@baton-dx/cli 0.1.0

package/dist/index.mjs

@@ -0,0 +1,3053 @@
+#!/usr/bin/env node
+import { t as findSourceRoot } from "./context-detection-0m8_Fp0j.mjs";
+import { access, mkdir, readFile, readdir, rm, rmdir, stat, unlink, writeFile } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defineCommand, runMain } from "citty";
+import { getAgentConfig, getAgentPath, getAllAgentKeys } from "@baton-dx/agent-paths";
+import { FileNotFoundError, KEBAB_CASE_REGEX, SourceParseError, addGlobalSource, clearAgentCache, clearIdeCache, cloneGitSource, collectProfileSupportPatterns, computeIntersection, detectInstalledAgents, detectInstalledIdes, detectLegacyPaths, discoverProfilesInSourceRepo, findSourceManifest, generateLock, getAdaptersForKeys, getDefaultGlobalSource, getGlobalAiTools, getGlobalIdePlatforms, getGlobalSources, getIdePlatformTargetDir, getProfileWeight, getRegisteredIdePlatforms, idePlatformRegistry, isKnownIdePlatform, isLockedProfile, loadLockfile, loadProfileManifest, loadProjectManifest, mergeContentParts, mergeMemory, mergeMemoryWithWarnings, mergeRules, mergeRulesWithWarnings, mergeSkills, mergeSkillsWithWarnings, parseFrontmatter, parseSource, placeFile, readLock, removeGlobalSource, resolveProfileChain, resolveProfileSupport, resolveVersion, setGlobalAiTools, setGlobalIdePlatforms, sortProfilesByWeight, updateGitignore, writeLock } from "@baton-dx/core";
+import * as p from "@clack/prompts";
+import { homedir } from "node:os";
+import { parse, stringify } from "yaml";
+import Handlebars from "handlebars";
+import simpleGit from "simple-git";
+
+//#region src/commands/ai-tools/list.ts
+const aiToolsListCommand = defineCommand({
+	meta: {
+		name: "list",
+		description: "Show saved AI tools from global config and their configuration status"
+	},
+	args: {
+		all: {
+			type: "boolean",
+			alias: "a",
+			description: "Show all supported tools, not just saved ones"
+		},
+		json: {
+			type: "boolean",
+			description: "Output machine-readable JSON",
+			alias: "j"
+		}
+	},
+	async run({ args }) {
+		if (!args.json) p.intro("Baton - AI Tools");
+		const savedTools = await getGlobalAiTools();
+		const allAgentKeys = getAllAgentKeys();
+		const keysToShow = args.all ? allAgentKeys : savedTools.length > 0 ? savedTools : allAgentKeys;
+		const agentStatuses = await Promise.all(keysToShow.map(async (agentKey) => {
+			const isSaved = savedTools.includes(agentKey);
+			let skillCount = 0;
+			let ruleCount = 0;
+			let agentCount = 0;
+			let memoryCount = 0;
+			let commandCount = 0;
+			if (isSaved) {
+				skillCount = await countConfigs(agentKey, "skills", "project");
+				ruleCount = await countConfigs(agentKey, "rules", "project");
+				agentCount = await countConfigs(agentKey, "agents", "project");
+				memoryCount = await countConfigs(agentKey, "memory", "project");
+				commandCount = await countConfigs(agentKey, "commands", "project");
+			}
+			const paths = {
+				skills: getAgentPath(agentKey, "skills", "project", ""),
+				rules: getAgentPath(agentKey, "rules", "project", ""),
+				agents: getAgentPath(agentKey, "agents", "project", ""),
+				memory: getAgentPath(agentKey, "memory", "project", ""),
+				commands: getAgentPath(agentKey, "commands", "project", "")
+			};
+			return {
+				key: agentKey,
+				name: getAgentConfig(agentKey).name,
+				saved: isSaved,
+				counts: {
+					skills: skillCount,
+					rules: ruleCount,
+					agents: agentCount,
+					memory: memoryCount,
+					commands: commandCount
+				},
+				paths
+			};
+		}));
+		if (args.json) {
+			console.log(JSON.stringify(agentStatuses, null, 2));
+			return;
+		}
+		if (savedTools.length === 0) {
+			p.log.warn("No AI tools saved in global config.");
+			p.log.info("Run 'baton ai-tools scan' to detect and save your AI tools.");
+			console.log("");
+			p.log.info(`All ${allAgentKeys.length} supported tools:`);
+			for (const key of allAgentKeys) {
+				const config = getAgentConfig(key);
+				console.log(`  \x1b[90m- ${config.name}\x1b[0m`);
+			}
+			p.outro("Run 'baton ai-tools scan' to get started.");
+			return;
+		}
+		console.log(`\nSaved AI tools (${savedTools.length}):\n`);
+		for (const agent of agentStatuses) {
+			const statusColor = agent.saved ? "\x1B[32m" : "\x1B[90m";
+			const status = agent.saved ? "✓" : "✗";
+			console.log(`${statusColor}${status} ${agent.name.padEnd(20)}`);
+			if (agent.saved) {
+				if (agent.counts.skills + agent.counts.rules + agent.counts.agents + agent.counts.memory + agent.counts.commands > 0) {
+					const details = [];
+					if (agent.counts.skills > 0) details.push(`${agent.counts.skills} skills`);
+					if (agent.counts.rules > 0) details.push(`${agent.counts.rules} rules`);
+					if (agent.counts.agents > 0) details.push(`${agent.counts.agents} agents`);
+					if (agent.counts.memory > 0) details.push(`${agent.counts.memory} memory`);
+					if (agent.counts.commands > 0) details.push(`${agent.counts.commands} commands`);
+					console.log(`  → ${details.join(", ")}`);
+				}
+			}
+			console.log("");
+		}
+		p.outro("Manage tools: 'baton ai-tools scan' (detect) | 'baton config set default-tools <tools>'");
+	}
+});
+/**
+* Count config files of a given type for an agent
+*/
+async function countConfigs(agentKey, configType, scope) {
+	try {
+		const dirPath = getAgentPath(agentKey, configType, scope, "").replace(/{name}.*$/, "").replace(/\/$/, "");
+		if (!(await stat(dirPath)).isDirectory()) return 0;
+		return (await readdir(dirPath)).length;
+	} catch (_error) {
+		return 0;
+	}
+}
+
+//#endregion
+//#region src/commands/ai-tools/scan.ts
+const aiToolsScanCommand = defineCommand({
+	meta: {
+		name: "scan",
+		description: "Scan your system for AI tools and save results to global config"
+	},
+	args: { yes: {
+		type: "boolean",
+		alias: "y",
+		description: "Automatically save detected tools without confirmation"
+	} },
+	async run({ args }) {
+		p.intro("Baton - AI Tool Scanner");
+		const spinner = p.spinner();
+		spinner.start("Scanning for AI tools...");
+		clearAgentCache();
+		const detectedAgents = await detectInstalledAgents();
+		const allAgentKeys = getAllAgentKeys();
+		const currentTools = await getGlobalAiTools();
+		spinner.stop("Scan complete.");
+		const installed = [];
+		const notInstalled = [];
+		for (const agentKey of allAgentKeys) {
+			const entry = {
+				key: agentKey,
+				name: getAgentConfig(agentKey).name
+			};
+			if (detectedAgents.includes(agentKey)) installed.push(entry);
+			else notInstalled.push(entry);
+		}
+		if (installed.length > 0) {
+			p.log.success(`Found ${installed.length} AI tool${installed.length !== 1 ? "s" : ""}:`);
+			for (const agent of installed) {
+				const badge = currentTools.includes(agent.key) ? " (saved)" : " (new)";
+				console.log(`  \x1b[32m✓\x1b[0m ${agent.name}${badge}`);
+			}
+		} else {
+			p.log.warn("No AI tools detected on your system.");
+			p.outro("Scan finished.");
+			return;
+		}
+		if (notInstalled.length > 0) {
+			console.log("");
+			p.log.info(`Not detected (${notInstalled.length}):`);
+			for (const agent of notInstalled) console.log(`  \x1b[90m✗ ${agent.name}\x1b[0m`);
+		}
+		const detectedKeys = installed.map((a) => a.key);
+		if (detectedKeys.length !== currentTools.length || detectedKeys.some((key) => !currentTools.includes(key))) {
+			console.log("");
+			let shouldSave = args.yes;
+			if (!shouldSave) {
+				const confirm = await p.confirm({ message: "Save detected tools to global config (~/.baton/config.yaml)?" });
+				if (p.isCancel(confirm)) {
+					p.outro("Scan finished (not saved).");
+					return;
+				}
+				shouldSave = confirm;
+			}
+			if (shouldSave) {
+				await setGlobalAiTools(detectedKeys);
+				p.log.success("Tools saved to global config.");
+			}
+		} else {
+			console.log("");
+			p.log.info("Global config is already up to date.");
+		}
+		p.outro("Scan finished.");
+	}
+});
+
+//#endregion
+//#region src/commands/ai-tools/index.ts
+const aiToolsCommand = defineCommand({
+	meta: {
+		name: "ai-tools",
+		description: "Manage AI tool detection and configuration"
+	},
+	subCommands: {
+		list: aiToolsListCommand,
+		scan: aiToolsScanCommand
+	}
+});
+
+//#endregion
+//#region src/utils/build-intersection.ts
+/**
+* Compute the intersection for a single profile source string.
+* Shared utility used by sync, config, and manage commands.
+*
+* @returns IntersectionResult or null if intersection cannot be computed
+*/
+async function buildIntersection(sourceString, developerTools, cwd) {
+	const parsed = parseSource(sourceString);
+	let repoRoot;
+	let profileDir;
+	if (parsed.provider === "github" || parsed.provider === "gitlab") {
+		repoRoot = (await cloneGitSource({
+			url: parsed.url,
+			ref: parsed.ref,
+			useCache: true
+		})).localPath;
+		profileDir = parsed.subpath ? resolve(repoRoot, parsed.subpath) : repoRoot;
+	} else if (parsed.provider === "local" || parsed.provider === "file") {
+		const absolutePath = parsed.path.startsWith("/") ? parsed.path : resolve(cwd, parsed.path);
+		profileDir = absolutePath;
+		repoRoot = await findSourceRoot(absolutePath, { fallbackToStart: true });
+	} else return null;
+	let sourceManifest;
+	try {
+		sourceManifest = await findSourceManifest(repoRoot);
+	} catch {
+		sourceManifest = {
+			name: "unknown",
+			version: "0.0.0"
+		};
+	}
+	const profileManifest = await loadProfileManifest(resolve(profileDir, "baton.profile.yaml")).catch(() => null);
+	if (!profileManifest) return null;
+	return computeIntersection(developerTools, resolveProfileSupport(profileManifest, sourceManifest));
+}
+
+//#endregion
+//#region src/utils/intersection-display.ts
+/**
+* Display the intersection between developer tools and profile support.
+* Shows which tools/platforms will be synced, which are unsupported, and which are unavailable.
+*
+* Used by `baton init` (after profile selection) and `baton manage` (overview).
+*/
+function displayIntersection(intersection) {
+	const hasAiData = intersection.aiTools.synced.length > 0 || intersection.aiTools.unsupported.length > 0 || intersection.aiTools.unavailable.length > 0;
+	const hasIdeData = intersection.idePlatforms.synced.length > 0 || intersection.idePlatforms.unsupported.length > 0 || intersection.idePlatforms.unavailable.length > 0;
+	if (!hasAiData && !hasIdeData) {
+		p.log.info("No tool or IDE intersection data available.");
+		return;
+	}
+	if (hasAiData) displayDimension("AI Tools", intersection.aiTools);
+	if (hasIdeData) displayDimension("IDE Platforms", intersection.idePlatforms);
+}
+/**
+* Display a single dimension (AI tools or IDE platforms) of the intersection.
+*/
+function displayDimension(label, dimension) {
+	const lines = [];
+	if (dimension.synced.length > 0) for (const item of dimension.synced) lines.push(`  \u2713 ${item}`);
+	if (dimension.unavailable.length > 0) for (const item of dimension.unavailable) lines.push(`  - ${item} (not installed)`);
+	if (dimension.unsupported.length > 0) for (const item of dimension.unsupported) lines.push(`  ~ ${item} (not supported by profile)`);
+	if (lines.length > 0) p.note(lines.join("\n"), label);
+}
+/**
+* Format a compact intersection summary for inline display.
+* Example: "claude-code, cursor (AI) + vscode (IDE)"
+*/
+function formatIntersectionSummary(intersection) {
+	const parts = [];
+	if (intersection.aiTools.synced.length > 0) parts.push(`${intersection.aiTools.synced.join(", ")} (AI)`);
+	if (intersection.idePlatforms.synced.length > 0) parts.push(`${intersection.idePlatforms.synced.join(", ")} (IDE)`);
+	if (parts.length === 0) return "No matching tools";
+	return parts.join(" + ");
+}
+
+//#endregion
+//#region src/commands/config.ts
+const CONFIG_FILE = join(homedir(), ".baton", "config.yaml");
+const VALID_KEYS = [
+	"cache-dir",
+	"default-scope",
+	"symlink-mode",
+	"default-tools"
+];
+async function loadConfig() {
+	try {
+		await access(CONFIG_FILE);
+	} catch {
+		return {};
+	}
+	return parse(await readFile(CONFIG_FILE, "utf-8"));
+}
+async function saveConfig(config) {
+	await mkdir(dirname(CONFIG_FILE), { recursive: true });
+	await writeFile(CONFIG_FILE, stringify(config), "utf-8");
+}
+async function showDashboard() {
+	p.intro("Baton Dashboard");
+	const [sources, aiTools, idePlatforms, projectManifest] = await Promise.all([
+		getGlobalSources(),
+		getGlobalAiTools(),
+		getGlobalIdePlatforms(),
+		loadProjectManifestSafe$1()
+	]);
+	console.log("");
+	p.log.step("Global Sources");
+	if (sources.length === 0) p.log.info("  No sources configured. Run: baton source connect <url>");
+	else for (const source of sources) {
+		const defaultBadge = source.default ? " (default)" : "";
+		const desc = source.description ? ` — ${source.description}` : "";
+		p.log.info(`  ${source.name}${defaultBadge}: ${source.url}${desc}`);
+	}
+	console.log("");
+	p.log.step("Developer Tools");
+	if (aiTools.length === 0 && idePlatforms.length === 0) p.log.info("  No tools configured. Run: baton ai-tools scan && baton ides scan");
+	else {
+		if (aiTools.length > 0) {
+			const toolNames = aiTools.map((key) => {
+				try {
+					return getAgentConfig(key).name;
+				} catch {
+					return key;
+				}
+			});
+			p.log.info(`  AI Tools: ${toolNames.join(", ")}`);
+		}
+		if (idePlatforms.length > 0) p.log.info(`  IDE Platforms: ${idePlatforms.join(", ")}`);
+	}
+	console.log("");
+	p.log.step("Current Project");
+	if (!projectManifest) p.log.info("  Not inside a Baton project. Run: baton init");
+	else if (projectManifest.profiles.length === 0) p.log.info("  No profiles installed. Run: baton manage");
+	else for (const profile of projectManifest.profiles) {
+		const version = profile.version ? ` (${profile.version})` : "";
+		p.log.info(`  ${profile.source}${version}`);
+	}
+	if (projectManifest && projectManifest.profiles.length > 0) {
+		if (aiTools.length > 0 || idePlatforms.length > 0) {
+			const developerTools = {
+				aiTools,
+				idePlatforms
+			};
+			console.log("");
+			p.log.step("Active Intersections");
+			for (const profile of projectManifest.profiles) try {
+				const intersection = await buildIntersection(profile.source, developerTools, process.cwd());
+				if (intersection) {
+					const summary = formatIntersectionSummary(intersection);
+					p.log.info(`  ${profile.source}: ${summary}`);
+				}
+			} catch {}
+		}
+	}
+	console.log("");
+	p.outro("Use 'baton config list' to view configuration settings");
+}
+async function loadProjectManifestSafe$1() {
+	try {
+		return await loadProjectManifest(join(process.cwd(), "baton.yaml"));
+	} catch {
+		return null;
+	}
+}
+const configCommand = defineCommand({
+	meta: {
+		name: "config",
+		description: "Show Baton dashboard overview or configure settings (set, get, list)"
+	},
+	args: {
+		action: {
+			type: "positional",
+			description: "Action: set, get, or list",
+			required: false
+		},
+		key: {
+			type: "positional",
+			description: "Configuration key",
+			required: false
+		},
+		value: {
+			type: "positional",
+			description: "Configuration value (for set)",
+			required: false
+		}
+	},
+	async run({ args }) {
+		const action = args.action;
+		const key = args.key;
+		const value = args.value;
+		if (!action) {
+			await showDashboard();
+			return;
+		}
+		const selectedAction = action;
+		if (selectedAction === "list") {
+			p.intro("⚙️  Baton Configuration");
+			const config = await loadConfig();
+			if (Object.keys(config).length === 0) {
+				p.outro("No configuration set. Using defaults.");
+				return;
+			}
+			console.log("");
+			for (const [configKey, configValue] of Object.entries(config)) console.log(`${configKey}: ${Array.isArray(configValue) ? configValue.join(", ") : configValue}`);
+			console.log("");
+			p.outro("Configuration loaded");
+			return;
+		}
+		if (selectedAction === "get") {
+			if (!key) {
+				p.intro("⚙️  Baton Configuration");
+				p.outro("Error: Missing key argument. Usage: baton config get <key>");
+				process.exit(1);
+			}
+			if (!VALID_KEYS.includes(key)) {
+				p.intro("⚙️  Baton Configuration");
+				p.outro(`Error: Invalid key "${key}". Valid keys: ${VALID_KEYS.join(", ")}`);
+				process.exit(1);
+			}
+			const configValue = (await loadConfig())[key];
+			if (configValue === void 0) {
+				p.intro("⚙️  Baton Configuration");
+				p.outro(`"${key}" is not set (using default)`);
+				return;
+			}
+			console.log(Array.isArray(configValue) ? configValue.join(", ") : configValue);
+			return;
+		}
+		if (selectedAction === "set") {
+			if (!key || !value) {
+				p.intro("⚙️  Baton Configuration");
+				p.outro("Error: Missing arguments. Usage: baton config set <key> <value>");
+				process.exit(1);
+			}
+			if (!VALID_KEYS.includes(key)) {
+				p.intro("⚙️  Baton Configuration");
+				p.outro(`Error: Invalid key "${key}". Valid keys: ${VALID_KEYS.join(", ")}`);
+				process.exit(1);
+			}
+			p.intro("⚙️  Baton Configuration");
+			const config = await loadConfig();
+			if (key === "default-scope") {
+				if (value !== "project" && value !== "global") {
+					p.outro("Error: default-scope must be either \"project\" or \"global\"");
+					process.exit(1);
+				}
+				config["default-scope"] = value;
+			} else if (key === "symlink-mode") {
+				if (value !== "true" && value !== "false") {
+					p.outro("Error: symlink-mode must be either \"true\" or \"false\"");
+					process.exit(1);
+				}
+				config["symlink-mode"] = value === "true";
+			} else if (key === "default-tools") config["default-tools"] = value.split(",").map((s) => s.trim());
+			else if (key === "cache-dir") config["cache-dir"] = value;
+			await saveConfig(config);
+			p.outro(`✓ Set ${key} = ${Array.isArray(config[key]) ? config[key].join(", ") : config[key]}`);
+			return;
+		}
+		p.intro("⚙️  Baton Configuration");
+		p.outro(`Error: Unknown action "${selectedAction}". Use: set, get, or list`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/commands/diff.ts
+const diffCommand = defineCommand({
+	meta: {
+		name: "diff",
+		description: "Compare local installed files with remote source versions to see what changed"
+	},
+	args: { nameOnly: {
+		type: "boolean",
+		description: "Show only changed filenames without content diff",
+		alias: "n"
+	} },
+	async run({ args }) {
+		p.intro("🔍 Baton Diff");
+		try {
+			const projectRoot = process.cwd();
+			const manifest = await loadProjectManifest(resolve(projectRoot, "baton.yaml"));
+			if (!manifest.profiles || manifest.profiles.length === 0) {
+				p.outro("⚠️  No profiles configured in baton.yaml");
+				process.exit(0);
+			}
+			const spinner = p.spinner();
+			spinner.start("Resolving profile chain...");
+			const allProfiles = [];
+			const profileLocalPaths = /* @__PURE__ */ new Map();
+			for (const profileSource of manifest.profiles) try {
+				const parsed = parseSource(profileSource.source);
+				let profileManifestPath;
+				let localPath;
+				if (parsed.provider === "local" || parsed.provider === "file") {
+					localPath = parsed.path.startsWith("/") ? parsed.path : resolve(projectRoot, parsed.path);
+					profileManifestPath = resolve(localPath, "baton.profile.yaml");
+				} else if (parsed.provider === "npm") {
+					spinner.message("NPM provider not yet supported for diff");
+					continue;
+				} else {
+					const url = parsed.url;
+					const subpath = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.subpath : void 0;
+					const cloned = await cloneGitSource({
+						url,
+						ref: profileSource.version || void 0,
+						subpath,
+						useCache: false
+					});
+					localPath = cloned.localPath;
+					profileManifestPath = resolve(cloned.localPath, "baton.profile.yaml");
+				}
+				const profileManifest = await loadProfileManifest(profileManifestPath);
+				const profileDir = dirname(profileManifestPath);
+				const chain = await resolveProfileChain(profileManifest, profileSource.source, profileDir);
+				for (const prof of chain) profileLocalPaths.set(prof.name, localPath);
+				allProfiles.push(...chain);
+			} catch (error) {
+				spinner.message(`Failed to resolve profile ${profileSource.source}: ${error instanceof Error ? error.message : error}`);
+			}
+			if (allProfiles.length === 0) {
+				spinner.stop("No profiles resolved");
+				p.outro("Nothing to diff. Run `baton manage` to add a profile.");
+				process.exit(0);
+			}
+			spinner.stop(`Resolved ${allProfiles.length} profile(s)`);
+			spinner.start("Merging configurations...");
+			const mergedSkills = mergeSkills(allProfiles);
+			const mergedRules = mergeRules(allProfiles);
+			const mergedMemory = mergeMemory(allProfiles);
+			const commandMap = /* @__PURE__ */ new Map();
+			for (const profile of allProfiles) for (const cmd of profile.manifest.ai?.commands || []) commandMap.set(cmd, profile.name);
+			const fileMap = /* @__PURE__ */ new Map();
+			for (const profile of allProfiles) for (const fileConfig of profile.manifest.files || []) {
+				const target = fileConfig.target || fileConfig.source;
+				fileMap.set(target, {
+					source: fileConfig.source,
+					target,
+					profileName: profile.name
+				});
+			}
+			const ideMap = /* @__PURE__ */ new Map();
+			for (const profile of allProfiles) {
+				if (!profile.manifest.ide) continue;
+				for (const [ideKey, files] of Object.entries(profile.manifest.ide)) {
+					if (!files) continue;
+					const targetDir = getIdePlatformTargetDir(ideKey);
+					if (!targetDir) continue;
+					for (const fileName of files) {
+						const targetPath = `${targetDir}/${fileName}`;
+						ideMap.set(targetPath, {
+							ideKey,
+							fileName,
+							targetDir,
+							profileName: profile.name
+						});
+					}
+				}
+			}
+			spinner.stop("Configurations merged");
+			spinner.start("Computing tool intersection...");
+			const globalAiTools = await getGlobalAiTools();
+			const detectedAgents = await detectInstalledAgents();
+			let syncedAiTools;
+			if (globalAiTools.length > 0) {
+				const developerTools = {
+					aiTools: globalAiTools,
+					idePlatforms: await getGlobalIdePlatforms()
+				};
+				const aggregatedSyncedAi = /* @__PURE__ */ new Set();
+				for (const profileSource of manifest.profiles) try {
+					const intersection = await buildIntersection(profileSource.source, developerTools, projectRoot);
+					if (intersection) for (const tool of intersection.aiTools.synced) aggregatedSyncedAi.add(tool);
+				} catch {}
+				syncedAiTools = aggregatedSyncedAi.size > 0 ? [...aggregatedSyncedAi] : [];
+			} else syncedAiTools = detectedAgents;
+			if (syncedAiTools.length === 0) {
+				spinner.stop("No AI tools in intersection");
+				p.cancel("No AI tools match. Run `baton ai-tools scan`.");
+				process.exit(1);
+			}
+			const adapters = getAdaptersForKeys(syncedAiTools);
+			spinner.stop(`Comparing for: ${syncedAiTools.join(", ")}`);
+			spinner.start("Comparing remote sources with placed files...");
+			const diffs = [];
+			const expectedPaths = /* @__PURE__ */ new Set();
+			const contentAccumulator = /* @__PURE__ */ new Map();
+			for (const adapter of adapters) for (const memoryEntry of mergedMemory) {
+				const contentParts = [];
+				for (const contribution of memoryEntry.contributions) {
+					const profileDir = profileLocalPaths.get(contribution.profileName);
+					if (!profileDir) continue;
+					const memoryFilePath = resolve(profileDir, "ai", "memory", memoryEntry.filename);
+					try {
+						contentParts.push(await readFile(memoryFilePath, "utf-8"));
+					} catch {}
+				}
+				if (contentParts.length === 0) continue;
+				const mergedContent = mergeContentParts(contentParts, memoryEntry.mergeStrategy);
+				const transformed = adapter.transformMemory({
+					filename: memoryEntry.filename,
+					content: mergedContent
+				});
+				const absolutePath = resolveAbsolutePath(adapter.getPath("memory", "project", transformed.filename), projectRoot);
+				const relativePath = toRelativePath(absolutePath, projectRoot);
+				expectedPaths.add(relativePath);
+				const existing = contentAccumulator.get(relativePath);
+				if (existing) existing.parts.push(transformed.content);
+				else contentAccumulator.set(relativePath, {
+					parts: [transformed.content],
+					absolutePath
+				});
+			}
+			for (const adapter of adapters) for (const skillItem of mergedSkills) {
+				const profileDir = profileLocalPaths.get(skillItem.profileName);
+				if (!profileDir) continue;
+				const skillSourceDir = resolve(profileDir, "ai", "skills", skillItem.name);
+				try {
+					await stat(skillSourceDir);
+				} catch {
+					continue;
+				}
+				const absoluteTargetDir = resolveAbsolutePath(adapter.getPath("skills", skillItem.scope, skillItem.name), projectRoot);
+				const remoteSkillFiles = await loadFilesFromDirectory(skillSourceDir);
+				const localSkillFiles = await loadFilesFromDirectory(absoluteTargetDir);
+				for (const [file, remoteContent] of Object.entries(remoteSkillFiles)) {
+					const relPath = toRelativePath(resolve(absoluteTargetDir, file), projectRoot);
+					expectedPaths.add(relPath);
+					addDiffEntry(diffs, relPath, remoteContent, localSkillFiles[file] ?? void 0);
+				}
+				for (const file of Object.keys(localSkillFiles)) {
+					const relPath = toRelativePath(resolve(absoluteTargetDir, file), projectRoot);
+					if (!expectedPaths.has(relPath)) addDiffEntry(diffs, relPath, void 0, localSkillFiles[file]);
+				}
+			}
+			for (const adapter of adapters) for (const ruleEntry of mergedRules) {
+				const isUniversal = ruleEntry.agents.length === 0;
+				const isForThisAdapter = ruleEntry.agents.includes(adapter.key);
+				if (!isUniversal && !isForThisAdapter) continue;
+				const profileDir = profileLocalPaths.get(ruleEntry.profileName);
+				if (!profileDir) continue;
+				const ruleSourcePath = resolve(profileDir, "ai", "rules", isUniversal ? "universal" : ruleEntry.agents[0], `${ruleEntry.name}.md`);
+				let rawContent;
+				try {
+					rawContent = await readFile(ruleSourcePath, "utf-8");
+				} catch {
+					continue;
+				}
+				const parsed = parseFrontmatter(rawContent);
+				const ruleFile = {
+					name: ruleEntry.name,
+					content: rawContent,
+					frontmatter: Object.keys(parsed.data).length > 0 ? parsed.data : void 0
+				};
+				const transformed = adapter.transformRule(ruleFile);
+				const absolutePath = resolveAbsolutePath(adapter.getPath("rules", "project", ruleEntry.name), projectRoot);
+				const relativePath = toRelativePath(absolutePath, projectRoot);
+				expectedPaths.add(relativePath);
+				const existing = contentAccumulator.get(relativePath);
+				if (existing) existing.parts.push(transformed.content);
+				else contentAccumulator.set(relativePath, {
+					parts: [transformed.content],
+					absolutePath
+				});
+			}
+			for (const [relativePath, entry] of contentAccumulator) addDiffEntry(diffs, relativePath, entry.parts.join("\n\n"), await readSafe(entry.absolutePath));
+			for (const adapter of adapters) for (const [commandName, profileName] of commandMap) {
+				const profileDir = profileLocalPaths.get(profileName);
+				if (!profileDir) continue;
+				const commandSourcePath = resolve(profileDir, "ai", "commands", `${commandName}.md`);
+				let content;
+				try {
+					content = await readFile(commandSourcePath, "utf-8");
+				} catch {
+					continue;
+				}
+				const absolutePath = resolveAbsolutePath(adapter.getPath("commands", "project", commandName), projectRoot);
+				const relativePath = toRelativePath(absolutePath, projectRoot);
+				expectedPaths.add(relativePath);
+				addDiffEntry(diffs, relativePath, content, await readSafe(absolutePath));
+			}
+			for (const fileEntry of fileMap.values()) {
+				const profileDir = profileLocalPaths.get(fileEntry.profileName);
+				if (!profileDir) continue;
+				const fileSourcePath = resolve(profileDir, "files", fileEntry.source);
+				let content;
+				try {
+					content = await readFile(fileSourcePath, "utf-8");
+				} catch {
+					continue;
+				}
+				const absolutePath = resolve(projectRoot, fileEntry.target);
+				const relativePath = fileEntry.target;
+				expectedPaths.add(relativePath);
+				addDiffEntry(diffs, relativePath, content, await readSafe(absolutePath));
+			}
+			for (const ideEntry of ideMap.values()) {
+				const profileDir = profileLocalPaths.get(ideEntry.profileName);
+				if (!profileDir) continue;
+				const ideSourcePath = resolve(profileDir, "ide", ideEntry.ideKey, ideEntry.fileName);
+				let content;
+				try {
+					content = await readFile(ideSourcePath, "utf-8");
+				} catch {
+					continue;
+				}
+				const absolutePath = resolve(projectRoot, ideEntry.targetDir, ideEntry.fileName);
+				const relativePath = `${ideEntry.targetDir}/${ideEntry.fileName}`;
+				expectedPaths.add(relativePath);
+				addDiffEntry(diffs, relativePath, content, await readSafe(absolutePath));
+			}
+			spinner.stop();
+			if (diffs.length === 0) {
+				p.log.success("No differences found");
+				p.outro("✅ Diff complete - all placed files match remote sources");
+				process.exit(0);
+			}
+			p.log.warning(`${diffs.length} file(s) with differences`);
+			for (const diff of diffs) if (args.nameOnly) {
+				const statusSymbol = diff.status === "added" ? "+" : diff.status === "removed" ? "-" : "~";
+				console.log(`  ${statusSymbol} ${diff.file}`);
+			} else {
+				console.log(`\n  📄 ${diff.file} (${diff.status})`);
+				if (diff.status === "modified") {
+					const localLines = (diff.localContent || "").split("\n");
+					const remoteLines = (diff.remoteContent || "").split("\n");
+					const maxLines = Math.max(localLines.length, remoteLines.length);
+					let diffLines = 0;
+					for (let i = 0; i < maxLines && diffLines < 10; i++) {
+						const localLine = localLines[i] || "";
+						const remoteLine = remoteLines[i] || "";
+						if (localLine !== remoteLine) {
+							diffLines++;
+							if (localLine) console.log(`  \x1b[31m- ${localLine}\x1b[0m`);
+							if (remoteLine) console.log(`  \x1b[32m+ ${remoteLine}\x1b[0m`);
+						}
+					}
+					if (diffLines >= 10) console.log("  ... (more differences)");
+				} else if (diff.status === "added") console.log("  \x1B[32m+ New file in remote (not yet placed locally)\x1B[0m");
+				else console.log("  \x1B[31m- File exists locally but not in remote\x1B[0m");
+			}
+			p.outro("✅ Diff complete - differences found. Run `baton sync` to update.");
+			process.exit(1);
+		} catch (error) {
+			p.log.error(`Failed to run diff: ${error instanceof Error ? error.message : "Unknown error"}`);
+			process.exit(1);
+		}
+	}
+});
+/**
+* Add a diff entry if remote and local content differ.
+*/
+function addDiffEntry(diffs, file, remoteContent, localContent) {
+	if (diffs.some((d) => d.file === file)) return;
+	if (remoteContent !== void 0 && localContent === void 0) diffs.push({
+		file,
+		status: "added",
+		remoteContent
+	});
+	else if (remoteContent === void 0 && localContent !== void 0) diffs.push({
+		file,
+		status: "removed",
+		localContent
+	});
+	else if (remoteContent !== void 0 && localContent !== void 0 && remoteContent !== localContent) diffs.push({
+		file,
+		status: "modified",
+		remoteContent,
+		localContent
+	});
+}
+/**
+* Read a file safely, returning undefined if it doesn't exist.
+*/
+async function readSafe(path) {
+	try {
+		return await readFile(path, "utf-8");
+	} catch {
+		return;
+	}
+}
+/**
+* Resolve a path to absolute, handling both absolute and relative paths.
+*/
+function resolveAbsolutePath(path, projectRoot) {
+	if (path.startsWith("/")) return path;
+	return resolve(projectRoot, path);
+}
+/**
+* Convert an absolute path to a relative path from project root.
+*/
+function toRelativePath(absolutePath, projectRoot) {
+	if (absolutePath.startsWith(projectRoot)) {
+		const rel = absolutePath.slice(projectRoot.length);
+		return rel.startsWith("/") ? rel.slice(1) : rel;
+	}
+	return absolutePath;
+}
+/**
+* Load all files from a directory recursively
+*/
+async function loadFilesFromDirectory(dirPath) {
+	const files = {};
+	try {
+		const entries = await readdir(dirPath, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = resolve(dirPath, entry.name);
+			if (entry.isDirectory()) {
+				const subFiles = await loadFilesFromDirectory(fullPath);
+				for (const [subPath, content] of Object.entries(subFiles)) files[`${entry.name}/${subPath}`] = content;
+			} else if (entry.isFile()) {
+				const content = await readFile(fullPath, "utf-8");
+				files[entry.name] = content;
+			}
+		}
+	} catch {
+		return {};
+	}
+	return files;
+}
+
+//#endregion
+//#region src/commands/ides/utils.ts
+/**
+* Format an IDE platform key into a display name.
+*/
+function formatIdeName(ideKey) {
+	return {
+		vscode: "VS Code",
+		jetbrains: "JetBrains",
+		cursor: "Cursor",
+		windsurf: "Windsurf",
+		antigravity: "Antigravity",
+		zed: "Zed"
+	}[ideKey] ?? ideKey;
+}
+
+//#endregion
+//#region src/commands/ides/list.ts
+const idesListCommand = defineCommand({
+	meta: {
+		name: "list",
+		description: "Show saved IDE platforms from global config"
+	},
+	args: {
+		all: {
+			type: "boolean",
+			alias: "a",
+			description: "Show all supported platforms, not just saved ones"
+		},
+		json: {
+			type: "boolean",
+			description: "Output machine-readable JSON",
+			alias: "j"
+		}
+	},
+	async run({ args }) {
+		if (!args.json) p.intro("Baton - IDE Platforms");
+		const savedPlatforms = await getGlobalIdePlatforms();
+		const allIdeKeys = getRegisteredIdePlatforms();
+		const platformStatuses = (args.all ? allIdeKeys : savedPlatforms.length > 0 ? savedPlatforms : allIdeKeys).map((ideKey) => {
+			const isSaved = savedPlatforms.includes(ideKey);
+			const entry = idePlatformRegistry[ideKey];
+			return {
+				key: ideKey,
+				name: formatIdeName(ideKey),
+				saved: isSaved,
+				targetDir: entry?.targetDir ?? "unknown"
+			};
+		});
+		if (args.json) {
+			console.log(JSON.stringify(platformStatuses, null, 2));
+			return;
+		}
+		if (savedPlatforms.length === 0) {
+			p.log.warn("No IDE platforms saved in global config.");
+			p.log.info("Run 'baton ides scan' to detect and save your IDE platforms.");
+			console.log("");
+			p.log.info(`All ${allIdeKeys.length} supported platforms:`);
+			for (const key of allIdeKeys) {
+				const entry = idePlatformRegistry[key];
+				console.log(`  \x1b[90m- ${formatIdeName(key)} (${entry?.targetDir ?? key})\x1b[0m`);
+			}
+			p.outro("Run 'baton ides scan' to get started.");
+			return;
+		}
+		console.log(`\nSaved IDE platforms (${savedPlatforms.length}):\n`);
+		for (const platform of platformStatuses) {
+			const statusColor = platform.saved ? "\x1B[32m" : "\x1B[90m";
+			const status = platform.saved ? "✓" : "✗";
+			console.log(`${statusColor}${status} ${platform.name.padEnd(20)} → ${platform.targetDir}`);
+		}
+		console.log("");
+		p.outro("Manage platforms: 'baton ides scan' (detect)");
+	}
+});
+
+//#endregion
+//#region src/commands/ides/scan.ts
+const idesScanCommand = defineCommand({
+	meta: {
+		name: "scan",
+		description: "Scan your system for IDE platforms and save results to global config"
+	},
+	args: { yes: {
+		type: "boolean",
+		alias: "y",
+		description: "Automatically save detected platforms without confirmation"
+	} },
+	async run({ args }) {
+		p.intro("Baton - IDE Platform Scanner");
+		const spinner = p.spinner();
+		spinner.start("Scanning for IDE platforms...");
+		clearIdeCache();
+		const detectedIdes = await detectInstalledIdes();
+		const allIdeKeys = getRegisteredIdePlatforms();
+		const currentPlatforms = await getGlobalIdePlatforms();
+		spinner.stop("Scan complete.");
+		const installed = [];
+		const notInstalled = [];
+		for (const ideKey of allIdeKeys) {
+			const entry = {
+				key: ideKey,
+				name: formatIdeName(ideKey)
+			};
+			if (detectedIdes.includes(ideKey)) installed.push(entry);
+			else notInstalled.push(entry);
+		}
+		if (installed.length > 0) {
+			p.log.success(`Found ${installed.length} IDE platform${installed.length !== 1 ? "s" : ""}:`);
+			for (const ide of installed) {
+				const badge = currentPlatforms.includes(ide.key) ? " (saved)" : " (new)";
+				console.log(`  \x1b[32m✓\x1b[0m ${ide.name}${badge}`);
+			}
+		} else {
+			p.log.warn("No IDE platforms detected on your system.");
+			p.outro("Scan finished.");
+			return;
+		}
+		if (notInstalled.length > 0) {
+			console.log("");
+			p.log.info(`Not detected (${notInstalled.length}):`);
+			for (const ide of notInstalled) console.log(`  \x1b[90m✗ ${ide.name}\x1b[0m`);
+		}
+		const detectedKeys = installed.map((i) => i.key);
+		if (detectedKeys.length !== currentPlatforms.length || detectedKeys.some((key) => !currentPlatforms.includes(key))) {
+			console.log("");
+			let shouldSave = args.yes;
+			if (!shouldSave) {
+				const confirm = await p.confirm({ message: "Save detected platforms to global config (~/.baton/config.yaml)?" });
+				if (p.isCancel(confirm)) {
+					p.outro("Scan finished (not saved).");
+					return;
+				}
+				shouldSave = confirm;
+			}
+			if (shouldSave) {
+				await setGlobalIdePlatforms(detectedKeys);
+				p.log.success("Platforms saved to global config.");
+			}
+		} else {
+			console.log("");
+			p.log.info("Global config is already up to date.");
+		}
+		p.outro("Scan finished.");
+	}
+});
+
+//#endregion
+//#region src/commands/ides/index.ts
+const idesCommand = defineCommand({
+	meta: {
+		name: "ides",
+		description: "Manage IDE platform detection and configuration"
+	},
+	subCommands: {
+		list: idesListCommand,
+		scan: idesScanCommand
+	}
+});
+
+//#endregion
+//#region src/utils/profile-selection.ts
+/**
+* Discovers and prompts user to select a profile from a source.
+* Used by `baton init --profile` and `baton manage` (add profile).
+*
+* @param sourceString - Source string to discover profiles from (e.g., "github:org/repo")
+* @returns Final source string with selected profile path (e.g., "github:org/repo/frontend")
+*/
+async function selectProfileFromSource(sourceString) {
+	const parsedSource = parseSource(sourceString);
+	if ((parsedSource.provider === "github" || parsedSource.provider === "gitlab") && !parsedSource.subpath) {
+		const spinner = p.spinner();
+		spinner.start("Cloning repository to discover profiles...");
+		try {
+			const cloned = await cloneGitSource({
+				url: parsedSource.url,
+				ref: parsedSource.ref,
+				useCache: true
+			});
+			spinner.stop("✅ Repository cloned");
+			const profiles = await discoverProfilesInSourceRepo(cloned.localPath);
+			if (profiles.length === 0) {
+				p.cancel("❌ No profiles found in the source repository");
+				process.exit(1);
+			}
+			const selectedProfilePath = await p.select({
+				message: "Select a profile from this source:",
+				options: profiles.map((profile) => ({
+					value: profile.path,
+					label: profile.name,
+					hint: profile.description ? `${profile.description} (v${profile.version})` : `v${profile.version}`
+				}))
+			});
+			if (p.isCancel(selectedProfilePath)) {
+				p.cancel("❌ Profile selection cancelled");
+				process.exit(0);
+			}
+			if (selectedProfilePath === ".") return sourceString;
+			return `${parsedSource.ref ? `${parsedSource.provider}:${parsedSource.org}/${parsedSource.repo}@${parsedSource.ref}` : `${parsedSource.provider}:${parsedSource.org}/${parsedSource.repo}`}/${selectedProfilePath}`;
+		} catch (error) {
+			spinner.stop("❌ Failed to clone repository");
+			p.cancel(`❌ Failed to discover profiles: ${error instanceof Error ? error.message : String(error)}`);
+			process.exit(1);
+		}
+	}
+	if (parsedSource.provider === "file" || parsedSource.provider === "local") {
+		const profiles = await discoverProfilesInSourceRepo(parsedSource.path.startsWith("/") ? parsedSource.path : resolve(process.cwd(), parsedSource.path));
+		if (profiles.length === 0) return sourceString;
+		if (profiles.length === 1) return profiles[0].path === "." ? sourceString : `${sourceString}/${profiles[0].path}`;
+		const selectedProfilePath = await p.select({
+			message: "Select a profile from this source:",
+			options: profiles.map((profile) => ({
+				value: profile.path,
+				label: profile.name,
+				hint: profile.description ? `${profile.description} (v${profile.version})` : `v${profile.version}`
+			}))
+		});
+		if (p.isCancel(selectedProfilePath)) {
+			p.cancel("❌ Profile selection cancelled");
+			process.exit(0);
+		}
+		if (selectedProfilePath === ".") return sourceString;
+		return `${sourceString}/${selectedProfilePath}`;
+	}
+	return sourceString;
+}
+/**
+* Discovers and prompts user to select multiple profiles from a source.
+* Returns array of full source strings with profile paths.
+*
+* Used by `baton init` to allow installing multiple profiles at once.
+*
+* @param sourceString - Source string to discover profiles from (e.g., "github:org/repo")
+* @returns Array of source strings with selected profile paths (e.g., ["github:org/repo/frontend", "github:org/repo/backend"])
+*/
+async function selectMultipleProfilesFromSource(sourceString, options) {
+	const parsedSource = parseSource(sourceString);
+	if ((parsedSource.provider === "github" || parsedSource.provider === "gitlab") && !parsedSource.subpath) {
+		const spinner = p.spinner();
+		spinner.start("Cloning repository to discover profiles...");
+		try {
+			const cloned = await cloneGitSource({
+				url: parsedSource.url,
+				ref: parsedSource.ref,
+				useCache: true
+			});
+			spinner.stop("✅ Repository cloned");
+			const profiles = await discoverProfilesInSourceRepo(cloned.localPath);
+			if (profiles.length === 0) {
+				p.cancel("❌ No profiles found in the source repository");
+				process.exit(1);
+			}
+			if (profiles.length === 1) {
+				p.note(`Using profile: ${profiles[0].name}`, "Profile");
+				return [constructProfilePath(parsedSource, profiles[0].path)];
+			}
+			if (options?.nonInteractive) {
+				p.note(`Auto-selecting all ${profiles.length} profile(s)`, "Non-interactive mode");
+				return profiles.map((prof) => constructProfilePath(parsedSource, prof.path));
+			}
+			const selected = await p.multiselect({
+				message: "Select profile(s) to install: (Space to select, Enter to continue)",
+				options: profiles.map((prof) => ({
+					value: prof.path,
+					label: prof.name,
+					hint: prof.description ? `${prof.description} (v${prof.version})` : `v${prof.version}`
+				})),
+				required: true
+			});
+			if (p.isCancel(selected)) {
+				p.cancel("❌ Profile selection cancelled");
+				process.exit(0);
+			}
+			return selected.map((path) => constructProfilePath(parsedSource, path));
+		} catch (error) {
+			spinner.stop("❌ Failed to clone repository");
+			p.cancel(`❌ Failed to discover profiles: ${error instanceof Error ? error.message : String(error)}`);
+			process.exit(1);
+		}
+	}
+	if (parsedSource.provider === "file" || parsedSource.provider === "local") {
+		const profiles = await discoverProfilesInSourceRepo(parsedSource.path.startsWith("/") ? parsedSource.path : resolve(process.cwd(), parsedSource.path));
+		if (profiles.length === 0) return [sourceString];
+		if (profiles.length === 1) {
+			p.note(`Using profile: ${profiles[0].name}`, "Profile");
+			return [profiles[0].path === "." ? sourceString : `${sourceString}/${profiles[0].path}`];
+		}
+		if (options?.nonInteractive) {
+			p.note(`Auto-selecting all ${profiles.length} profile(s)`, "Non-interactive mode");
+			return profiles.map((prof) => prof.path === "." ? sourceString : `${sourceString}/${prof.path}`);
+		}
+		const selected = await p.multiselect({
+			message: "Select profile(s) to install: (Space to select, Enter to continue)",
+			options: profiles.map((prof) => ({
+				value: prof.path,
+				label: prof.name,
+				hint: prof.description ? `${prof.description} (v${prof.version})` : `v${prof.version}`
+			})),
+			required: true
+		});
+		if (p.isCancel(selected)) {
+			p.cancel("❌ Profile selection cancelled");
+			process.exit(0);
+		}
+		return selected.map((path) => path === "." ? sourceString : `${sourceString}/${path}`);
+	}
+	return [sourceString];
+}
+/**
+* Helper: Constructs full source path with profile subpath.
+*
+* @param parsed - Parsed source object (github or gitlab only)
+* @param profilePath - Profile path (e.g., ".", "frontend", "backend")
+* @returns Full source string (e.g., "github:org/repo/frontend")
+*/
+function constructProfilePath(parsed, profilePath) {
+	if (profilePath === ".") return parsed.ref ? `${parsed.provider}:${parsed.org}/${parsed.repo}@${parsed.ref}` : `${parsed.provider}:${parsed.org}/${parsed.repo}`;
+	return `${parsed.ref ? `${parsed.provider}:${parsed.org}/${parsed.repo}@${parsed.ref}` : `${parsed.provider}:${parsed.org}/${parsed.repo}`}/${profilePath}`;
+}
+
+//#endregion
+//#region src/utils/run-baton-sync.ts
+/**
+* Run `baton sync` as a child process, inheriting stdio for interactive output.
+*/
+async function runBatonSync(cwd) {
+	const { spawn } = await import("node:child_process");
+	await new Promise((done) => {
+		const syncProcess = spawn("baton", ["sync"], {
+			cwd,
+			stdio: "inherit"
+		});
+		syncProcess.on("close", (code) => {
+			if (code === 0) p.log.success("Profiles synced successfully!");
+			else p.log.warn(`Sync finished with exit code ${code}`);
+			done();
+		});
+		syncProcess.on("error", (error) => {
+			p.log.warn(`Failed to run sync: ${error.message}`);
+			done();
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/init.ts
+const initCommand = defineCommand({
+	meta: {
+		name: "init",
+		description: "Initialize Baton in your project with an interactive setup wizard"
+	},
+	args: {
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Skip all prompts and use defaults"
+		},
+		force: {
+			type: "boolean",
+			description: "Overwrite existing baton.yaml"
+		},
+		profile: {
+			type: "string",
+			description: "Profile source to install (skips profile selection)"
+		}
+	},
+	async run({ args }) {
+		const isInteractive = !args.yes;
+		const cwd = process.cwd();
+		p.intro("🎯 Welcome to Baton");
+		try {
+			await readFile(join(cwd, "baton.yaml"));
+			if (!args.force) {
+				p.cancel("baton.yaml already exists in this directory.");
+				p.note("Use `baton manage` to modify your project configuration\nor `baton sync` to sync your profiles.\n\nTo reinitialize, use `baton init --force`.", "Already initialized");
+				process.exit(1);
+			}
+			p.log.warn("Overwriting existing baton.yaml (--force)");
+		} catch (_error) {}
+		const spinner = p.spinner();
+		await autoScanAiTools(spinner, isInteractive);
+		await autoScanIdePlatforms(spinner, isInteractive);
+		let profileSources;
+		if (args.profile) profileSources = await selectMultipleProfilesFromSource(args.profile, { nonInteractive: !isInteractive });
+		else {
+			const globalSources = await getGlobalSources();
+			if (globalSources.length === 0) {
+				p.cancel("No sources configured.");
+				p.note("Connect a source repository first:\n\n  baton source connect <url>\n\nExample:\n  baton source connect github:my-org/dx-config", "No sources found");
+				process.exit(1);
+			} else if (globalSources.length === 1 && globalSources[0].default) {
+				const defaultSource = globalSources[0];
+				p.note(`Using default source: ${defaultSource.name}\n${defaultSource.url}`, "Source");
+				profileSources = await selectMultipleProfilesFromSource(defaultSource.url, { nonInteractive: !isInteractive });
+			} else if (!isInteractive) profileSources = await selectMultipleProfilesFromSource((await getDefaultGlobalSource())?.url || globalSources[0].url, { nonInteractive: true });
+			else {
+				const defaultSource = await getDefaultGlobalSource();
+				const selectedUrl = await p.select({
+					message: "Select a source repository:",
+					options: globalSources.map((s) => ({
+						value: s.url,
+						label: s.default ? `${s.name} [default]` : s.name,
+						hint: s.description || s.url
+					})),
+					initialValue: defaultSource?.url
+				});
+				if (p.isCancel(selectedUrl)) {
+					p.cancel("Setup cancelled.");
+					process.exit(0);
+				}
+				profileSources = await selectMultipleProfilesFromSource(selectedUrl);
+			}
+		}
+		await showProfileIntersections(profileSources);
+		const yamlContent = stringify({ profiles: profileSources.map((source) => ({ source })) });
+		spinner.start("Creating baton.yaml...");
+		await writeFile(join(cwd, "baton.yaml"), yamlContent, "utf-8");
+		spinner.stop("✅ Created baton.yaml");
+		spinner.start("Updating .gitignore...");
+		const gitignorePath = join(cwd, ".gitignore");
+		let gitignoreContent = "";
+		try {
+			gitignoreContent = await readFile(gitignorePath, "utf-8");
+		} catch (_error) {}
+		if (!gitignoreContent.includes(".baton/")) {
+			await writeFile(gitignorePath, gitignoreContent ? `${gitignoreContent}\n\n# Baton cache\n.baton/\n` : "# Baton cache\n.baton/\n", "utf-8");
+			spinner.stop("✅ Added .baton/ to .gitignore");
+		} else spinner.stop("✅ .gitignore already contains .baton/");
+		spinner.start("Creating .baton directory...");
+		try {
+			await mkdir(join(cwd, ".baton"), { recursive: true });
+			spinner.stop("✅ Created .baton directory");
+		} catch (_error) {
+			spinner.stop("✅ .baton directory already exists");
+		}
+		if (profileSources.length > 0) {
+			const shouldSync = isInteractive ? await p.confirm({
+				message: "Sync profiles now?",
+				initialValue: true
+			}) : true;
+			if (!p.isCancel(shouldSync) && shouldSync) await runBatonSync(cwd);
+			else p.log.info("Run 'baton sync' later to apply your profiles.");
+		}
+		p.outro("Baton initialized successfully!");
+	}
+});
+/**
+* Auto-scan AI tools if none are configured in global config.
+* In interactive mode: shows results and asks for confirmation.
+* In non-interactive mode (--yes): auto-saves detected tools.
+*/
+async function autoScanAiTools(spinner, isInteractive) {
+	const existingTools = await getGlobalAiTools();
+	if (existingTools.length > 0) {
+		p.log.info(`AI tools already configured: ${existingTools.join(", ")}`);
+		return;
+	}
+	spinner.start("Scanning for installed AI tools...");
+	clearAgentCache();
+	const detectedTools = await detectInstalledAgents();
+	spinner.stop(detectedTools.length > 0 ? `Found ${detectedTools.length} AI tool${detectedTools.length !== 1 ? "s" : ""}: ${detectedTools.join(", ")}` : "No AI tools detected.");
+	if (detectedTools.length === 0) {
+		p.log.warn("No AI tools detected. You can run 'baton ai-tools scan' later.");
+		return;
+	}
+	if (isInteractive) {
+		const shouldSave = await p.confirm({
+			message: "Save detected AI tools to global config?",
+			initialValue: true
+		});
+		if (p.isCancel(shouldSave) || !shouldSave) {
+			p.log.info("Skipped saving AI tools. Run 'baton ai-tools scan' later.");
+			return;
+		}
+	}
+	await setGlobalAiTools(detectedTools);
+	p.log.success("AI tools saved to global config.");
+}
+/**
+* Auto-scan IDE platforms if none are configured in global config.
+* In interactive mode: shows results and asks for confirmation.
+* In non-interactive mode (--yes): auto-saves detected platforms.
+*/
+async function autoScanIdePlatforms(spinner, isInteractive) {
+	const existingPlatforms = await getGlobalIdePlatforms();
+	if (existingPlatforms.length > 0) {
+		p.log.info(`IDE platforms already configured: ${existingPlatforms.join(", ")}`);
+		return;
+	}
+	spinner.start("Scanning for installed IDE platforms...");
+	clearIdeCache();
+	const detectedIdes = await detectInstalledIdes();
+	spinner.stop(detectedIdes.length > 0 ? `Found ${detectedIdes.length} IDE platform${detectedIdes.length !== 1 ? "s" : ""}: ${detectedIdes.join(", ")}` : "No IDE platforms detected.");
+	if (detectedIdes.length === 0) {
+		p.log.warn("No IDE platforms detected. You can run 'baton ides scan' later.");
+		return;
+	}
+	if (isInteractive) {
+		const shouldSave = await p.confirm({
+			message: "Save detected IDE platforms to global config?",
+			initialValue: true
+		});
+		if (p.isCancel(shouldSave) || !shouldSave) {
+			p.log.info("Skipped saving IDE platforms. Run 'baton ides scan' later.");
+			return;
+		}
+	}
+	await setGlobalIdePlatforms(detectedIdes);
+	p.log.success("IDE platforms saved to global config.");
+}
+/**
+* Load source/profile manifests for each selected profile and display
+* the intersection between developer tools and profile support.
+*
+* Gracefully handles errors (e.g., missing source manifest) — the intersection
+* display is informational and should not block init.
+*/
+async function showProfileIntersections(profileSources) {
+	const aiTools = await getGlobalAiTools();
+	const idePlatforms = await getGlobalIdePlatforms();
+	if (aiTools.length === 0 && idePlatforms.length === 0) return;
+	const developerTools = {
+		aiTools,
+		idePlatforms
+	};
+	for (const sourceString of profileSources) try {
+		const parsed = parseSource(sourceString);
+		let repoRoot;
+		let profileDir;
+		if (parsed.provider === "github" || parsed.provider === "gitlab") {
+			repoRoot = (await cloneGitSource({
+				url: parsed.url,
+				ref: parsed.ref,
+				useCache: true
+			})).localPath;
+			profileDir = parsed.subpath ? resolve(repoRoot, parsed.subpath) : repoRoot;
+		} else if (parsed.provider === "local" || parsed.provider === "file") {
+			const absolutePath = parsed.path.startsWith("/") ? parsed.path : resolve(process.cwd(), parsed.path);
+			profileDir = absolutePath;
+			repoRoot = await findSourceRoot(absolutePath, { fallbackToStart: true });
+		} else continue;
+		let sourceManifest;
+		try {
+			sourceManifest = await findSourceManifest(repoRoot);
+		} catch {
+			sourceManifest = {
+				name: "unknown",
+				version: "0.0.0"
+			};
+		}
+		const profileManifest = await loadProfileManifest(resolve(profileDir, "baton.profile.yaml")).catch(() => null);
+		if (!profileManifest) continue;
+		const intersection = computeIntersection(developerTools, resolveProfileSupport(profileManifest, sourceManifest));
+		if (intersection.aiTools.synced.length > 0 || intersection.aiTools.unavailable.length > 0 || intersection.idePlatforms.synced.length > 0 || intersection.idePlatforms.unavailable.length > 0) {
+			p.log.step(`Intersection for ${profileManifest.name}`);
+			displayIntersection(intersection);
+		}
+	} catch {}
+}
+
+//#endregion
+//#region src/commands/manage.ts
+async function loadProjectManifestSafe(cwd) {
+	try {
+		return await loadProjectManifest(join(cwd, "baton.yaml"));
+	} catch {
+		return null;
+	}
+}
+async function hasLockfile(cwd) {
+	try {
+		await access(join(cwd, "baton.lock"));
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function showOverview(cwd) {
+	const [manifest, sources, synced] = await Promise.all([
+		loadProjectManifestSafe(cwd),
+		getGlobalSources(),
+		hasLockfile(cwd)
+	]);
+	if (!manifest) {
+		p.log.warn("Could not load baton.yaml");
+		return;
+	}
+	p.log.step("Installed Profiles");
+	if (manifest.profiles.length === 0) p.log.info("  No profiles installed.");
+	else for (const profile of manifest.profiles) {
+		const version = profile.version ? ` (${profile.version})` : "";
+		const matchingSource = sources.find((s) => profile.source.includes(s.url) || profile.source.includes(s.name));
+		const sourceName = matchingSource ? ` [${matchingSource.name}]` : "";
+		p.log.info(`  ${profile.source}${version}${sourceName}`);
+	}
+	if (manifest.profiles.length > 0) {
+		const aiTools = await getGlobalAiTools();
+		const idePlatforms = await getGlobalIdePlatforms();
+		if (aiTools.length > 0 || idePlatforms.length > 0) {
+			const developerTools = {
+				aiTools,
+				idePlatforms
+			};
+			console.log("");
+			p.log.step("Tool Intersection");
+			for (const profile of manifest.profiles) try {
+				const intersection = await buildIntersection(profile.source, developerTools, cwd);
+				if (intersection) {
+					const summary = formatIntersectionSummary(intersection);
+					p.log.info(`  ${profile.source}: ${summary}`);
+					displayIntersection(intersection);
+				}
+			} catch {}
+		}
+	}
+	console.log("");
+	p.log.step("Sync Status");
+	if (synced) p.log.info("  Synced (baton.lock exists)");
+	else p.log.info("  Not synced — run 'baton sync' to sync profiles");
+	console.log("");
+	p.log.step("Global Sources");
+	if (sources.length === 0) p.log.info("  No sources configured. Run: baton source connect <url>");
+	else for (const source of sources) {
+		const defaultBadge = source.default ? " (default)" : "";
+		p.log.info(`  ${source.name}${defaultBadge}: ${source.url}`);
+	}
+}
+async function handleAddProfile(cwd) {
+	const manifestPath = join(cwd, "baton.yaml");
+	const manifest = await loadProjectManifestSafe(cwd);
+	if (!manifest) {
+		p.log.error("Could not load baton.yaml");
+		return;
+	}
+	const globalSources = await getGlobalSources();
+	if (globalSources.length === 0) {
+		p.log.warn("No global sources configured. Run: baton source connect <url>");
+		return;
+	}
+	let sourceString;
+	if (globalSources.length === 1) {
+		sourceString = globalSources[0].url;
+		p.log.info(`Using source: ${globalSources[0].name} (${sourceString})`);
+	} else {
+		const defaultSource = await getDefaultGlobalSource();
+		const selectedUrl = await p.select({
+			message: "Select a source repository:",
+			options: globalSources.map((s) => ({
+				value: s.url,
+				label: s.default ? `${s.name} [default]` : s.name,
+				hint: s.description || s.url
+			})),
+			initialValue: defaultSource?.url
+		});
+		if (p.isCancel(selectedUrl)) {
+			p.log.warn("Cancelled.");
+			return;
+		}
+		sourceString = selectedUrl;
+	}
+	const selectedSource = await selectProfileFromSource(sourceString);
+	if (manifest.profiles.some((pr) => pr.source === selectedSource)) {
+		p.log.warn(`Profile "${selectedSource}" is already installed.`);
+		return;
+	}
+	manifest.profiles.push({ source: selectedSource });
+	await writeFile(manifestPath, stringify(manifest), "utf-8");
+	p.log.success(`Added profile: ${selectedSource}`);
+	const shouldSync = await p.confirm({
+		message: "Sync profiles now?",
+		initialValue: true
+	});
+	if (p.isCancel(shouldSync) || !shouldSync) {
+		p.log.info("Run 'baton sync' later to apply the new profile.");
+		return;
+	}
+	await runBatonSync(cwd);
+}
+async function handleRemoveProfile(cwd) {
+	const manifestPath = join(cwd, "baton.yaml");
+	const manifest = await loadProjectManifestSafe(cwd);
+	if (!manifest) {
+		p.log.error("Could not load baton.yaml");
+		return;
+	}
+	if (manifest.profiles.length === 0) {
+		p.log.warn("No profiles installed.");
+		return;
+	}
+	const selected = await p.select({
+		message: "Which profile do you want to remove?",
+		options: manifest.profiles.map((pr) => ({
+			value: pr.source,
+			label: pr.source,
+			hint: pr.version ? `v${pr.version}` : void 0
+		}))
+	});
+	if (p.isCancel(selected)) {
+		p.log.warn("Cancelled.");
+		return;
+	}
+	const profileSource = selected;
+	const confirmed = await p.confirm({
+		message: `Remove profile "${profileSource}"?`,
+		initialValue: false
+	});
+	if (p.isCancel(confirmed) || !confirmed) {
+		p.log.warn("Cancelled.");
+		return;
+	}
+	const profileIndex = manifest.profiles.findIndex((pr) => pr.source === profileSource);
+	manifest.profiles.splice(profileIndex, 1);
+	await writeFile(manifestPath, stringify(manifest), "utf-8");
+	p.log.success(`Removed profile: ${profileSource}`);
+	p.log.info("Run 'baton sync' to clean up synced files.");
+}
+async function handleRemoveBaton(cwd) {
+	p.log.warn("This will remove Baton from your project:");
+	p.log.info("  - baton.yaml (project manifest)");
+	p.log.info("  - baton.lock (lockfile)");
+	const confirmed = await p.confirm({
+		message: "Are you sure you want to remove Baton from this project?",
+		initialValue: false
+	});
+	if (p.isCancel(confirmed) || !confirmed) {
+		p.log.warn("Cancelled.");
+		return false;
+	}
+	await rm(join(cwd, "baton.yaml"), { force: true });
+	await rm(join(cwd, "baton.lock"), { force: true });
+	p.log.success("Baton has been removed from this project.");
+	p.log.info("Note: Synced files (rules, skills, memory) were not removed.");
+	p.log.info("Run 'baton sync' before removing to clean up, or delete them manually.");
+	return true;
+}
+const manageCommand = defineCommand({
+	meta: {
+		name: "manage",
+		description: "Interactive project management wizard for Baton"
+	},
+	async run() {
+		const cwd = process.cwd();
+		if (!await loadProjectManifestSafe(cwd)) {
+			p.intro("Baton Manage");
+			p.cancel("baton.yaml not found. Run 'baton init' first.");
+			process.exit(1);
+		}
+		p.intro("Baton Manage");
+		while (true) {
+			const action = await p.select({
+				message: "What would you like to do?",
+				options: [
+					{
+						value: "overview",
+						label: "Overview",
+						hint: "Show project configuration"
+					},
+					{
+						value: "add-profile",
+						label: "Add profile",
+						hint: "Add a profile from a source"
+					},
+					{
+						value: "remove-profile",
+						label: "Remove profile",
+						hint: "Remove an installed profile"
+					},
+					{
+						value: "remove-baton",
+						label: "Remove Baton",
+						hint: "Remove Baton from this project"
+					},
+					{
+						value: "quit",
+						label: "Quit"
+					}
+				]
+			});
+			if (p.isCancel(action) || action === "quit") {
+				p.outro("Goodbye!");
+				return;
+			}
+			if (action === "overview") {
+				console.log("");
+				await showOverview(cwd);
+				console.log("");
+			} else if (action === "add-profile") {
+				console.log("");
+				await handleAddProfile(cwd);
+				console.log("");
+			} else if (action === "remove-profile") {
+				console.log("");
+				await handleRemoveProfile(cwd);
+				console.log("");
+			} else if (action === "remove-baton") {
+				console.log("");
+				if (await handleRemoveBaton(cwd)) {
+					p.outro("Goodbye!");
+					return;
+				}
+				console.log("");
+			}
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/profile/index.ts
+const profileCommand = defineCommand({
+	meta: {
+		name: "profile",
+		description: "Manage profiles (create, list, remove)"
+	},
+	subCommands: {
+		create: () => import("./create-CqfUSGj7.mjs").then((m) => m.createCommand),
+		list: () => import("./list-o76RXPxE.mjs").then((m) => m.profileListCommand),
+		remove: () => import("./remove-BB883RDx.mjs").then((m) => m.profileRemoveCommand)
+	}
+});
+
+//#endregion
+//#region src/commands/source/connect.ts
+/**
+* Command: baton source connect
+*
+* Connects a source repository to the global configuration (~/.baton/config.yaml).
+* Once connected, sources can be auto-selected in `baton init`.
+*/
+const connectCommand = defineCommand({
+	meta: {
+		name: "connect",
+		description: "Connect a source repository to your global config"
+	},
+	args: {
+		url: {
+			type: "positional",
+			description: "Source URL (github:org/repo, ../path)",
+			required: true
+		},
+		name: {
+			type: "string",
+			description: "Custom name for the source (kebab-case)"
+		},
+		description: {
+			type: "string",
+			description: "Source description"
+		}
+	},
+	async run({ args }) {
+		const url = args.url;
+		const customName = args.name;
+		if (customName && !KEBAB_CASE_REGEX.test(customName)) {
+			p.cancel("Source name must be kebab-case (e.g., my-source)");
+			process.exit(1);
+		}
+		try {
+			parseSource(url);
+		} catch (error) {
+			const message = error instanceof SourceParseError ? error.message : `Invalid source: ${error.message}`;
+			p.cancel(message);
+			process.exit(1);
+		}
+		try {
+			await addGlobalSource(url, {
+				name: args.name,
+				description: args.description
+			});
+			const displayName = args.name || url;
+			p.log.success(`Connected source: ${displayName}`);
+			const shouldSync = await p.confirm({ message: "Would you like to sync profiles from this source now?" });
+			if (p.isCancel(shouldSync) || !shouldSync) {
+				p.outro("Source connected. Run 'baton init' to set up profiles.");
+				return;
+			}
+			p.outro("Starting profile sync...");
+			const profiles = await selectMultipleProfilesFromSource(url);
+			if (profiles.length > 0) {
+				p.log.success(`Selected ${profiles.length} profile(s) for sync.`);
+				p.note("Run 'baton init' in your project directory to install these profiles.", "Next step");
+			}
+		} catch (error) {
+			p.cancel(`Failed to connect source: ${error.message}`);
+			process.exit(1);
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/source/create.ts
+const __dirname$1 = dirname(fileURLToPath(import.meta.url));
+async function runInteractiveWizard(overrides = {}) {
+	p.intro("Create a new Baton source repository");
+	let name;
+	if (overrides.name) name = overrides.name;
+	else {
+		const result = await p.text({
+			message: "What is the name of your source repository?",
+			placeholder: "my-team-profile",
+			validate: (value) => {
+				if (!value) return "Name is required";
+				if (!KEBAB_CASE_REGEX.test(value)) return "Name must be in kebab-case (lowercase, hyphens only)";
+			}
+		});
+		if (p.isCancel(result)) {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		name = String(result);
+	}
+	let git;
+	if (overrides.git !== void 0) git = overrides.git;
+	else {
+		const result = await p.confirm({
+			message: "Initialize Git repository?",
+			initialValue: true
+		});
+		if (p.isCancel(result)) {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		git = result;
+	}
+	let withInitialProfile;
+	if (overrides.withInitialProfile !== void 0) withInitialProfile = overrides.withInitialProfile;
+	else {
+		const result = await p.confirm({
+			message: "Create initial profile in profiles/default/?",
+			initialValue: true
+		});
+		if (p.isCancel(result)) {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		withInitialProfile = result;
+	}
+	return {
+		name,
+		git,
+		withInitialProfile
+	};
+}
+/**
+* Recursively copy a directory and apply Handlebars variable substitution to text files
+*/
+async function copyDirectory(src, dest, variables) {
+	await mkdir(dest, { recursive: true });
+	const entries = await readdir(src, { withFileTypes: true });
+	for (const entry of entries) {
+		const srcPath = join(src, entry.name);
+		const destPath = join(dest, entry.name);
+		if (entry.isDirectory()) await copyDirectory(srcPath, destPath, variables);
+		else if (entry.isFile()) {
+			const content = await readFile(srcPath, "utf-8");
+			if (new Set([
+				".png",
+				".jpg",
+				".jpeg",
+				".gif",
+				".ico",
+				".woff",
+				".woff2",
+				".ttf",
+				".eot"
+			]).has(entry.name.substring(entry.name.lastIndexOf(".")))) await writeFile(destPath, content);
+			else await writeFile(destPath, Handlebars.compile(content, { noEscape: true })(variables));
+		}
+	}
+}
+/**
+* Initialize Git repository and create initial commit
+*/
+async function initializeGit(targetDir) {
+	const git = simpleGit(targetDir);
+	await git.init();
+	await git.add(".");
+	await git.commit("Initial baton source setup");
+}
+/**
+* Generate README.md with next steps
+*/
+async function generateReadme(targetDir, options) {
+	const { name, withInitialProfile } = options;
+	const org = name.includes("-") ? name.split("-")[0] : name;
+	const readmeContent = `# ${name}
+
+Baton source repository.
+
+## Usage
+
+Add profiles from this source repository to your project:
+
+\`\`\`bash
+# From GitHub (after you push)
+baton init --profile github:${org}/${name}/profiles/default
+
+# Or locally (for testing)
+baton init --profile file:./${name}/profiles/default
+\`\`\`
+
+## Next Steps
+
+1. **Customize your profiles:**
+   - Edit \`baton.source.yaml\` to configure the source metadata
+   - Modify profiles in \`profiles/*/baton.profile.yaml\`
+   - Add project-specific configurations to \`profiles/*/files/\`
+   - Customize AI tool configs in \`profiles/*/ai/\`
+
+2. **Create additional profiles:**
+   \`\`\`bash
+   cd ${name}
+   baton profile create frontend
+   baton profile create backend
+   \`\`\`
+
+3. **Set up Git remote:**
+   \`\`\`bash
+   git remote add origin https://github.com/${org}/${name}.git
+   git push -u origin main
+   \`\`\`
+
+4. **Share with your team:**
+   - Publish to GitHub for team-wide access
+   - Team members can use: \`baton init --profile github:${org}/${name}/profiles/default\`
+
+## Structure
+
+- \`baton.source.yaml\` - Source repository manifest
+- \`profiles/\` - Container for all profiles
+${withInitialProfile ? "  - `profiles/default/` - Default profile\n    - `baton.profile.yaml` - Profile manifest\n    - `ai/` - AI tool configurations\n    - `files/` - Dotfiles and configs to sync\n    - `ide/` - IDE settings\n" : ""}
+## Learn More
+
+- [Baton Documentation](https://github.com/baton-dx/baton)
+- [Source Schema](https://github.com/baton-dx/baton/blob/main/docs/source-schema.md)
+- [Profile Schema](https://github.com/baton-dx/baton/blob/main/docs/profile-schema.md)
+
+---
+
+Generated with \`baton source create\`
+`;
+	await writeFile(join(targetDir, "README.md"), readmeContent);
+}
+/**
+* Scaffold a source repository
+*/
+async function scaffoldSourceRepo(options) {
+	const { name, git, withInitialProfile } = options;
+	const targetDir = join(process.cwd(), name);
+	await mkdir(join(targetDir, "profiles"), { recursive: true });
+	const sourceManifest = `name: "${name}"
+version: "0.1.0"
+description: "Baton source repository"
+
+${withInitialProfile ? `profiles:
+  - name: "default"
+    path: "profiles/default"
+    description: "Default profile configuration"
+` : ""}
+metadata:
+  created: "${(/* @__PURE__ */ new Date()).getFullYear()}"
+`;
+	await writeFile(join(targetDir, "baton.source.yaml"), sourceManifest);
+	if (withInitialProfile) {
+		const profileDir = join(targetDir, "profiles", "default");
+		await mkdir(profileDir, { recursive: true });
+		await copyDirectory(join(__dirname$1, "..", "src", "templates", "profile", "minimal"), profileDir, { name: "default" });
+	}
+	await generateReadme(targetDir, options);
+	if (git) await initializeGit(targetDir);
+	return targetDir;
+}
+const sourceCreateCommand = defineCommand({
+	meta: {
+		name: "source create",
+		description: "Create a new source repository with an interactive wizard"
+	},
+	args: {
+		name: {
+			type: "positional",
+			description: "Name of the source repository (kebab-case)",
+			required: false
+		},
+		yes: {
+			type: "boolean",
+			description: "Skip interactive wizard and use defaults",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const providedName = args.name;
+		const yesArg = args.yes;
+		if (providedName && !KEBAB_CASE_REGEX.test(providedName)) {
+			console.error("Error: Name must be in kebab-case (lowercase, hyphens only)");
+			process.exit(1);
+		}
+		const overrides = { name: providedName || void 0 };
+		if (yesArg) {
+			overrides.name = overrides.name || "my-source";
+			overrides.git = true;
+			overrides.withInitialProfile = false;
+		}
+		const options = await runInteractiveWizard(overrides);
+		const spinner = p.spinner();
+		spinner.start("Creating source repository...");
+		try {
+			const targetDir = await scaffoldSourceRepo(options);
+			spinner.stop(`Source repository created at ${targetDir}`);
+			const features = [];
+			if (options.withInitialProfile) features.push("Initial Profile: profiles/default/");
+			if (options.git) features.push("Git: Initialized with initial commit");
+			if (features.length > 0) p.note(features.join("\n"), "Features");
+			const org = options.name.includes("-") ? options.name.split("-")[0] : options.name;
+			const nextSteps = [];
+			nextSteps.push(`  cd ${options.name}`);
+			nextSteps.push("  # Customize your profile (see README.md)");
+			if (options.git) {
+				nextSteps.push(`  git remote add origin https://github.com/${org}/${options.name}.git`);
+				nextSteps.push("  git push -u origin main");
+			}
+			nextSteps.push("");
+			nextSteps.push("  # Share with your team:");
+			nextSteps.push(`  baton source connect https://github.com/${org}/${options.name}.git`);
+			p.outro(`Source repository "${options.name}" created successfully!\n\nNext steps:\n${nextSteps.join("\n")}`);
+		} catch (error) {
+			spinner.stop("Failed to create source repository");
+			throw error;
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/source/disconnect.ts
+/**
+* Command: baton source disconnect
+*
+* Disconnects a source repository from the global configuration.
+* Shows a warning about profiles that depend on this source before removing.
+*/
+const disconnectCommand = defineCommand({
+	meta: {
+		name: "disconnect",
+		description: "Disconnect a source repository from your global config"
+	},
+	args: { source: {
+		type: "positional",
+		description: "Source name or URL to disconnect",
+		required: true
+	} },
+	async run({ args }) {
+		const sourceIdentifier = args.source;
+		const matchedSource = (await getGlobalSources()).find((s) => s.name === sourceIdentifier || s.url === sourceIdentifier);
+		if (!matchedSource) {
+			p.cancel(`Source "${sourceIdentifier}" not found in global configuration.`);
+			process.exit(1);
+		}
+		p.log.warn(`Disconnecting source "${matchedSource.name}" (${matchedSource.url}) will affect any projects using profiles from this source.`);
+		p.log.info("Projects that reference this source will no longer be able to sync or update their profiles.");
+		const confirmed = await p.confirm({
+			message: `Are you sure you want to disconnect source "${matchedSource.name}"?`,
+			initialValue: false
+		});
+		if (p.isCancel(confirmed) || !confirmed) {
+			p.cancel("Operation cancelled.");
+			process.exit(0);
+		}
+		try {
+			await removeGlobalSource(sourceIdentifier);
+			p.outro(`Disconnected source: ${matchedSource.name}`);
+		} catch (error) {
+			p.cancel(`Failed to disconnect source: ${error.message}`);
+			process.exit(1);
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/source/list.ts
+/**
+* Command: baton source list
+*
+* Lists all registered global sources from ~/.baton/config.yaml.
+*/
+const listCommand = defineCommand({
+	meta: {
+		name: "list",
+		description: "List all global sources"
+	},
+	async run() {
+		const sources = await getGlobalSources();
+		if (sources.length === 0) {
+			p.log.info("No global sources configured.");
+			p.note("Add a source with:\n  baton source connect <url>", "Tip");
+			return;
+		}
+		console.log("\n🌐 Global Sources\n");
+		console.log("┌──────────────────┬─────────────────────────────────────┬─────────┐");
+		console.log("│ Name             │ URL                                 │ Default │");
+		console.log("├──────────────────┼─────────────────────────────────────┼─────────┤");
+		for (const source of sources) {
+			const name = source.name.padEnd(16);
+			const url = truncate(source.url, 35).padEnd(35);
+			const def = source.default ? "✓" : "";
+			console.log(`│ ${name} │ ${url} │ ${def.padEnd(7)} │`);
+			if (source.description) {
+				const desc = `  ${truncate(source.description, 33)}`.padEnd(35);
+				console.log(`│                  │ ${desc} │         │`);
+			}
+		}
+		console.log("└──────────────────┴─────────────────────────────────────┴─────────┘\n");
+	}
+});
+/**
+* Truncates a string to the specified length, adding "..." if truncated.
+*/
+function truncate(str, maxLength) {
+	if (str.length <= maxLength) return str;
+	return `${str.slice(0, maxLength - 3)}...`;
+}
+
+//#endregion
+//#region src/commands/source/index.ts
+const sourceCommand = defineCommand({
+	meta: {
+		name: "source",
+		description: "Manage source repositories (create, list, connect, disconnect)"
+	},
+	subCommands: {
+		create: sourceCreateCommand,
+		list: listCommand,
+		connect: connectCommand,
+		disconnect: disconnectCommand
+	}
+});
+
+//#endregion
+//#region src/commands/sync.ts
+const validCategories = [
+	"ai",
+	"files",
+	"ide"
+];
+/** Get or initialize placed files for a profile, avoiding unsafe `as` casts on Map.get(). */
+function getOrCreatePlacedFiles(map, profileName) {
+	let files = map.get(profileName);
+	if (!files) {
+		files = {};
+		map.set(profileName, files);
+	}
+	return files;
+}
+/**
+* Recursively copy all files from sourceDir to targetDir.
+* Returns the number of files written (skips identical content).
+*/
+async function copyDirectoryRecursive(sourceDir, targetDir) {
+	await mkdir(targetDir, { recursive: true });
+	const entries = await readdir(sourceDir, { withFileTypes: true });
+	let placed = 0;
+	for (const entry of entries) {
+		const sourcePath = resolve(sourceDir, entry.name);
+		const targetPath = resolve(targetDir, entry.name);
+		if (entry.isDirectory()) placed += await copyDirectoryRecursive(sourcePath, targetPath);
+		else {
+			const content = await readFile(sourcePath, "utf-8");
+			if (await readFile(targetPath, "utf-8").catch(() => void 0) !== content) {
+				await writeFile(targetPath, content, "utf-8");
+				placed++;
+			}
+		}
+	}
+	return placed;
+}
+/**
+* Collect profile-support-based .gitignore patterns and update .gitignore.
+* Uses ALL tools the profile supports (not just the developer's intersection)
+* to ensure consistent .gitignore across all team members.
+*/
+async function updateGitignorePatterns(params) {
+	const { allIntersections, adapters, ideMap, mergedSkills, mergedRules, mergedMemory, mergedCommandCount, fileMap, projectRoot, spinner } = params;
+	const profileSupportedAiTools = /* @__PURE__ */ new Set();
+	const profileSupportedIdePlatforms = /* @__PURE__ */ new Set();
+	if (allIntersections) for (const intersection of allIntersections.values()) {
+		for (const tool of intersection.aiTools.synced) profileSupportedAiTools.add(tool);
+		for (const tool of intersection.aiTools.unavailable) profileSupportedAiTools.add(tool);
+		for (const plat of intersection.idePlatforms.synced) profileSupportedIdePlatforms.add(plat);
+		for (const plat of intersection.idePlatforms.unavailable) profileSupportedIdePlatforms.add(plat);
+	}
+	else {
+		for (const adapter of adapters) profileSupportedAiTools.add(adapter.key);
+		for (const entry of ideMap.values()) profileSupportedIdePlatforms.add(entry.ideKey);
+	}
+	const hasContent = mergedSkills.length > 0 || mergedRules.length > 0 || mergedMemory.length > 0 || mergedCommandCount > 0;
+	const gitignorePatterns = collectProfileSupportPatterns({
+		profileAiTools: [...profileSupportedAiTools],
+		profileIdePlatforms: [...profileSupportedIdePlatforms],
+		fileTargets: [...fileMap.values()].map((f) => f.target),
+		hasContent
+	});
+	if (gitignorePatterns.length > 0) {
+		spinner.start("Updating .gitignore...");
+		const updated = await updateGitignore(projectRoot, gitignorePatterns);
+		spinner.stop(updated ? "Updated .gitignore with synced patterns" : ".gitignore already up to date");
+	}
+}
+/**
+* Generate and write the baton.lock lockfile from placed files and profile metadata.
+*/
+async function writeLockData(params) {
+	const { allProfiles, sourceShas, placedFiles, projectRoot, spinner } = params;
+	spinner.start("Updating lockfile...");
+	const lockPackages = {};
+	for (const profile of allProfiles) lockPackages[profile.name] = {
+		source: profile.source,
+		resolved: profile.source,
+		version: profile.manifest.version,
+		sha: sourceShas.get(profile.source) || "unknown",
+		files: placedFiles.get(profile.name) || {}
+	};
+	await writeLock(generateLock(lockPackages), resolve(projectRoot, "baton.lock"));
+	spinner.stop("Lockfile updated");
+}
+/**
+* Detect and remove files that were in the previous lockfile but are no longer
+* part of the current sync. Cleans up empty parent directories.
+*/
+async function cleanupOrphanedFiles(params) {
+	const { previousPaths, placedFiles, projectRoot, dryRun, autoYes, spinner } = params;
+	if (previousPaths.size === 0) return;
+	const currentPaths = /* @__PURE__ */ new Set();
+	for (const files of placedFiles.values()) for (const filePath of Object.keys(files)) currentPaths.add(filePath);
+	const orphanedPaths = [...previousPaths].filter((prev) => !currentPaths.has(prev));
+	if (orphanedPaths.length === 0) return;
+	if (dryRun) {
+		p.log.warn(`Would remove ${orphanedPaths.length} orphaned file(s):`);
+		for (const orphanedPath of orphanedPaths) p.log.info(`  Removed: ${orphanedPath}`);
+		return;
+	}
+	p.log.warn(`Found ${orphanedPaths.length} orphaned file(s) to remove:`);
+	for (const orphanedPath of orphanedPaths) p.log.info(`  Removed: ${orphanedPath}`);
+	let shouldRemove = autoYes;
+	if (!autoYes) {
+		const confirmed = await p.confirm({
+			message: `Remove ${orphanedPaths.length} orphaned file(s)?`,
+			initialValue: true
+		});
+		if (p.isCancel(confirmed)) {
+			p.log.info("Skipped orphan removal.");
+			shouldRemove = false;
+		} else shouldRemove = confirmed;
+	}
+	if (!shouldRemove) {
+		p.log.info("Orphan removal skipped.");
+		return;
+	}
+	spinner.start("Removing orphaned files...");
+	let removedCount = 0;
+	for (const orphanedPath of orphanedPaths) {
+		const absolutePath = orphanedPath.startsWith("/") ? orphanedPath : resolve(projectRoot, orphanedPath);
+		try {
+			await unlink(absolutePath);
+			removedCount++;
+			let dir = dirname(absolutePath);
+			while (dir !== projectRoot && dir.startsWith(projectRoot)) try {
+				if ((await readdir(dir)).length === 0) {
+					await rmdir(dir);
+					dir = dirname(dir);
+				} else break;
+			} catch {
+				break;
+			}
+		} catch {}
+	}
+	spinner.stop(`Removed ${removedCount} orphaned file(s)`);
+}
+const syncCommand = defineCommand({
+	meta: {
+		name: "sync",
+		description: "Sync all profiles, skills, agents, and rules to installed AI tools"
+	},
+	args: {
+		"dry-run": {
+			type: "boolean",
+			description: "Show what would be done without writing files",
+			default: false
+		},
+		category: {
+			type: "string",
+			description: "Sync only a specific category: ai, files, or ide",
+			required: false
+		},
+		yes: {
+			type: "boolean",
+			description: "Run non-interactively (no prompts)",
+			default: false
+		},
+		verbose: {
+			type: "boolean",
+			alias: "v",
+			description: "Show detailed output for each placed file",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const dryRun = args["dry-run"];
+		const categoryArg = args.category;
+		const autoYes = args.yes;
+		const verbose = args.verbose;
+		let category;
+		if (categoryArg) {
+			if (!validCategories.includes(categoryArg)) {
+				p.cancel(`Invalid category "${categoryArg}". Valid categories: ${validCategories.join(", ")}`);
+				process.exit(1);
+			}
+			category = categoryArg;
+		}
+		const syncAi = !category || category === "ai";
+		const syncFiles = !category || category === "files";
+		const syncIde = !category || category === "ide";
+		p.intro(category ? `🔄 Baton Sync (category: ${category})` : "🔄 Baton Sync");
+		const stats = {
+			created: 0,
+			errors: 0
+		};
+		try {
+			const projectRoot = process.cwd();
+			const manifestPath = resolve(projectRoot, "baton.yaml");
+			let projectManifest;
+			try {
+				projectManifest = await loadProjectManifest(manifestPath);
+			} catch (error) {
+				if (error instanceof FileNotFoundError) p.cancel("baton.yaml not found. Run `baton init` first.");
+				else p.cancel(`Failed to load baton.yaml: ${error instanceof Error ? error.message : String(error)}`);
+				process.exit(1);
+			}
+			const previousPaths = /* @__PURE__ */ new Set();
+			try {
+				const previousLock = await readLock(resolve(projectRoot, "baton.lock"));
+				for (const pkg of Object.values(previousLock.packages)) for (const filePath of Object.keys(pkg.integrity)) previousPaths.add(filePath);
+			} catch {}
+			const spinner = p.spinner();
+			spinner.start("Resolving profile chain...");
+			const allProfiles = [];
+			const sourceShas = /* @__PURE__ */ new Map();
+			for (const profileSource of projectManifest.profiles || []) try {
+				if (verbose) p.log.info(`Resolving source: ${profileSource.source}`);
+				const parsed = parseSource(profileSource.source);
+				let manifestPath;
+				if (parsed.provider === "local" || parsed.provider === "file") {
+					const absolutePath = parsed.path.startsWith("/") ? parsed.path : resolve(projectRoot, parsed.path);
+					manifestPath = resolve(absolutePath, "baton.profile.yaml");
+					try {
+						const git = simpleGit(absolutePath);
+						await git.checkIsRepo();
+						const sha = await git.revparse(["HEAD"]);
+						sourceShas.set(profileSource.source, sha.trim());
+					} catch {
+						sourceShas.set(profileSource.source, "local");
+					}
+				} else {
+					const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
+					if (!url) throw new Error(`Invalid source: ${profileSource.source}`);
+					const cloned = await cloneGitSource({
+						url,
+						ref: profileSource.version,
+						subpath: "subpath" in parsed ? parsed.subpath : void 0,
+						useCache: true
+					});
+					manifestPath = resolve(cloned.localPath, "baton.profile.yaml");
+					sourceShas.set(profileSource.source, cloned.sha);
+				}
+				const manifest = await loadProfileManifest(manifestPath);
+				const profileDir = dirname(manifestPath);
+				const chain = await resolveProfileChain(manifest, profileSource.source, profileDir);
+				allProfiles.push(...chain);
+			} catch (error) {
+				spinner.stop(`Failed to resolve profile ${profileSource.source}: ${error}`);
+				stats.errors++;
+			}
+			if (allProfiles.length === 0) {
+				spinner.stop("No profiles configured");
+				p.outro("Nothing to sync. Run `baton manage` to add a profile.");
+				process.exit(2);
+			}
+			spinner.stop(`Resolved ${allProfiles.length} profile(s)`);
+			const weightSortedProfiles = sortProfilesByWeight(allProfiles);
+			spinner.start("Merging configurations...");
+			const allWeightWarnings = [];
+			const skillsResult = mergeSkillsWithWarnings(weightSortedProfiles);
+			const mergedSkills = skillsResult.skills;
+			allWeightWarnings.push(...skillsResult.warnings);
+			const rulesResult = mergeRulesWithWarnings(weightSortedProfiles);
+			const mergedRules = rulesResult.rules;
+			allWeightWarnings.push(...rulesResult.warnings);
+			const memoryResult = mergeMemoryWithWarnings(weightSortedProfiles);
+			const mergedMemory = memoryResult.entries;
+			allWeightWarnings.push(...memoryResult.warnings);
+			const commandMap = /* @__PURE__ */ new Map();
+			const lockedCommands = /* @__PURE__ */ new Set();
+			const commandOwner = /* @__PURE__ */ new Map();
+			for (const profile of weightSortedProfiles) {
+				const weight = getProfileWeight(profile);
+				const locked = isLockedProfile(profile);
+				for (const cmd of profile.manifest.ai?.commands || []) {
+					if (lockedCommands.has(cmd)) continue;
+					const existing = commandOwner.get(cmd);
+					if (existing && existing.weight === weight && existing.profileName !== profile.name) allWeightWarnings.push({
+						key: cmd,
+						category: "command",
+						profileA: existing.profileName,
+						profileB: profile.name,
+						weight
+					});
+					commandMap.set(cmd, profile.name);
+					commandOwner.set(cmd, {
+						profileName: profile.name,
+						weight
+					});
+					if (locked) lockedCommands.add(cmd);
+				}
+			}
+			const mergedCommandCount = commandMap.size;
+			const fileMap = /* @__PURE__ */ new Map();
+			const lockedFiles = /* @__PURE__ */ new Set();
+			const fileOwner = /* @__PURE__ */ new Map();
+			for (const profile of weightSortedProfiles) {
+				const weight = getProfileWeight(profile);
+				const locked = isLockedProfile(profile);
+				for (const fileConfig of profile.manifest.files || []) {
+					const target = fileConfig.target || fileConfig.source;
+					if (lockedFiles.has(target)) continue;
+					const existing = fileOwner.get(target);
+					if (existing && existing.weight === weight && existing.profileName !== profile.name) allWeightWarnings.push({
+						key: target,
+						category: "file",
+						profileA: existing.profileName,
+						profileB: profile.name,
+						weight
+					});
+					fileMap.set(target, {
+						source: fileConfig.source,
+						target,
+						profileName: profile.name
+					});
+					fileOwner.set(target, {
+						profileName: profile.name,
+						weight
+					});
+					if (locked) lockedFiles.add(target);
+				}
+			}
+			const mergedFileCount = fileMap.size;
+			const ideMap = /* @__PURE__ */ new Map();
+			const lockedIdeConfigs = /* @__PURE__ */ new Set();
+			const ideOwner = /* @__PURE__ */ new Map();
+			for (const profile of weightSortedProfiles) {
+				if (!profile.manifest.ide) continue;
+				const weight = getProfileWeight(profile);
+				const locked = isLockedProfile(profile);
+				for (const [ideKey, files] of Object.entries(profile.manifest.ide)) {
+					if (!files) continue;
+					const targetDir = getIdePlatformTargetDir(ideKey);
+					if (!targetDir) {
+						if (!isKnownIdePlatform(ideKey)) p.log.warn(`Unknown IDE platform "${ideKey}" in profile "${profile.name}" — skipping. Register it in the IDE platform registry.`);
+						continue;
+					}
+					for (const fileName of files) {
+						const targetPath = `${targetDir}/${fileName}`;
+						if (lockedIdeConfigs.has(targetPath)) continue;
+						const existing = ideOwner.get(targetPath);
+						if (existing && existing.weight === weight && existing.profileName !== profile.name) allWeightWarnings.push({
+							key: targetPath,
+							category: "ide",
+							profileA: existing.profileName,
+							profileB: profile.name,
+							weight
+						});
+						ideMap.set(targetPath, {
+							ideKey,
+							fileName,
+							targetDir,
+							profileName: profile.name
+						});
+						ideOwner.set(targetPath, {
+							profileName: profile.name,
+							weight
+						});
+						if (locked) lockedIdeConfigs.add(targetPath);
+					}
+				}
+			}
+			const mergedIdeCount = ideMap.size;
+			spinner.stop(`Merged: ${mergedSkills.length} skills, ${mergedRules.length} rules, ${mergedMemory.length} memory files, ${mergedCommandCount} commands, ${mergedFileCount} files, ${mergedIdeCount} IDE configs`);
+			if (allWeightWarnings.length > 0) for (const w of allWeightWarnings) p.log.warn(`Weight conflict: "${w.profileA}" and "${w.profileB}" both define ${w.category} "${w.key}" with weight ${w.weight}. Last declared wins.`);
+			spinner.start("Computing tool intersection...");
+			const globalAiTools = await getGlobalAiTools();
+			const globalIdePlatforms = await getGlobalIdePlatforms();
+			const detectedAgents = await detectInstalledAgents();
+			let syncedAiTools;
+			let syncedIdePlatforms = null;
+			let allIntersections = null;
+			if (globalAiTools.length > 0) {
+				const developerTools = {
+					aiTools: globalAiTools,
+					idePlatforms: globalIdePlatforms
+				};
+				const aggregatedSyncedAi = /* @__PURE__ */ new Set();
+				const aggregatedSyncedIde = /* @__PURE__ */ new Set();
+				allIntersections = /* @__PURE__ */ new Map();
+				for (const profileSource of projectManifest.profiles || []) try {
+					const intersection = await buildIntersection(profileSource.source, developerTools, projectRoot);
+					if (intersection) {
+						allIntersections.set(profileSource.source, intersection);
+						for (const tool of intersection.aiTools.synced) aggregatedSyncedAi.add(tool);
+						for (const platform of intersection.idePlatforms.synced) aggregatedSyncedIde.add(platform);
+					}
+				} catch {}
+				syncedAiTools = aggregatedSyncedAi.size > 0 ? [...aggregatedSyncedAi] : [];
+				syncedIdePlatforms = [...aggregatedSyncedIde];
+			} else {
+				syncedAiTools = detectedAgents;
+				syncedIdePlatforms = null;
+				if (detectedAgents.length > 0) {
+					p.log.warn("No AI tools configured. Run `baton ai-tools scan` to configure your tools.");
+					p.log.info(`Falling back to detected tools: ${detectedAgents.join(", ")}`);
+				}
+			}
+			if (syncedAiTools.length === 0 && detectedAgents.length === 0) {
+				spinner.stop("No AI tools available");
+				p.cancel("No AI tools found. Install an AI coding tool first.");
+				process.exit(1);
+			}
+			if (syncedAiTools.length === 0) {
+				spinner.stop("No AI tools in intersection");
+				p.cancel("No AI tools match between your configuration and profile support. Run `baton ai-tools scan` or check your profile's supported tools.");
+				process.exit(1);
+			}
+			if (allIntersections) for (const [source, intersection] of allIntersections) if (verbose) {
+				p.log.step(`Intersection for ${source}`);
+				displayIntersection(intersection);
+			} else {
+				const summary = formatIntersectionSummary(intersection);
+				p.log.info(`Syncing for: ${summary}`);
+			}
+			const ideSummary = syncedIdePlatforms && syncedIdePlatforms.length > 0 ? ` | IDE platforms: ${syncedIdePlatforms.join(", ")}` : "";
+			spinner.stop(`Syncing AI tools: ${syncedAiTools.join(", ")}${ideSummary}`);
+			spinner.start("Checking for legacy paths...");
+			const legacyFiles = await detectLegacyPaths(projectRoot);
+			if (legacyFiles.length > 0 && !dryRun) {
+				spinner.stop(`Found ${legacyFiles.length} legacy file(s)`);
+				if (!autoYes) {
+					p.note(`Found legacy configuration files:\n${legacyFiles.map((f) => `  - ${f.legacyPath}`).join("\n")}`, "Legacy Files");
+					p.log.warn("Run migration manually with appropriate action (migrate/copy/skip)");
+				}
+			} else spinner.stop("No legacy files found");
+			spinner.start("Processing configurations...");
+			const adapters = getAdaptersForKeys(syncedAiTools);
+			const placementConfig = {
+				mode: "copy",
+				projectRoot
+			};
+			const placedFiles = /* @__PURE__ */ new Map();
+			const profileLocalPaths = /* @__PURE__ */ new Map();
+			for (const profileSource of projectManifest.profiles || []) {
+				const parsed = parseSource(profileSource.source);
+				if (parsed.provider === "local" || parsed.provider === "file") {
+					const localPath = parsed.path.startsWith("/") ? parsed.path : resolve(projectRoot, parsed.path);
+					for (const prof of allProfiles) if (prof.source === profileSource.source) profileLocalPaths.set(prof.name, localPath);
+				} else if (parsed.provider === "github" || parsed.provider === "gitlab" || parsed.provider === "git") {
+					const cloned = await cloneGitSource({
+						url: parsed.provider === "git" ? parsed.url : parsed.url,
+						ref: profileSource.version,
+						subpath: "subpath" in parsed ? parsed.subpath : void 0,
+						useCache: true
+					});
+					for (const prof of allProfiles) if (prof.source === profileSource.source) profileLocalPaths.set(prof.name, cloned.localPath);
+				}
+			}
+			const contentAccumulator = /* @__PURE__ */ new Map();
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) p.log.step(`[${adapter.key}] Placing memory files...`);
+				for (const memoryEntry of mergedMemory) try {
+					const contentParts = [];
+					for (const contribution of memoryEntry.contributions) {
+						const profileDir = profileLocalPaths.get(contribution.profileName);
+						if (!profileDir) {
+							spinner.message(`Warning: Could not resolve local path for profile ${contribution.profileName}`);
+							continue;
+						}
+						const memoryFilePath = resolve(profileDir, "ai", "memory", memoryEntry.filename);
+						try {
+							const content = await readFile(memoryFilePath, "utf-8");
+							contentParts.push(content);
+						} catch {
+							spinner.message(`Warning: Could not read ${memoryFilePath}`);
+						}
+					}
+					if (contentParts.length === 0) continue;
+					const mergedContent = mergeContentParts(contentParts, memoryEntry.mergeStrategy);
+					const transformed = adapter.transformMemory({
+						filename: memoryEntry.filename,
+						content: mergedContent
+					});
+					const targetPath = adapter.getPath("memory", "project", transformed.filename);
+					const absolutePath = targetPath.startsWith("/") ? targetPath : resolve(projectRoot, targetPath);
+					const existing = contentAccumulator.get(absolutePath);
+					if (existing) {
+						existing.parts.push(transformed.content);
+						for (const c of memoryEntry.contributions) existing.profiles.add(c.profileName);
+					} else {
+						const profiles = /* @__PURE__ */ new Set();
+						for (const c of memoryEntry.contributions) profiles.add(c.profileName);
+						contentAccumulator.set(absolutePath, {
+							parts: [transformed.content],
+							adapter,
+							type: "memory",
+							name: transformed.filename,
+							profiles
+						});
+					}
+				} catch (error) {
+					spinner.message(`Error placing ${memoryEntry.filename} for ${adapter.name}: ${error}`);
+					stats.errors++;
+				}
+			}
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) p.log.step(`[${adapter.key}] Placing skills...`);
+				for (const skillItem of mergedSkills) try {
+					const profileDir = profileLocalPaths.get(skillItem.profileName);
+					if (!profileDir) {
+						spinner.message(`Warning: Could not resolve local path for profile ${skillItem.profileName}`);
+						continue;
+					}
+					const skillSourceDir = resolve(profileDir, "ai", "skills", skillItem.name);
+					try {
+						await stat(skillSourceDir);
+					} catch {
+						spinner.message(`Warning: Skill directory not found: ${skillSourceDir}`);
+						continue;
+					}
+					const targetSkillPath = adapter.getPath("skills", skillItem.scope, skillItem.name);
+					const absoluteTargetDir = targetSkillPath.startsWith("/") ? targetSkillPath : resolve(projectRoot, targetSkillPath);
+					const placed = await copyDirectoryRecursive(skillSourceDir, absoluteTargetDir);
+					stats.created += placed;
+					const profileFiles = getOrCreatePlacedFiles(placedFiles, skillItem.profileName);
+					try {
+						profileFiles[targetSkillPath] = {
+							content: await readFile(resolve(skillSourceDir, "index.md"), "utf-8"),
+							tool: adapter.key,
+							category: "ai"
+						};
+					} catch {
+						profileFiles[targetSkillPath] = {
+							content: skillItem.name,
+							tool: adapter.key,
+							category: "ai"
+						};
+					}
+					if (verbose) {
+						const label = placed > 0 ? `${placed} file(s) created` : "unchanged, skipped";
+						p.log.info(`  -> ${absoluteTargetDir}/ (${label})`);
+					}
+				} catch (error) {
+					spinner.message(`Error placing skill ${skillItem.name} for ${adapter.name}: ${error}`);
+					stats.errors++;
+				}
+			}
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) p.log.step(`[${adapter.key}] Placing rules...`);
+				for (const ruleEntry of mergedRules) try {
+					const isUniversal = ruleEntry.agents.length === 0;
+					const isForThisAdapter = ruleEntry.agents.includes(adapter.key);
+					if (!isUniversal && !isForThisAdapter) continue;
+					const profileDir = profileLocalPaths.get(ruleEntry.profileName);
+					if (!profileDir) {
+						spinner.message(`Warning: Could not resolve local path for profile ${ruleEntry.profileName}`);
+						continue;
+					}
+					const ruleSourcePath = resolve(profileDir, "ai", "rules", isUniversal ? "universal" : ruleEntry.agents[0], `${ruleEntry.name}.md`);
+					let rawContent;
+					try {
+						rawContent = await readFile(ruleSourcePath, "utf-8");
+					} catch {
+						spinner.message(`Warning: Could not read rule file: ${ruleSourcePath}`);
+						continue;
+					}
+					const parsed = parseFrontmatter(rawContent);
+					const ruleFile = {
+						name: ruleEntry.name,
+						content: rawContent,
+						frontmatter: Object.keys(parsed.data).length > 0 ? parsed.data : void 0
+					};
+					const transformed = adapter.transformRule(ruleFile);
+					const targetPath = adapter.getPath("rules", "project", ruleEntry.name);
+					const absolutePath = targetPath.startsWith("/") ? targetPath : resolve(projectRoot, targetPath);
+					const existing = contentAccumulator.get(absolutePath);
+					if (existing) {
+						existing.parts.push(transformed.content);
+						existing.profiles.add(ruleEntry.profileName);
+					} else contentAccumulator.set(absolutePath, {
+						parts: [transformed.content],
+						adapter,
+						type: "rules",
+						name: ruleEntry.name,
+						profiles: new Set([ruleEntry.profileName])
+					});
+				} catch (error) {
+					spinner.message(`Error placing rule ${ruleEntry.name} for ${adapter.name}: ${error}`);
+					stats.errors++;
+				}
+			}
+			if (!dryRun && syncAi) for (const [absolutePath, entry] of contentAccumulator) try {
+				const combinedContent = entry.parts.join("\n\n");
+				const result = await placeFile(combinedContent, entry.adapter, entry.type, "project", entry.name, placementConfig);
+				if (result.action !== "skipped") stats.created++;
+				for (const profileName of entry.profiles) {
+					const pf = getOrCreatePlacedFiles(placedFiles, profileName);
+					pf[result.path] = {
+						content: combinedContent,
+						tool: entry.adapter.key,
+						category: "ai"
+					};
+				}
+				if (verbose) {
+					const label = result.action === "skipped" ? "unchanged, skipped" : result.action;
+					p.log.info(`  -> ${result.path} (${label})`);
+				}
+			} catch (error) {
+				spinner.message(`Error placing accumulated content to ${absolutePath}: ${error}`);
+				stats.errors++;
+			}
+			if (!dryRun && syncAi) for (const adapter of adapters) {
+				if (verbose) p.log.step(`[${adapter.key}] Placing commands...`);
+				for (const profile of allProfiles) {
+					const profileDir = profileLocalPaths.get(profile.name);
+					if (!profileDir) continue;
+					const commandNames = profile.manifest.ai?.commands || [];
+					for (const commandName of commandNames) try {
+						const commandSourcePath = resolve(profileDir, "ai", "commands", `${commandName}.md`);
+						let content;
+						try {
+							content = await readFile(commandSourcePath, "utf-8");
+						} catch {
+							continue;
+						}
+						const result = await placeFile(content, adapter, "commands", "project", commandName, placementConfig);
+						if (result.action !== "skipped") stats.created++;
+						const pf = getOrCreatePlacedFiles(placedFiles, profile.name);
+						pf[result.path] = {
+							content,
+							tool: adapter.key,
+							category: "ai"
+						};
+						if (verbose) {
+							const label = result.action === "skipped" ? "unchanged, skipped" : result.action;
+							p.log.info(`  -> ${result.path} (${label})`);
+						}
+					} catch (error) {
+						spinner.message(`Error placing command ${commandName} for ${adapter.name}: ${error}`);
+						stats.errors++;
+					}
+				}
+			}
+			if (!dryRun && syncFiles) for (const fileEntry of fileMap.values()) try {
+				const profileDir = profileLocalPaths.get(fileEntry.profileName);
+				if (!profileDir) continue;
+				const fileSourcePath = resolve(profileDir, "files", fileEntry.source);
+				let content;
+				try {
+					content = await readFile(fileSourcePath, "utf-8");
+				} catch {
+					continue;
+				}
+				const targetPath = resolve(projectRoot, fileEntry.target);
+				await mkdir(dirname(targetPath), { recursive: true });
+				if (await readFile(targetPath, "utf-8").catch(() => void 0) !== content) {
+					await writeFile(targetPath, content, "utf-8");
+					stats.created++;
+					if (verbose) p.log.info(`  -> ${fileEntry.target} (created)`);
+				} else if (verbose) p.log.info(`  -> ${fileEntry.target} (unchanged, skipped)`);
+				const fpf = getOrCreatePlacedFiles(placedFiles, fileEntry.profileName);
+				fpf[fileEntry.target] = {
+					content,
+					category: "files"
+				};
+			} catch (error) {
+				spinner.message(`Error placing file ${fileEntry.source}: ${error}`);
+				stats.errors++;
+			}
+			if (!dryRun && syncIde) for (const ideEntry of ideMap.values()) try {
+				if (syncedIdePlatforms !== null && !syncedIdePlatforms.includes(ideEntry.ideKey)) {
+					if (verbose) p.log.info(`  -> ${ideEntry.targetDir}/${ideEntry.fileName} (skipped — IDE platform "${ideEntry.ideKey}" not in intersection)`);
+					continue;
+				}
+				const profileDir = profileLocalPaths.get(ideEntry.profileName);
+				if (!profileDir) continue;
+				const ideSourcePath = resolve(profileDir, "ide", ideEntry.ideKey, ideEntry.fileName);
+				let content;
+				try {
+					content = await readFile(ideSourcePath, "utf-8");
+				} catch {
+					continue;
+				}
+				const targetPath = resolve(projectRoot, ideEntry.targetDir, ideEntry.fileName);
+				await mkdir(dirname(targetPath), { recursive: true });
+				if (await readFile(targetPath, "utf-8").catch(() => void 0) !== content) {
+					await writeFile(targetPath, content, "utf-8");
+					stats.created++;
+					if (verbose) p.log.info(`  -> ${ideEntry.targetDir}/${ideEntry.fileName} (created)`);
+				} else if (verbose) p.log.info(`  -> ${ideEntry.targetDir}/${ideEntry.fileName} (unchanged, skipped)`);
+				const ideRelPath = `${ideEntry.targetDir}/${ideEntry.fileName}`;
+				const ipf = getOrCreatePlacedFiles(placedFiles, ideEntry.profileName);
+				ipf[ideRelPath] = {
+					content,
+					tool: ideEntry.ideKey,
+					category: "ide"
+				};
+			} catch (error) {
+				spinner.message(`Error placing IDE config ${ideEntry.fileName}: ${error}`);
+				stats.errors++;
+			}
+			spinner.stop(dryRun ? `Would place files for ${adapters.length} agent(s)` : `Placed ${stats.created} file(s) for ${adapters.length} agent(s)`);
+			if (!dryRun) await updateGitignorePatterns({
+				allIntersections,
+				adapters,
+				ideMap,
+				mergedSkills,
+				mergedRules,
+				mergedMemory,
+				mergedCommandCount,
+				fileMap,
+				projectRoot,
+				spinner
+			});
+			if (!dryRun) await writeLockData({
+				allProfiles,
+				sourceShas,
+				placedFiles,
+				projectRoot,
+				spinner
+			});
+			await cleanupOrphanedFiles({
+				previousPaths,
+				placedFiles,
+				projectRoot,
+				dryRun,
+				autoYes,
+				spinner
+			});
+			if (dryRun) {
+				const parts = [];
+				if (syncAi) {
+					parts.push(`  • ${mergedSkills.length} skills`);
+					parts.push(`  • ${mergedRules.length} rules`);
+					parts.push(`  • ${mergedMemory.length} memory files`);
+					parts.push(`  • ${mergedCommandCount} commands`);
+				}
+				if (syncFiles) parts.push(`  • ${mergedFileCount} files`);
+				if (syncIde) {
+					const filteredIdeCount = syncedIdePlatforms !== null ? [...ideMap.values()].filter((e) => syncedIdePlatforms.includes(e.ideKey)).length : mergedIdeCount;
+					parts.push(`  • ${filteredIdeCount} IDE configs`);
+				}
+				const categoryLabel = category ? ` (category: ${category})` : "";
+				p.outro(`[Dry Run${categoryLabel}] Would sync:\n${parts.join("\n")}\n\nFor ${adapters.length} agent(s): ${syncedAiTools.join(", ")}`);
+			} else {
+				const categoryLabel = category ? ` (category: ${category})` : "";
+				p.outro(`✅ Sync complete${categoryLabel}! Configurations updated.`);
+			}
+			process.exit(stats.errors > 0 ? 1 : 0);
+		} catch (error) {
+			p.cancel(`Sync failed: ${error}`);
+			process.exit(1);
+		}
+	}
+});
+
+//#endregion
+//#region src/commands/update.ts
+const updateCommand = defineCommand({
+	meta: {
+		name: "update",
+		description: "Check for and apply updates to installed profiles and packages"
+	},
+	args: {
+		"dry-run": {
+			type: "boolean",
+			description: "Show available updates without applying them",
+			default: false
+		},
+		yes: {
+			type: "boolean",
+			description: "Apply all updates without confirmation prompts",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const dryRun = args["dry-run"];
+		const autoConfirm = args.yes;
+		p.intro("Baton Update");
+		const cwd = process.cwd();
+		const manifestPath = resolve(cwd, "baton.yaml");
+		const lockfilePath = resolve(cwd, "baton.lock");
+		const spinner = p.spinner();
+		spinner.start("Loading project configuration");
+		let manifest;
+		try {
+			manifest = await loadProjectManifest(manifestPath);
+		} catch (error) {
+			spinner.stop("Failed to load baton.yaml");
+			p.cancel(error instanceof Error ? error.message : "Could not load project manifest");
+			process.exit(1);
+		}
+		let lockfile = null;
+		try {
+			lockfile = await loadLockfile(lockfilePath);
+			spinner.stop("Configuration loaded");
+		} catch {
+			spinner.stop("Configuration loaded (no lockfile found)");
+			p.note("No lockfile found. Run 'baton sync' first to create one.");
+		}
+		spinner.start("Checking for updates");
+		const updateCandidates = [];
+		for (const profile of manifest.profiles || []) try {
+			const parsed = parseSource(profile.source);
+			if (parsed.provider === "local" || parsed.provider === "file") continue;
+			const packageName = getPackageName(parsed);
+			const currentVersion = lockfile?.packages[packageName]?.version || profile.version || "HEAD";
+			const latestVersion = await getLatestVersion(parsed);
+			if (currentVersion !== latestVersion) {
+				const changes = await getChangeSummary(parsed, currentVersion, latestVersion);
+				updateCandidates.push({
+					name: packageName,
+					source: profile.source,
+					currentVersion,
+					latestVersion,
+					changes
+				});
+			}
+		} catch (error) {
+			if (error instanceof SourceParseError) p.log.warn(`Skipping invalid source: ${profile.source}`);
+		}
+		spinner.stop("Update check complete");
+		if (updateCandidates.length === 0) {
+			p.outro("All packages are up to date!");
+			process.exit(0);
+		}
+		p.note(`Found ${updateCandidates.length} update${updateCandidates.length > 1 ? "s" : ""}`);
+		for (const candidate of updateCandidates) {
+			console.log(`\n📦 ${candidate.name}: ${candidate.currentVersion} → ${candidate.latestVersion}`);
+			if (candidate.changes.length > 0) {
+				console.log("   Changes:");
+				for (const change of candidate.changes) console.log(`   - ${change}`);
+			}
+		}
+		if (dryRun) {
+			p.outro("Dry-run mode enabled. No changes were made.\nRun 'baton update' without --dry-run to apply updates.");
+			process.exit(0);
+		}
+		if (!autoConfirm) {
+			const confirmed = await p.confirm({
+				message: `Apply ${updateCandidates.length} update${updateCandidates.length > 1 ? "s" : ""}?`,
+				initialValue: true
+			});
+			if (p.isCancel(confirmed) || !confirmed) {
+				p.cancel("Update cancelled");
+				process.exit(0);
+			}
+		}
+		spinner.start("Applying updates");
+		const updatedPackages = {};
+		for (const candidate of updateCandidates) try {
+			const parsed = parseSource(candidate.source);
+			const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
+			if (!url) {
+				spinner.stop("Update failed");
+				p.cancel(`Cannot update local source: ${candidate.name}`);
+				process.exit(1);
+			}
+			const clonedSource = await cloneGitSource({
+				url,
+				ref: candidate.latestVersion,
+				subpath: parsed.provider !== "local" && "subpath" in parsed ? parsed.subpath : void 0
+			});
+			const files = {};
+			updatedPackages[candidate.name] = {
+				source: candidate.source,
+				resolved: url,
+				version: candidate.latestVersion,
+				sha: clonedSource.sha,
+				files
+			};
+		} catch (error) {
+			spinner.stop("Update failed");
+			p.cancel(`Failed to update ${candidate.name}: ${error instanceof Error ? error.message : "Unknown error"}`);
+			process.exit(1);
+		}
+		const newLock = generateLock(updatedPackages);
+		if (lockfile) {
+			lockfile.packages = {
+				...lockfile.packages,
+				...newLock.packages
+			};
+			lockfile.locked_at = (/* @__PURE__ */ new Date()).toISOString();
+			await writeLock(lockfile, lockfilePath);
+		} else await writeLock(newLock, lockfilePath);
+		spinner.stop("Updates applied successfully");
+		p.outro(`✅ Updated ${updateCandidates.length} package${updateCandidates.length > 1 ? "s" : ""}!\n\nRun 'baton sync' to apply the updated configurations.`);
+		process.exit(0);
+	}
+});
+function getPackageName(parsed) {
+	if (parsed.provider === "local" || parsed.provider === "file") return parsed.path;
+	if (parsed.provider === "github" || parsed.provider === "gitlab") return `${parsed.org}/${parsed.repo}`;
+	if (parsed.provider === "npm") return parsed.scope ? `${parsed.scope}/${parsed.package}` : parsed.package;
+	if (parsed.provider === "git") return parsed.url;
+	return "unknown";
+}
+async function getLatestVersion(parsed) {
+	if (parsed.provider === "local") return "local";
+	const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
+	if (!url) return "HEAD";
+	return await resolveVersion(url, "latest");
+}
+async function getChangeSummary(parsed, fromVersion, toVersion) {
+	try {
+		const url = parsed.provider === "github" || parsed.provider === "gitlab" ? parsed.url : parsed.provider === "git" ? parsed.url : "";
+		if (!url) return [`Updated from ${fromVersion} to ${toVersion}`];
+		const clonedSource = await cloneGitSource({
+			url,
+			ref: toVersion,
+			subpath: parsed.provider !== "local" && "subpath" in parsed ? parsed.subpath : void 0
+		});
+		const simpleGit = (await import("simple-git")).default;
+		return (await simpleGit(clonedSource.localPath).log({
+			from: fromVersion,
+			to: toVersion,
+			maxCount: 5
+		})).all.map((commit) => commit.message.split("\n")[0]);
+	} catch {
+		return [`Updated from ${fromVersion} to ${toVersion}`];
+	}
+}
+
+//#endregion
+//#region src/index.ts
+const __dirname = dirname(fileURLToPath(import.meta.url));
+let packageJson = {};
+try {
+	packageJson = JSON.parse(await readFile(join(__dirname, "../package.json"), "utf-8"));
+} catch {}
+runMain(defineCommand({
+	meta: {
+		name: "baton",
+		version: packageJson.version,
+		description: "The package manager for Developer Experience & AI configuration. Manages Skills, Rules, Agents, Memory Files as versioned profiles."
+	},
+	args: {
+		version: {
+			type: "boolean",
+			alias: "v",
+			description: "Show version number"
+		},
+		yes: {
+			type: "boolean",
+			alias: "y",
+			description: "Suppress all interactive prompts (non-interactive mode)"
+		},
+		"dry-run": {
+			type: "boolean",
+			description: "Show what would be done without writing any files"
+		},
+		verbose: {
+			type: "boolean",
+			description: "Enable debug logging"
+		}
+	},
+	subCommands: {
+		init: initCommand,
+		sync: syncCommand,
+		update: updateCommand,
+		diff: diffCommand,
+		manage: manageCommand,
+		config: configCommand,
+		source: sourceCommand,
+		profile: profileCommand,
+		"ai-tools": aiToolsCommand,
+		ides: idesCommand
+	},
+	run({ args }) {
+		if (Object.keys(args).length === 0) {
+			console.log(`baton v${packageJson.version}`);
+			console.log("");
+			console.log("The package manager for Developer Experience & AI configuration.");
+			console.log("");
+			console.log("Usage:");
+			console.log("  baton <command> [options]");
+			console.log("");
+			console.log("Available commands:");
+			console.log("  init       Initialize Baton in your project");
+			console.log("  sync       Sync all configurations to installed AI tools");
+			console.log("  update     Check for and apply updates to installed packages");
+			console.log("  diff       Compare local files with remote source versions");
+			console.log("  manage     Interactive project management wizard");
+			console.log("  config     Show dashboard overview or configure settings");
+			console.log("");
+			console.log("Resource commands:");
+			console.log("  source     Manage source repositories (create, list, connect, disconnect)");
+			console.log("  profile    Manage profiles (create, list, remove)");
+			console.log("  ai-tools   Manage AI tool detection and configuration");
+			console.log("  ides       Manage IDE platform detection and configuration");
+			console.log("");
+			console.log("Global Options:");
+			console.log("  --help, -h         Show this help message");
+			console.log("  --version, -v      Show version number");
+			console.log("  --yes, -y          Suppress all interactive prompts");
+			console.log("  --dry-run          Show what would be done without writing files");
+			console.log("  --verbose          Enable debug logging");
+			return;
+		}
+	}
+}));
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.mjs.map