panopticon-cli 0.6.4 → 0.6.6

package/dist/sync-DMfgd389.js

@@ -0,0 +1,693 @@
+import { G as init_paths, K as isDevMode, R as SYNC_TARGET, b as PANOPTICON_HOME } from "./paths-CDJ_HsbN.js";
+import { a as init_config, i as getDevrootPath, o as loadConfig } from "./config-BQNKsi9G.js";
+import { d as migrateStalePersonalContent, f as planHooksSync, g as syncStatusline, h as syncHooks, l as executeSync, m as refreshCache, o as loadSettings, p as planSync, v as createBackup } from "./settings-BcWPTrua.js";
+import { h as listProjects, p as init_projects } from "./projects-Bk-5QhFQ.js";
+import { a as migratePanopticonToPan, i as init_workspace_manager } from "./workspace-manager-DuLhnzJV.js";
+import { existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, renameSync, statSync, symlinkSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+import chalk from "chalk";
+import { fileURLToPath } from "url";
+import ora from "ora";
+import { execSync } from "child_process";
+import yaml from "js-yaml";
+//#region src/lib/config-migration.ts
+/**
+* Configuration Migration
+*
+* Migrates from legacy settings.json format to new config.yaml format.
+* Legacy presets are no longer supported - all selection is now smart/capability-based.
+*/
+/** Path to legacy settings file */
+const LEGACY_SETTINGS_PATH = join(homedir(), ".panopticon", "settings.json");
+/** Path to new config file */
+const NEW_CONFIG_PATH = join(homedir(), ".panopticon", "config.yaml");
+/** Path to backup of legacy settings */
+const BACKUP_SETTINGS_PATH = join(homedir(), ".panopticon", "settings.json.backup");
+/**
+* Check if migration is needed
+* Returns true if settings.json exists and config.yaml doesn't
+*/
+function needsMigration() {
+	return existsSync(LEGACY_SETTINGS_PATH) && !existsSync(NEW_CONFIG_PATH);
+}
+/**
+* Check if legacy settings exist (even if already migrated)
+*/
+function hasLegacySettings() {
+	return existsSync(LEGACY_SETTINGS_PATH);
+}
+/**
+* Determine which providers are enabled based on API keys
+*/
+function detectEnabledProviders(settings) {
+	return {
+		anthropic: true,
+		openai: !!settings.api_keys.openai,
+		google: !!settings.api_keys.google,
+		zai: !!settings.api_keys.zai,
+		kimi: false
+	};
+}
+/**
+* Convert legacy settings.json to new config.yaml format
+*/
+function convertToYamlConfig(settings) {
+	return {
+		models: {
+			providers: detectEnabledProviders(settings),
+			overrides: {},
+			gemini_thinking_level: 3
+		},
+		api_keys: settings.api_keys
+	};
+}
+function migrateConfig(options = {}) {
+	const { backup = true, deleteLegacy = false, dryRun = false } = options;
+	try {
+		if (!needsMigration()) {
+			if (existsSync(NEW_CONFIG_PATH)) return {
+				success: true,
+				overridesCount: 0,
+				providersEnabled: ["anthropic"],
+				message: "Config already migrated (config.yaml exists)"
+			};
+			return {
+				success: false,
+				overridesCount: 0,
+				providersEnabled: [],
+				message: "No legacy settings.json found to migrate"
+			};
+		}
+		const yamlConfig = convertToYamlConfig(loadSettings());
+		const yamlContent = yaml.dump(yamlConfig, {
+			indent: 2,
+			lineWidth: 120,
+			noRefs: true
+		});
+		if (dryRun) {
+			const providersEnabled = Object.entries(yamlConfig.models?.providers || {}).filter(([_, enabled]) => enabled).map(([name]) => name);
+			return {
+				success: true,
+				overridesCount: Object.keys(yamlConfig.models?.overrides || {}).length,
+				providersEnabled,
+				message: `Would migrate to smart selection with ${providersEnabled.length} providers enabled`
+			};
+		}
+		writeFileSync(NEW_CONFIG_PATH, yamlContent, "utf-8");
+		if (backup) writeFileSync(BACKUP_SETTINGS_PATH, readFileSync(LEGACY_SETTINGS_PATH, "utf-8"), "utf-8");
+		if (deleteLegacy) renameSync(LEGACY_SETTINGS_PATH, `${LEGACY_SETTINGS_PATH}.migrated`);
+		const providersEnabled = Object.entries(yamlConfig.models?.providers || {}).filter(([_, enabled]) => enabled).map(([name]) => name);
+		return {
+			success: true,
+			overridesCount: Object.keys(yamlConfig.models?.overrides || {}).length,
+			providersEnabled,
+			message: `Successfully migrated to smart selection with ${providersEnabled.length} providers`
+		};
+	} catch (error) {
+		return {
+			success: false,
+			overridesCount: 0,
+			providersEnabled: [],
+			message: "Migration failed",
+			error: error.message
+		};
+	}
+}
+function cleanupLegacyRuntimeSymlinks() {
+	const legacyDirs = [
+		{
+			name: "codex",
+			base: join(homedir(), ".codex")
+		},
+		{
+			name: "cursor",
+			base: join(homedir(), ".cursor")
+		},
+		{
+			name: "gemini",
+			base: join(homedir(), ".gemini")
+		},
+		{
+			name: "opencode",
+			base: join(homedir(), ".opencode")
+		}
+	];
+	const cleaned = [];
+	const errors = [];
+	for (const { name, base } of legacyDirs) for (const subdir of [
+		"skills",
+		"commands",
+		"agents"
+	]) {
+		const dir = join(base, subdir);
+		if (!existsSync(dir)) continue;
+		try {
+			const entries = readdirSync(dir);
+			for (const entry of entries) {
+				const entryPath = join(dir, entry);
+				try {
+					if (!lstatSync(entryPath).isSymbolicLink()) continue;
+					if (readlinkSync(entryPath).includes(".panopticon")) {
+						unlinkSync(entryPath);
+						cleaned.push(`${name}/${subdir}/${entry}`);
+					}
+				} catch (err) {
+					errors.push(`${name}/${subdir}/${entry}: ${err.message}`);
+				}
+			}
+		} catch (err) {
+			errors.push(`${name}/${subdir}: ${err.message}`);
+		}
+	}
+	return {
+		cleaned,
+		total: cleaned.length,
+		errors
+	};
+}
+/**
+* Migrate legacy sync config by stripping the 'targets' field from config.toml.
+* This handles users who had `targets = ["claude", "codex"]` in their config.
+*/
+function migrateSyncTargets() {
+	const configPath = join(homedir(), ".panopticon", "config.toml");
+	if (!existsSync(configPath)) return {
+		migrated: false,
+		hadNonClaudeTargets: false
+	};
+	try {
+		const content = readFileSync(configPath, "utf-8");
+		const targetsMatch = content.match(/^targets\s*=\s*\[([^\]]*)\]/m);
+		if (!targetsMatch) return {
+			migrated: false,
+			hadNonClaudeTargets: false
+		};
+		const targetsStr = targetsMatch[1];
+		const hadNonClaudeTargets = /codex|cursor|gemini|opencode/i.test(targetsStr);
+		writeFileSync(configPath, content.replace(/^targets\s*=\s*\[[^\]]*\]\s*\n?/m, ""), "utf-8");
+		return {
+			migrated: true,
+			hadNonClaudeTargets
+		};
+	} catch {
+		return {
+			migrated: false,
+			hadNonClaudeTargets: false
+		};
+	}
+}
+//#endregion
+//#region src/lib/multi-tool-sync.ts
+/**
+* Multi-Tool Skill Sync
+*
+* Writes Panopticon skills to other AI tool formats so skills authored once
+* in .pan/skills/ are available across all configured tools.
+*
+* Configured via `tools.also_sync` in ~/.panopticon/config.yaml and .pan.yaml.
+* Per-project .pan.yaml values are merged additively with global config.
+*
+* Supported targets:
+*   cursor    → .cursor/rules/<skill-name>.mdc
+*   codex     → AGENTS.md (named blocks)
+*   windsurf  → .windsurf/rules/<skill-name>.md
+*   cline     → .clinerules/<skill-name>.md
+*   copilot   → .github/instructions/<skill-name>.instructions.md
+*   aider     → CONVENTIONS.md (named blocks)
+*/
+init_paths();
+/** Strip YAML frontmatter from a skill markdown file */
+function stripFrontmatter(content) {
+	if (!content.startsWith("---")) return content;
+	const end = content.indexOf("\n---", 4);
+	if (end === -1) return content;
+	return content.slice(end + 4).trimStart();
+}
+/** Extract the skill name from frontmatter, or fall back to dir name */
+function extractSkillName(content, fallback) {
+	if (!content.startsWith("---")) return fallback;
+	const end = content.indexOf("\n---", 4);
+	if (end === -1) return fallback;
+	const match = content.slice(4, end).match(/^name:\s*(.+)$/m);
+	return match ? match[1].trim() : fallback;
+}
+/** Read main SKILL.md content for a skill directory */
+function readSkillContent(skillDir) {
+	const skillMd = join(skillDir, "SKILL.md");
+	if (!existsSync(skillMd)) {
+		const files = existsSync(skillDir) ? readdirSync(skillDir).filter((f) => f.endsWith(".md")) : [];
+		if (files.length === 0) return null;
+		return readFileSync(join(skillDir, files[0]), "utf-8");
+	}
+	return readFileSync(skillMd, "utf-8");
+}
+/** Collect all skill directories from the given skills root */
+function collectSkillDirs(skillsDir) {
+	if (!existsSync(skillsDir)) return [];
+	return readdirSync(skillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({
+		name: e.name,
+		dir: join(skillsDir, e.name)
+	}));
+}
+/**
+* Update or insert a named block in a file.
+* Blocks are delimited by: <!-- panopticon:<skill-name> start --> ... <!-- panopticon:<skill-name> end -->
+*/
+function upsertNamedBlock(filePath, blockName, content) {
+	const startTag = `<!-- panopticon:${blockName} start -->`;
+	const endTag = `<!-- panopticon:${blockName} end -->`;
+	const block = `${startTag}\n${content}\n${endTag}`;
+	let existing = existsSync(filePath) ? readFileSync(filePath, "utf-8") : "";
+	const startIdx = existing.indexOf(startTag);
+	const endIdx = existing.indexOf(endTag);
+	if (startIdx !== -1 && endIdx !== -1 && endIdx > startIdx) existing = existing.slice(0, startIdx) + block + existing.slice(endIdx + endTag.length);
+	else {
+		if (existing.length > 0 && !existing.endsWith("\n")) existing += "\n";
+		existing += "\n" + block + "\n";
+	}
+	writeFileSync(filePath, existing, "utf-8");
+}
+/** Sync a single skill to the cursor target */
+function syncToCursor(projectPath, skillName, rawContent) {
+	const rulesDir = join(projectPath, ".cursor", "rules");
+	mkdirSync(rulesDir, { recursive: true });
+	const body = stripFrontmatter(rawContent);
+	writeFileSync(join(rulesDir, `${skillName}.mdc`), body, "utf-8");
+}
+/** Sync a single skill to the windsurf target */
+function syncToWindsurf(projectPath, skillName, rawContent) {
+	const rulesDir = join(projectPath, ".windsurf", "rules");
+	mkdirSync(rulesDir, { recursive: true });
+	writeFileSync(join(rulesDir, `${skillName}.md`), stripFrontmatter(rawContent), "utf-8");
+}
+/** Sync a single skill to the cline target */
+function syncToCline(projectPath, skillName, rawContent) {
+	const rulesDir = join(projectPath, ".clinerules");
+	mkdirSync(rulesDir, { recursive: true });
+	writeFileSync(join(rulesDir, `${skillName}.md`), stripFrontmatter(rawContent), "utf-8");
+}
+/** Sync a single skill to the copilot target */
+function syncToCopilot(projectPath, skillName, rawContent) {
+	const instructionsDir = join(projectPath, ".github", "instructions");
+	mkdirSync(instructionsDir, { recursive: true });
+	writeFileSync(join(instructionsDir, `${skillName}.instructions.md`), stripFrontmatter(rawContent), "utf-8");
+}
+/** Sync a single skill to AGENTS.md (codex) as a named block */
+function syncToCodex(projectPath, skillName, rawContent) {
+	upsertNamedBlock(join(projectPath, "AGENTS.md"), skillName, `## ${skillName}\n\n${stripFrontmatter(rawContent)}`);
+}
+/** Sync a single skill to CONVENTIONS.md (aider) as a named block */
+function syncToAider(projectPath, skillName, rawContent) {
+	upsertNamedBlock(join(projectPath, "CONVENTIONS.md"), skillName, `## ${skillName}\n\n${stripFrontmatter(rawContent)}`);
+}
+const TOOL_WRITERS = {
+	cursor: syncToCursor,
+	windsurf: syncToWindsurf,
+	cline: syncToCline,
+	copilot: syncToCopilot,
+	codex: syncToCodex,
+	aider: syncToAider
+};
+/**
+* Resolve the merged list of tools to sync.
+* Global config is the base; per-project .pan.yaml adds more (never removes).
+*/
+function resolveAlsoSyncTools(projectPath) {
+	const tools = /* @__PURE__ */ new Set();
+	const globalConfig = join(PANOPTICON_HOME, "config.yaml");
+	if (existsSync(globalConfig)) try {
+		const globalTools = yaml.load(readFileSync(globalConfig, "utf-8"))?.tools?.also_sync || [];
+		for (const t of globalTools) if (t in TOOL_WRITERS) tools.add(t);
+	} catch {}
+	if (projectPath) {
+		const panYaml = join(projectPath, ".pan.yaml");
+		const legacyYaml = join(projectPath, ".panopticon.yaml");
+		const configPath = existsSync(panYaml) ? panYaml : existsSync(legacyYaml) ? legacyYaml : null;
+		if (configPath) try {
+			const projectTools = yaml.load(readFileSync(configPath, "utf-8"))?.tools?.also_sync || [];
+			for (const t of projectTools) if (t in TOOL_WRITERS) tools.add(t);
+		} catch {}
+	}
+	return Array.from(tools);
+}
+/**
+* Sync skills from a skills directory to all configured tools.
+*
+* @param skillsDir  Directory containing skill subdirectories
+* @param projectPath  Project root where tool targets live
+* @param tools  Tools to sync to (from resolveAlsoSyncTools)
+*/
+function syncSkillsToTools(skillsDir, projectPath, tools) {
+	if (tools.length === 0 || !existsSync(skillsDir)) return [];
+	const skills = collectSkillDirs(skillsDir);
+	const results = [];
+	for (const tool of tools) {
+		const writer = TOOL_WRITERS[tool];
+		const result = {
+			tool,
+			written: [],
+			skipped: [],
+			errors: []
+		};
+		for (const { name, dir } of skills) try {
+			const rawContent = readSkillContent(dir);
+			if (!rawContent) {
+				result.skipped.push(name);
+				continue;
+			}
+			writer(projectPath, extractSkillName(rawContent, name), rawContent);
+			result.written.push(name);
+		} catch (err) {
+			result.errors.push(`${name}: ${err.message}`);
+		}
+		results.push(result);
+	}
+	return results;
+}
+/**
+* Run the full multi-tool sync for a project.
+* Sources: .pan/skills/ (project-local) and/or ~/.panopticon/skills/ (global).
+*/
+function runMultiToolSync(projectPath) {
+	const tools = resolveAlsoSyncTools(projectPath);
+	if (tools.length === 0) return [];
+	const allResults = [];
+	const globalResults = syncSkillsToTools(join(PANOPTICON_HOME, "skills"), projectPath, tools);
+	allResults.push(...globalResults);
+	const projectSkillsDir = join(projectPath, ".pan", "skills");
+	if (existsSync(projectSkillsDir)) {
+		const projectResults = syncSkillsToTools(projectSkillsDir, projectPath, tools);
+		for (const pr of projectResults) {
+			const existing = allResults.find((r) => r.tool === pr.tool);
+			if (existing) {
+				existing.written.push(...pr.written);
+				existing.errors.push(...pr.errors);
+			} else allResults.push(pr);
+		}
+	}
+	return allResults;
+}
+//#endregion
+//#region src/cli/commands/sync.ts
+init_config();
+init_paths();
+init_projects();
+init_workspace_manager();
+const BUNDLED_GIT_HOOKS_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "scripts", "git-hooks");
+function checkCommand(cmd) {
+	try {
+		execSync(`which ${cmd}`, { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function syncCommand(options) {
+	if (options.dryRun) {
+		console.log(chalk.bold("Sync Plan (dry run):\n"));
+		if (isDevMode()) console.log(chalk.magenta("Developer mode detected - dev-skills will be synced\n"));
+		const hooksPlan = planHooksSync();
+		if (hooksPlan.length > 0) {
+			console.log(chalk.cyan("hooks (bin scripts):"));
+			for (const hook of hooksPlan) {
+				const icon = hook.status === "new" ? chalk.green("+") : chalk.blue("↻");
+				const status = hook.status === "new" ? "" : chalk.dim("[update]");
+				console.log(`  ${icon} ${hook.name} ${status}`);
+			}
+			console.log("");
+		}
+		const devrootPath = getDevrootPath();
+		console.log(chalk.cyan(`devroot (${devrootPath || "disabled"}):`));
+		if (!devrootPath) console.log(chalk.dim("  (devroot disabled — set sync.devroot in config)"));
+		else {
+			const plan = planSync();
+			const allItems = [
+				...plan.skills,
+				...plan.agents,
+				...plan.rules,
+				...plan.commands
+			];
+			if (allItems.length === 0) console.log(chalk.dim("  (nothing to sync)"));
+			else for (const item of allItems) {
+				const icon = item.status === "conflict" ? chalk.yellow("!") : item.status === "symlink" ? chalk.blue("↻") : chalk.green("+");
+				const label = item.status === "conflict" ? chalk.yellow("[modified]") : item.status === "symlink" ? chalk.dim("[update]") : chalk.green("[new]");
+				console.log(`  ${icon} ${item.name} ${label}`);
+			}
+		}
+		const dryRunProjects = listProjects();
+		for (const { config } of dryRunProjects) {
+			if (!existsSync(config.path)) continue;
+			const panSkillsDir = join(config.path, ".pan", "skills");
+			if (existsSync(panSkillsDir)) {
+				const skills = readdirSync(panSkillsDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+				if (skills.length > 0) {
+					console.log(chalk.cyan(`\n.pan/skills/ (${config.name}):`));
+					for (const skillName of skills) console.log(`  ${chalk.green("+")} ${skillName} ${chalk.green("[project-local]")}`);
+				}
+			}
+			const tools = resolveAlsoSyncTools(config.path);
+			if (tools.length > 0) {
+				console.log(chalk.cyan(`\nmulti-tool sync (${config.name}): ${tools.join(", ")}`));
+				if (existsSync(join(config.path, ".pan", "skills"))) {
+					const skills = readdirSync(join(config.path, ".pan", "skills"), { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+					for (const tool of tools) for (const skillName of skills) console.log(`  ${chalk.green("+")} ${skillName} → ${tool}`);
+				}
+			}
+		}
+		console.log("");
+		console.log(chalk.dim("Run without --dry-run to apply changes."));
+		return;
+	}
+	const syncMigration = migrateSyncTargets();
+	if (syncMigration.migrated) {
+		if (syncMigration.hadNonClaudeTargets) console.log(chalk.yellow("Config updated: removed non-Claude sync targets (Panopticon now syncs to Claude Code only)."));
+	}
+	const cleanupResult = cleanupLegacyRuntimeSymlinks();
+	if (cleanupResult.cleaned.length > 0) console.log(chalk.dim(`Removed ${cleanupResult.total} legacy runtime symlink(s): ${cleanupResult.cleaned.join(", ")}`));
+	const migration = migrateStalePersonalContent();
+	if (migration.removedSymlinks.length > 0) {
+		console.log(chalk.cyan(`Migrated: removed ${migration.removedSymlinks.length} Panopticon symlink(s) from ~/.claude/`));
+		if (migration.preservedUserContent.length > 0) console.log(chalk.dim(`  Preserved ${migration.preservedUserContent.length} user-created item(s)`));
+	}
+	if (loadConfig().sync.backup_before_sync) {
+		const spinner = ora("Creating backup...").start();
+		const backup = createBackup([
+			SYNC_TARGET.skills,
+			SYNC_TARGET.commands,
+			SYNC_TARGET.agents
+		]);
+		if (backup.targets.length > 0) spinner.succeed(`Backup created: ${backup.timestamp}`);
+		else spinner.info("No existing content to backup");
+		if (options.backupOnly) return;
+	}
+	const cacheSpinner = ora("Refreshing cache from repo...").start();
+	const cacheResult = refreshCache();
+	const cacheParts = [];
+	if (cacheResult.skills.copied > 0) cacheParts.push(`${cacheResult.skills.copied} skills`);
+	if (cacheResult.agents.copied > 0) cacheParts.push(`${cacheResult.agents.copied} agents`);
+	if (cacheResult.rules.copied > 0) cacheParts.push(`${cacheResult.rules.copied} rules`);
+	cacheSpinner.succeed(`Cache refreshed: ${cacheParts.length > 0 ? cacheParts.join(", ") : "up to date"}`);
+	const devrootPath = getDevrootPath();
+	const spinner = ora(`Syncing to devroot (${devrootPath || "disabled"})...`).start();
+	if (!devrootPath) spinner.info("Devroot disabled (set sync.devroot in config to enable)");
+	else {
+		const result = executeSync({
+			force: options.force,
+			diff: options.diff
+		});
+		const totalSynced = result.created.length + result.updated.length;
+		if (result.diffs.length > 0) {
+			spinner.info(`Showing diffs for ${result.diffs.length} modified file(s):\n`);
+			for (const d of result.diffs) {
+				console.log(chalk.cyan(`--- ${d.path} (installed)`));
+				console.log(chalk.cyan(`+++ ${d.path} (current on disk)`));
+				const sourceLines = d.sourceContent.split("\n");
+				const targetLines = d.targetContent.split("\n");
+				const maxLines = Math.max(sourceLines.length, targetLines.length);
+				for (let i = 0; i < maxLines; i++) if (sourceLines[i] !== targetLines[i]) {
+					if (targetLines[i] !== void 0) console.log(chalk.red(`- ${targetLines[i]}`));
+					if (sourceLines[i] !== void 0) console.log(chalk.green(`+ ${sourceLines[i]}`));
+				}
+				console.log("");
+			}
+		}
+		if (result.conflicts.length > 0 && !options.force) {
+			spinner.warn(`Synced ${totalSynced} items, ${result.conflicts.length} conflicts`);
+			console.log("");
+			console.log(chalk.yellow("Modified since Panopticon installed:"));
+			for (const name of result.conflicts) console.log(chalk.dim(`  - ${name}`));
+			console.log("");
+			console.log(chalk.dim("Use --force to overwrite, --diff to see changes."));
+		} else if (result.skipped.length > 0) spinner.succeed(`Synced ${totalSynced} items to devroot (${result.skipped.length} user-owned skipped)`);
+		else spinner.succeed(`Synced ${totalSynced} items to devroot`);
+	}
+	const hooksSpinner = ora("Syncing hooks...").start();
+	const hooksResult = syncHooks();
+	if (hooksResult.errors.length > 0) {
+		hooksSpinner.warn(`Synced ${hooksResult.synced.length} hooks, ${hooksResult.errors.length} errors`);
+		for (const error of hooksResult.errors) console.log(chalk.red(`  ✗ ${error}`));
+	} else if (hooksResult.synced.length > 0) hooksSpinner.succeed(`Synced ${hooksResult.synced.length} hooks to ~/.panopticon/bin/`);
+	else hooksSpinner.info("No hooks to sync");
+	const projects = listProjects();
+	if (projects.length > 0 && checkCommand("bd")) for (const { key, config } of projects) {
+		if (!existsSync(config.path)) continue;
+		if (!existsSync(join(config.path, ".beads"))) continue;
+		try {
+			execSync("bd list --json --limit 0 2>&1", {
+				cwd: config.path,
+				stdio: "pipe",
+				timeout: 8e3
+			});
+		} catch (e) {
+			const msg = String(e?.stdout ?? e?.stderr ?? e?.message ?? "");
+			if (msg.includes("database") && (msg.includes("not found") || msg.includes("not exist") || msg.includes("defaulting"))) {
+				const beadsSpinner = ora(`Initializing beads database for ${config.name}...`).start();
+				try {
+					const prefix = (key || config.name).toLowerCase().replace(/[^a-z0-9-]/g, "-");
+					execSync(`bd init --prefix ${prefix}`, {
+						cwd: config.path,
+						stdio: "pipe",
+						timeout: 2e4
+					});
+					try {
+						execSync("git config beads.role contributor", {
+							cwd: config.path,
+							stdio: "pipe"
+						});
+					} catch {}
+					beadsSpinner.succeed(`Beads database initialized for ${config.name} (prefix: ${prefix})`);
+				} catch {
+					beadsSpinner.warn(`Could not auto-initialize beads for ${config.name} — run: cd ${config.path} && bd init`);
+				}
+			}
+		}
+	}
+	if (!checkCommand("jq")) {
+		console.log(chalk.yellow("\n  ⚠ jq not found — statusline and other features need it"));
+		console.log(chalk.dim("    Install: apt install jq / brew install jq\n"));
+	}
+	const statuslineSpinner = ora("Syncing statusline...").start();
+	const statuslineResult = syncStatusline();
+	if (statuslineResult.errors.length > 0) {
+		statuslineSpinner.warn(`Synced statusline to ${statuslineResult.synced.length} runtime(s), ${statuslineResult.errors.length} error(s)`);
+		for (const error of statuslineResult.errors) console.log(chalk.red(`  ✗ ${error}`));
+	} else if (statuslineResult.synced.length > 0) statuslineSpinner.succeed(`Synced statusline to ${statuslineResult.synced.join(", ")}`);
+	else statuslineSpinner.info("No statusline script found (scripts/statusline.sh)");
+	if (!checkCommand("claude-code-router")) {
+		const routerSpinner = ora("Installing claude-code-router...").start();
+		try {
+			execSync("npm install -g @musistudio/claude-code-router", {
+				stdio: "pipe",
+				timeout: 12e4
+			});
+			routerSpinner.succeed("claude-code-router installed");
+		} catch (error) {
+			routerSpinner.warn("Failed to install claude-code-router - run: npm install -g @musistudio/claude-code-router");
+		}
+	}
+	if (!checkCommand("mkcert")) {
+		const mkcertSpinner = ora("Installing mkcert...").start();
+		try {
+			const binDir = join(homedir(), ".local", "bin");
+			mkdirSync(binDir, { recursive: true });
+			const mkcertPath = join(binDir, "mkcert");
+			execSync(`curl -sL "https://github.com/FiloSottile/mkcert/releases/latest/download/mkcert-v1.4.4-linux-${process.arch === "x64" ? "amd64" : process.arch}" -o "${mkcertPath}" && chmod +x "${mkcertPath}"`, {
+				stdio: "pipe",
+				timeout: 6e4
+			});
+			mkcertSpinner.succeed("mkcert installed");
+		} catch {
+			mkcertSpinner.warn("Failed to install mkcert - run: https://github.com/FiloSottile/mkcert/releases");
+		}
+	}
+	if (!checkCommand("ox")) {
+		const oxSpinner = ora("Installing SageOx CLI (ox)...").start();
+		try {
+			const binDir = join(homedir(), ".local", "bin");
+			mkdirSync(binDir, { recursive: true });
+			const oxPath = join(binDir, "ox");
+			const arch = process.arch === "x64" ? "amd64" : process.arch;
+			execSync(`curl -sL "https://github.com/eltmon/ox/releases/download/latest/ox-${process.platform === "darwin" ? "darwin" : "linux"}-${arch}" -o "${oxPath}" && chmod +x "${oxPath}"`, {
+				stdio: "pipe",
+				timeout: 6e4
+			});
+			oxSpinner.succeed("SageOx CLI installed");
+		} catch {
+			oxSpinner.warn("Failed to install SageOx CLI - see: https://github.com/eltmon/ox/releases");
+		}
+	}
+	const mcpPath = join(homedir(), ".claude", "mcp.json");
+	try {
+		if (existsSync(mcpPath)) {
+			const mcpConfig = JSON.parse(readFileSync(mcpPath, "utf-8"));
+			const pw = mcpConfig?.mcpServers?.playwright;
+			if (pw && Array.isArray(pw.args) && !pw.args.includes("--isolated")) {
+				pw.args.push("--isolated");
+				writeFileSync(mcpPath, JSON.stringify(mcpConfig, null, 2) + "\n");
+				console.log(chalk.green("✓ Added --isolated to Playwright MCP (prevents stale zoom/profile state)"));
+			}
+		}
+	} catch {}
+	for (const { config } of projects) {
+		if (!existsSync(config.path)) continue;
+		const migResult = migratePanopticonToPan(config.path);
+		if (migResult.migrated.length > 0) console.log(chalk.cyan(`Migrated .panopticon/ → .pan/ in ${config.name}: ${migResult.migrated.join(", ")}`));
+		if (migResult.skipped.length > 0) console.log(chalk.yellow(`Migration skipped (both exist) in ${config.name}: ${migResult.skipped.join(", ")}`));
+		for (const err of migResult.errors) console.log(chalk.red(`Migration error in ${config.name}: ${err}`));
+		const toolSyncResults = runMultiToolSync(config.path);
+		for (const r of toolSyncResults) {
+			if (r.written.length > 0) console.log(chalk.cyan(`Synced ${r.written.length} skill(s) to ${r.tool} in ${config.name}`));
+			for (const err of r.errors) console.log(chalk.red(`Multi-tool sync error (${r.tool}) in ${config.name}: ${err}`));
+		}
+	}
+	if (projects.length > 0 && existsSync(BUNDLED_GIT_HOOKS_DIR)) {
+		const gitHooksSpinner = ora("Installing git hooks in registered projects...").start();
+		let totalInstalled = 0;
+		let projectsUpdated = 0;
+		for (const { config } of projects) {
+			if (!existsSync(config.path)) continue;
+			const gitDirs = [];
+			if (existsSync(join(config.path, ".git")) && statSync(join(config.path, ".git")).isDirectory()) gitDirs.push(join(config.path, ".git"));
+			else try {
+				const entries = readdirSync(config.path);
+				for (const entry of entries) {
+					const gitPath = join(join(config.path, entry), ".git");
+					if (existsSync(gitPath) && statSync(gitPath).isDirectory()) gitDirs.push(gitPath);
+				}
+			} catch {}
+			for (const gitDir of gitDirs) {
+				const hooksTarget = join(gitDir, "hooks");
+				if (!existsSync(hooksTarget)) mkdirSync(hooksTarget, { recursive: true });
+				try {
+					const hooks = readdirSync(BUNDLED_GIT_HOOKS_DIR).filter((f) => statSync(join(BUNDLED_GIT_HOOKS_DIR, f)).isFile());
+					for (const hook of hooks) {
+						const source = join(BUNDLED_GIT_HOOKS_DIR, hook);
+						const target = join(hooksTarget, hook);
+						if (existsSync(target)) {
+							try {
+								const { readlinkSync } = await import("fs");
+								if (readlinkSync(target) === source) continue;
+							} catch {}
+							const { renameSync } = await import("fs");
+							try {
+								renameSync(target, `${target}.backup`);
+							} catch {}
+						}
+						try {
+							symlinkSync(source, target);
+							totalInstalled++;
+						} catch {}
+					}
+					projectsUpdated++;
+				} catch {}
+			}
+		}
+		if (totalInstalled > 0) gitHooksSpinner.succeed(`Installed git hooks in ${projectsUpdated} project(s)`);
+		else gitHooksSpinner.info("Git hooks already up to date");
+	}
+}
+//#endregion
+export { needsMigration as i, hasLegacySettings as n, migrateConfig as r, syncCommand as t };
+
+//# sourceMappingURL=sync-DMfgd389.js.map