formalconf 2.0.0

package/dist/formalconf.js

@@ -0,0 +1,2339 @@
+#!/usr/bin/env node
+// src/cli/formalconf.tsx
+import { useState as useState4, useEffect as useEffect3, useMemo } from "react";
+import { render, Box as Box10, Text as Text9, useApp, useInput as useInput3 } from "ink";
+import { Spinner } from "@inkjs/ui";
+
+// src/components/ui/VimSelect.tsx
+import { useState } from "react";
+import { Box, Text, useInput } from "ink";
+
+// src/lib/theme.ts
+var colors = {
+  primary: "#5eead4",
+  primaryDim: "#2dd4bf",
+  accent: "#06b6d4",
+  success: "#22c55e",
+  error: "#ef4444",
+  warning: "#f59e0b",
+  info: "#3b82f6",
+  text: "white",
+  textDim: "gray",
+  border: "#374151",
+  borderLight: "#4b5563"
+};
+var borderStyles = {
+  panel: "round",
+  header: "round",
+  footer: "single"
+};
+
+// src/components/ui/VimSelect.tsx
+import { jsxDEV } from "react/jsx-dev-runtime";
+function VimSelect({ options, onChange, isDisabled = false }) {
+  const [index, setIndex] = useState(0);
+  useInput((input, key) => {
+    if (isDisabled)
+      return;
+    if (input === "j" || key.downArrow) {
+      setIndex((i) => i < options.length - 1 ? i + 1 : i);
+    }
+    if (input === "k" || key.upArrow) {
+      setIndex((i) => i > 0 ? i - 1 : i);
+    }
+    if (input === "l" || key.return) {
+      onChange(options[index].value);
+    }
+  });
+  return /* @__PURE__ */ jsxDEV(Box, {
+    flexDirection: "column",
+    children: options.map((opt, i) => /* @__PURE__ */ jsxDEV(Box, {
+      children: /* @__PURE__ */ jsxDEV(Text, {
+        color: i === index ? colors.primary : undefined,
+        children: [
+          i === index ? "❯" : " ",
+          " ",
+          opt.label
+        ]
+      }, undefined, true, undefined, this)
+    }, opt.value, false, undefined, this))
+  }, undefined, false, undefined, this);
+}
+
+// src/cli/formalconf.tsx
+import { readdirSync as readdirSync5, existsSync as existsSync6 } from "fs";
+import { join as join5 } from "path";
+
+// src/components/layout/Layout.tsx
+import { Box as Box6 } from "ink";
+
+// src/hooks/useTerminalSize.ts
+import { useStdout } from "ink";
+import { useState as useState2, useEffect } from "react";
+function useTerminalSize() {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState2({
+    columns: stdout.columns || 80,
+    rows: stdout.rows || 24
+  });
+  useEffect(() => {
+    const handleResize = () => {
+      setSize({
+        columns: stdout.columns || 80,
+        rows: stdout.rows || 24
+      });
+    };
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  return size;
+}
+
+// src/components/Header.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+
+// src/hooks/useSystemStatus.ts
+import { useState as useState3, useEffect as useEffect2 } from "react";
+import { existsSync, readlinkSync, readdirSync, lstatSync } from "fs";
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+
+// src/lib/runtime.ts
+import { spawn as nodeSpawn } from "child_process";
+import { readFile as nodeReadFile, writeFile as nodeWriteFile, mkdir } from "fs/promises";
+import { dirname } from "path";
+import { fileURLToPath } from "url";
+var isBun = typeof Bun !== "undefined";
+async function exec(command, cwd) {
+  if (isBun) {
+    const proc = Bun.spawn(command, {
+      stdout: "pipe",
+      stderr: "pipe",
+      cwd
+    });
+    const [stdout, stderr] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text()
+    ]);
+    const exitCode = await proc.exited;
+    return {
+      stdout: stdout.trim(),
+      stderr: stderr.trim(),
+      exitCode,
+      success: exitCode === 0
+    };
+  }
+  return new Promise((resolve) => {
+    const [cmd, ...args] = command;
+    const proc = nodeSpawn(cmd, args, { cwd, shell: false });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (data) => {
+      stdout += data;
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data;
+    });
+    proc.on("close", (code) => {
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: code ?? 1,
+        success: code === 0
+      });
+    });
+  });
+}
+async function execLive(command, cwd) {
+  if (isBun) {
+    const proc = Bun.spawn(command, {
+      stdout: "inherit",
+      stderr: "inherit",
+      stdin: "inherit",
+      cwd
+    });
+    return await proc.exited;
+  }
+  return new Promise((resolve) => {
+    const [cmd, ...args] = command;
+    const proc = nodeSpawn(cmd, args, {
+      cwd,
+      stdio: "inherit",
+      shell: false
+    });
+    proc.on("close", (code) => {
+      resolve(code ?? 1);
+    });
+  });
+}
+async function readJson(path) {
+  if (isBun) {
+    return Bun.file(path).json();
+  }
+  const content = await nodeReadFile(path, "utf-8");
+  return JSON.parse(content);
+}
+async function readText(path) {
+  if (isBun) {
+    return Bun.file(path).text();
+  }
+  return nodeReadFile(path, "utf-8");
+}
+async function writeFile(path, content) {
+  if (isBun) {
+    await Bun.write(path, content);
+    return;
+  }
+  await nodeWriteFile(path, content, "utf-8");
+}
+async function ensureDir(path) {
+  if (isBun) {
+    await Bun.$`mkdir -p ${path}`.quiet();
+    return;
+  }
+  await mkdir(path, { recursive: true });
+}
+function getScriptDir(importMeta) {
+  if (isBun && importMeta.dir) {
+    return importMeta.dir;
+  }
+  if (importMeta.dirname) {
+    return importMeta.dirname;
+  }
+  return dirname(fileURLToPath(importMeta.url));
+}
+async function commandExists(cmd) {
+  const result = await exec(["which", cmd]);
+  return result.success;
+}
+
+// src/lib/paths.ts
+var HOME_DIR = homedir();
+var CONFIG_DIR = join(HOME_DIR, ".config", "formalconf");
+var THEME_TARGET_DIR = join(CONFIG_DIR, "current", "theme");
+var BACKGROUNDS_TARGET_DIR = join(CONFIG_DIR, "current", "backgrounds");
+var scriptPath = getScriptDir(import.meta);
+var ROOT_DIR = join(scriptPath, "..", "..");
+var CONFIGS_DIR = join(CONFIG_DIR, "configs");
+var THEMES_DIR = join(CONFIG_DIR, "themes");
+var PKG_CONFIG_PATH = join(CONFIG_DIR, "pkg-config.json");
+var PKG_LOCK_PATH = join(CONFIG_DIR, "pkg-lock.json");
+async function ensureDir2(path) {
+  await ensureDir(path);
+}
+async function ensureConfigDir() {
+  await ensureDir2(CONFIG_DIR);
+  await ensureDir2(CONFIGS_DIR);
+  await ensureDir2(THEMES_DIR);
+  await ensureDir2(THEME_TARGET_DIR);
+  await ensureDir2(BACKGROUNDS_TARGET_DIR);
+}
+
+// src/hooks/useSystemStatus.ts
+import { basename, dirname as dirname2, join as join2 } from "path";
+function useSystemStatus() {
+  const [status, setStatus] = useState3({
+    currentTheme: null,
+    configsLinked: false,
+    loading: true
+  });
+  useEffect2(() => {
+    let theme = null;
+    try {
+      if (existsSync(THEME_TARGET_DIR)) {
+        const entries = readdirSync(THEME_TARGET_DIR);
+        for (const entry of entries) {
+          const entryPath = join2(THEME_TARGET_DIR, entry);
+          if (lstatSync(entryPath).isSymbolicLink()) {
+            const target = readlinkSync(entryPath);
+            theme = basename(dirname2(target));
+            break;
+          }
+        }
+      }
+    } catch {}
+    let configsLinked = false;
+    try {
+      if (existsSync(CONFIGS_DIR)) {
+        const entries = readdirSync(CONFIGS_DIR);
+        configsLinked = entries.length > 0;
+      }
+    } catch {}
+    setStatus({
+      currentTheme: theme,
+      configsLinked,
+      loading: false
+    });
+  }, []);
+  return status;
+}
+
+// src/components/ui/StatusIndicator.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsxDEV as jsxDEV2 } from "react/jsx-dev-runtime";
+function StatusIndicator({
+  label,
+  value,
+  status = "neutral"
+}) {
+  const statusColors = {
+    success: colors.success,
+    warning: colors.warning,
+    error: colors.error,
+    neutral: colors.textDim
+  };
+  const icon = {
+    success: "●",
+    warning: "●",
+    error: "●",
+    neutral: "○"
+  };
+  return /* @__PURE__ */ jsxDEV2(Box2, {
+    gap: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV2(Text2, {
+        dimColor: true,
+        children: [
+          label,
+          ":"
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV2(Text2, {
+        color: statusColors[status],
+        children: [
+          icon[status],
+          " ",
+          value || "None"
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+// package.json
+var package_default = {
+  name: "formalconf",
+  version: "2.0.0",
+  description: "Dotfiles management TUI for macOS - config management, package sync, and theme switching",
+  type: "module",
+  main: "./dist/formalconf.js",
+  bin: {
+    formalconf: "dist/formalconf.js"
+  },
+  files: [
+    "dist"
+  ],
+  scripts: {
+    formalconf: "bun run src/cli/formalconf.tsx",
+    config: "bun run src/cli/config-manager.ts",
+    "pkg-sync": "bun run src/cli/pkg-sync.ts",
+    "pkg-lock": "bun run src/cli/pkg-lock.ts",
+    theme: "bun run src/cli/set-theme.ts",
+    typecheck: "bun tsc --noEmit",
+    build: "bun run scripts/build.ts",
+    prepublishOnly: "bun run build"
+  },
+  engines: {
+    node: ">=20.11.0"
+  },
+  keywords: [
+    "dotfiles",
+    "config",
+    "stow",
+    "homebrew",
+    "macos",
+    "tui",
+    "cli",
+    "themes"
+  ],
+  author: "Kyan De Sutter <hello@formalsnake.dev>",
+  license: "MIT",
+  repository: {
+    type: "git",
+    url: "git+https://github.com/FormalSnake/formalconf.git"
+  },
+  dependencies: {
+    ink: "^5.0.1",
+    "@inkjs/ui": "^2.0.0",
+    react: "^18.3.1"
+  },
+  devDependencies: {
+    "@types/bun": "latest",
+    "@types/node": "^20.0.0",
+    "@types/react": "^18.3.0",
+    typescript: "^5.0.0"
+  }
+};
+
+// src/components/Header.tsx
+import { jsxDEV as jsxDEV3 } from "react/jsx-dev-runtime";
+function Header() {
+  const { columns } = useTerminalSize();
+  const { currentTheme, configsLinked, loading } = useSystemStatus();
+  return /* @__PURE__ */ jsxDEV3(Box3, {
+    flexDirection: "column",
+    width: columns - 2,
+    borderStyle: borderStyles.header,
+    borderColor: colors.primary,
+    paddingX: 2,
+    marginBottom: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV3(Box3, {
+        justifyContent: "space-between",
+        width: "100%",
+        children: [
+          /* @__PURE__ */ jsxDEV3(Box3, {
+            children: [
+              /* @__PURE__ */ jsxDEV3(Text3, {
+                bold: true,
+                color: colors.primary,
+                children: "FormalConf"
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsxDEV3(Text3, {
+                dimColor: true,
+                children: " - Dotfiles Manager"
+              }, undefined, false, undefined, this)
+            ]
+          }, undefined, true, undefined, this),
+          /* @__PURE__ */ jsxDEV3(Text3, {
+            dimColor: true,
+            children: [
+              "v",
+              package_default.version
+            ]
+          }, undefined, true, undefined, this)
+        ]
+      }, undefined, true, undefined, this),
+      !loading && /* @__PURE__ */ jsxDEV3(Box3, {
+        marginTop: 1,
+        gap: 4,
+        children: [
+          /* @__PURE__ */ jsxDEV3(StatusIndicator, {
+            label: "Theme",
+            value: currentTheme,
+            status: currentTheme ? "success" : "neutral"
+          }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsxDEV3(StatusIndicator, {
+            label: "Configs",
+            value: configsLinked ? "Linked" : "Not linked",
+            status: configsLinked ? "success" : "warning"
+          }, undefined, false, undefined, this)
+        ]
+      }, undefined, true, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/layout/Footer.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsxDEV as jsxDEV4 } from "react/jsx-dev-runtime";
+var defaultShortcuts = [
+  { key: "↑↓/jk", label: "Navigate" },
+  { key: "Enter/l", label: "Select" },
+  { key: "ESC/h", label: "Back" },
+  { key: "q", label: "Quit" }
+];
+function Footer({ shortcuts = defaultShortcuts }) {
+  const { columns } = useTerminalSize();
+  return /* @__PURE__ */ jsxDEV4(Box4, {
+    width: columns - 2,
+    borderStyle: borderStyles.footer,
+    borderColor: colors.border,
+    paddingX: 2,
+    marginTop: 1,
+    justifyContent: "center",
+    gap: 2,
+    children: shortcuts.map((shortcut, index) => /* @__PURE__ */ jsxDEV4(Box4, {
+      gap: 1,
+      children: [
+        /* @__PURE__ */ jsxDEV4(Text4, {
+          color: colors.primary,
+          bold: true,
+          children: shortcut.key
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV4(Text4, {
+          dimColor: true,
+          children: shortcut.label
+        }, undefined, false, undefined, this)
+      ]
+    }, index, true, undefined, this))
+  }, undefined, false, undefined, this);
+}
+
+// src/components/layout/Breadcrumb.tsx
+import React2 from "react";
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsxDEV as jsxDEV5 } from "react/jsx-dev-runtime";
+function Breadcrumb({ path }) {
+  return /* @__PURE__ */ jsxDEV5(Box5, {
+    children: path.map((segment, index) => /* @__PURE__ */ jsxDEV5(React2.Fragment, {
+      children: [
+        index > 0 && /* @__PURE__ */ jsxDEV5(Text5, {
+          color: colors.textDim,
+          children: [
+            " ",
+            ">",
+            " "
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV5(Text5, {
+          color: index === path.length - 1 ? colors.primary : colors.textDim,
+          bold: index === path.length - 1,
+          children: segment
+        }, undefined, false, undefined, this)
+      ]
+    }, index, true, undefined, this))
+  }, undefined, false, undefined, this);
+}
+
+// src/components/layout/Layout.tsx
+import { jsxDEV as jsxDEV6 } from "react/jsx-dev-runtime";
+function Layout({
+  children,
+  breadcrumb = ["Main"],
+  showFooter = true
+}) {
+  const { columns } = useTerminalSize();
+  return /* @__PURE__ */ jsxDEV6(Box6, {
+    flexDirection: "column",
+    width: columns,
+    padding: 1,
+    children: [
+      /* @__PURE__ */ jsxDEV6(Header, {}, undefined, false, undefined, this),
+      breadcrumb.length > 1 && /* @__PURE__ */ jsxDEV6(Box6, {
+        marginBottom: 1,
+        marginLeft: 1,
+        children: /* @__PURE__ */ jsxDEV6(Breadcrumb, {
+          path: breadcrumb
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV6(Box6, {
+        flexDirection: "column",
+        flexGrow: 1,
+        children
+      }, undefined, false, undefined, this),
+      showFooter && /* @__PURE__ */ jsxDEV6(Footer, {}, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/layout/Panel.tsx
+import { Box as Box7, Text as Text6 } from "ink";
+import { jsxDEV as jsxDEV7 } from "react/jsx-dev-runtime";
+function Panel({
+  title,
+  children,
+  width,
+  flexGrow,
+  borderColor = colors.border
+}) {
+  return /* @__PURE__ */ jsxDEV7(Box7, {
+    flexDirection: "column",
+    width,
+    flexGrow,
+    borderStyle: borderStyles.panel,
+    borderColor,
+    paddingX: 1,
+    children: [
+      title && /* @__PURE__ */ jsxDEV7(Box7, {
+        marginBottom: 1,
+        children: /* @__PURE__ */ jsxDEV7(Text6, {
+          bold: true,
+          color: colors.primary,
+          children: title
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      children
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/CommandOutput.tsx
+import { Box as Box8, Text as Text7, useInput as useInput2 } from "ink";
+import { jsxDEV as jsxDEV8 } from "react/jsx-dev-runtime";
+function CommandOutput({
+  title,
+  output,
+  success = true,
+  onDismiss
+}) {
+  useInput2(() => {
+    onDismiss();
+  });
+  return /* @__PURE__ */ jsxDEV8(Panel, {
+    title,
+    borderColor: success ? colors.success : colors.error,
+    children: [
+      output && /* @__PURE__ */ jsxDEV8(Box8, {
+        flexDirection: "column",
+        marginBottom: 1,
+        children: /* @__PURE__ */ jsxDEV8(Text7, {
+          children: output
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV8(Text7, {
+        color: success ? colors.success : colors.error,
+        children: success ? "Done" : "Failed"
+      }, undefined, false, undefined, this),
+      /* @__PURE__ */ jsxDEV8(Text7, {
+        dimColor: true,
+        children: "Press any key to continue..."
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+
+// src/components/ThemeCard.tsx
+import { Box as Box9, Text as Text8 } from "ink";
+import { jsxDEV as jsxDEV9 } from "react/jsx-dev-runtime";
+function ThemeCard({ theme, isSelected, width }) {
+  const borderColor = isSelected ? colors.accent : colors.border;
+  const nameColor = isSelected ? colors.primary : colors.text;
+  const indicators = [];
+  if (theme.hasBackgrounds)
+    indicators.push("bg");
+  if (theme.isLightMode)
+    indicators.push("light");
+  const indicatorText = indicators.length > 0 ? ` [${indicators.join(" ")}]` : "";
+  return /* @__PURE__ */ jsxDEV9(Box9, {
+    flexDirection: "column",
+    width,
+    borderStyle: borderStyles.panel,
+    borderColor,
+    paddingX: 1,
+    children: /* @__PURE__ */ jsxDEV9(Box9, {
+      children: [
+        /* @__PURE__ */ jsxDEV9(Text8, {
+          color: isSelected ? colors.accent : colors.primaryDim,
+          children: isSelected ? "● " : "  "
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV9(Text8, {
+          color: nameColor,
+          bold: true,
+          wrap: "truncate",
+          children: theme.name
+        }, undefined, false, undefined, this),
+        /* @__PURE__ */ jsxDEV9(Text8, {
+          color: colors.primaryDim,
+          children: indicatorText
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this)
+  }, undefined, false, undefined, this);
+}
+
+// src/lib/theme-parser.ts
+import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+function parseYaml(content) {
+  const result = {};
+  const lines = content.split(`
+`);
+  let currentSection = null;
+  let currentKey = "";
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const indentLevel = line.search(/\S/);
+    const match = trimmed.match(/^([\w-]+):\s*(.*)$/);
+    if (match) {
+      const [, key, value] = match;
+      if (indentLevel === 0) {
+        if (value) {
+          result[key] = value.replace(/^["']|["']$/g, "");
+        } else {
+          currentKey = key;
+          currentSection = {};
+          result[key] = currentSection;
+        }
+      } else if (currentSection) {
+        currentSection[key] = value.replace(/^["']|["']$/g, "");
+      }
+    }
+  }
+  return result;
+}
+async function parseThemeMetadata(themePath) {
+  const yamlPath = join3(themePath, "theme.yaml");
+  if (!existsSync2(yamlPath)) {
+    return;
+  }
+  try {
+    const content = await readText(yamlPath);
+    const parsed = parseYaml(content);
+    return {
+      name: parsed.name || "",
+      author: parsed.author,
+      description: parsed.description,
+      version: parsed.version,
+      source: parsed.source,
+      colors: parsed.colors
+    };
+  } catch {
+    return;
+  }
+}
+function parseThemeFiles(themePath) {
+  const entries = readdirSync2(themePath, { withFileTypes: true });
+  return entries.filter((e) => e.isFile() && !e.name.startsWith(".") && e.name !== "theme.yaml" && e.name !== "light.mode").map((e) => ({
+    name: e.name,
+    path: join3(themePath, e.name),
+    application: e.name.replace(/\.(conf|theme|lua|toml|css|json|ini)$/, "")
+  }));
+}
+async function parseTheme(themePath, themeName) {
+  const files = parseThemeFiles(themePath);
+  const metadata = await parseThemeMetadata(themePath);
+  return {
+    name: metadata?.name || themeName,
+    path: themePath,
+    files,
+    metadata,
+    hasBackgrounds: existsSync2(join3(themePath, "backgrounds")),
+    hasPreview: existsSync2(join3(themePath, "preview.png")),
+    isLightMode: existsSync2(join3(themePath, "light.mode"))
+  };
+}
+
+// src/cli/config-manager.ts
+import { parseArgs } from "util";
+import { readdirSync as readdirSync3, existsSync as existsSync3, lstatSync as lstatSync2, readlinkSync as readlinkSync2 } from "fs";
+var colors2 = {
+  red: "\x1B[0;31m",
+  green: "\x1B[0;32m",
+  blue: "\x1B[0;34m",
+  yellow: "\x1B[1;33m",
+  cyan: "\x1B[0;36m",
+  reset: "\x1B[0m"
+};
+async function checkStow() {
+  if (!await commandExists("stow")) {
+    console.error(`${colors2.red}Error: GNU Stow is not installed. Install with: brew install stow${colors2.reset}`);
+    process.exit(1);
+  }
+}
+function listPackages() {
+  const entries = readdirSync3(CONFIGS_DIR, { withFileTypes: true });
+  return entries.filter((e) => e.isDirectory()).map((e) => ({
+    name: e.name,
+    path: `${CONFIGS_DIR}/${e.name}`,
+    isStowed: checkPackageStowed(e.name)
+  }));
+}
+function checkPackageStowed(packageName) {
+  const packageDir = `${CONFIGS_DIR}/${packageName}`;
+  if (!existsSync3(packageDir))
+    return false;
+  const entries = readdirSync3(packageDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const targetPath = `${HOME_DIR}/${entry.name}`;
+    if (!existsSync3(targetPath))
+      return false;
+    try {
+      const stat = lstatSync2(targetPath);
+      if (!stat.isSymbolicLink())
+        continue;
+      const linkTarget = readlinkSync2(targetPath);
+      if (!linkTarget.includes(packageDir))
+        return false;
+    } catch {
+      return false;
+    }
+  }
+  return true;
+}
+async function stowPackage(packageName) {
+  const result = await exec(["stow", "-v", "--target", HOME_DIR, packageName], CONFIGS_DIR);
+  return {
+    success: result.success,
+    package: packageName,
+    message: result.success ? `${packageName} stowed successfully` : result.stderr
+  };
+}
+async function unstowPackage(packageName) {
+  const result = await exec(["stow", "-v", "--delete", "--target", HOME_DIR, packageName], CONFIGS_DIR);
+  return {
+    success: result.success,
+    package: packageName,
+    message: result.success ? `${packageName} unstowed successfully` : result.stderr
+  };
+}
+async function restowPackage(packageName) {
+  const result = await exec(["stow", "-v", "--restow", "--target", HOME_DIR, packageName], CONFIGS_DIR);
+  return {
+    success: result.success,
+    package: packageName,
+    message: result.success ? `${packageName} restowed successfully` : result.stderr
+  };
+}
+async function adoptPackage(packageName) {
+  const result = await exec(["stow", "-v", "--adopt", "--target", HOME_DIR, packageName], CONFIGS_DIR);
+  return {
+    success: result.success,
+    package: packageName,
+    message: result.success ? `${packageName} adopted successfully` : result.stderr
+  };
+}
+async function showStatus() {
+  const packages = listPackages();
+  console.log(`
+${colors2.cyan}Package Status:${colors2.reset}`);
+  console.log("─".repeat(40));
+  for (const pkg of packages) {
+    const status = pkg.isStowed ? `${colors2.green}✓ stowed${colors2.reset}` : `${colors2.yellow}○ not stowed${colors2.reset}`;
+    console.log(`  ${pkg.name}: ${status}`);
+  }
+  console.log();
+}
+async function stowAll() {
+  const packages = listPackages();
+  console.log(`
+${colors2.cyan}Stowing all packages...${colors2.reset}
+`);
+  for (const pkg of packages) {
+    const result = await stowPackage(pkg.name);
+    const icon = result.success ? colors2.green + "✓" : colors2.red + "✗";
+    console.log(`  ${icon} ${result.message}${colors2.reset}`);
+  }
+  console.log();
+}
+async function unstowAll() {
+  const packages = listPackages();
+  console.log(`
+${colors2.cyan}Unstowing all packages...${colors2.reset}
+`);
+  for (const pkg of packages) {
+    const result = await unstowPackage(pkg.name);
+    const icon = result.success ? colors2.green + "✓" : colors2.red + "✗";
+    console.log(`  ${icon} ${result.message}${colors2.reset}`);
+  }
+  console.log();
+}
+function printUsage() {
+  console.log(`
+${colors2.cyan}Usage: bun run config <command> [package]${colors2.reset}
+
+Commands:
+  ${colors2.blue}stow${colors2.reset} <package>     Stow a package
+  ${colors2.blue}unstow${colors2.reset} <package>   Unstow a package
+  ${colors2.blue}restow${colors2.reset} <package>   Restow a package
+  ${colors2.blue}adopt${colors2.reset} <package>    Adopt existing config into package
+  ${colors2.blue}list${colors2.reset}               List all packages
+  ${colors2.blue}status${colors2.reset}             Show status of all packages
+  ${colors2.blue}stow-all${colors2.reset}           Stow all packages
+  ${colors2.blue}unstow-all${colors2.reset}         Unstow all packages
+`);
+}
+async function runConfigManager(args) {
+  const { positionals } = parseArgs({
+    args,
+    allowPositionals: true
+  });
+  try {
+    await checkStow();
+  } catch {
+    return { output: "GNU Stow is not installed", success: false };
+  }
+  const [command, packageName] = positionals;
+  let output = "";
+  let success = true;
+  switch (command) {
+    case "stow": {
+      if (!packageName) {
+        return { output: "Package name required", success: false };
+      }
+      const result = await stowPackage(packageName);
+      output = result.message;
+      success = result.success;
+      break;
+    }
+    case "unstow": {
+      if (!packageName) {
+        return { output: "Package name required", success: false };
+      }
+      const result = await unstowPackage(packageName);
+      output = result.message;
+      success = result.success;
+      break;
+    }
+    case "restow": {
+      if (!packageName) {
+        return { output: "Package name required", success: false };
+      }
+      const result = await restowPackage(packageName);
+      output = result.message;
+      success = result.success;
+      break;
+    }
+    case "adopt": {
+      if (!packageName) {
+        return { output: "Package name required", success: false };
+      }
+      const result = await adoptPackage(packageName);
+      output = result.message;
+      success = result.success;
+      break;
+    }
+    case "list": {
+      const packages = listPackages();
+      output = packages.map((p) => p.name).join(`
+`);
+      break;
+    }
+    case "status": {
+      const packages = listPackages();
+      output = packages.map((p) => `${p.name}: ${p.isStowed ? "stowed" : "not stowed"}`).join(`
+`);
+      break;
+    }
+    case "stow-all": {
+      const packages = listPackages();
+      const results = [];
+      for (const pkg of packages) {
+        const result = await stowPackage(pkg.name);
+        results.push(`${result.success ? "✓" : "✗"} ${result.message}`);
+        if (!result.success)
+          success = false;
+      }
+      output = results.join(`
+`);
+      break;
+    }
+    case "unstow-all": {
+      const packages = listPackages();
+      const results = [];
+      for (const pkg of packages) {
+        const result = await unstowPackage(pkg.name);
+        results.push(`${result.success ? "✓" : "✗"} ${result.message}`);
+        if (!result.success)
+          success = false;
+      }
+      output = results.join(`
+`);
+      break;
+    }
+    default:
+      output = "Unknown command";
+      success = false;
+      break;
+  }
+  return { output, success };
+}
+async function main() {
+  const { positionals } = parseArgs({
+    args: process.argv.slice(2),
+    allowPositionals: true
+  });
+  await checkStow();
+  const [command, packageName] = positionals;
+  switch (command) {
+    case "stow": {
+      if (!packageName) {
+        console.error(`${colors2.red}Error: Package name required${colors2.reset}`);
+        process.exit(1);
+      }
+      const result = await stowPackage(packageName);
+      console.log(result.success ? `${colors2.green}${result.message}${colors2.reset}` : `${colors2.red}${result.message}${colors2.reset}`);
+      break;
+    }
+    case "unstow": {
+      if (!packageName) {
+        console.error(`${colors2.red}Error: Package name required${colors2.reset}`);
+        process.exit(1);
+      }
+      const result = await unstowPackage(packageName);
+      console.log(result.success ? `${colors2.green}${result.message}${colors2.reset}` : `${colors2.red}${result.message}${colors2.reset}`);
+      break;
+    }
+    case "restow": {
+      if (!packageName) {
+        console.error(`${colors2.red}Error: Package name required${colors2.reset}`);
+        process.exit(1);
+      }
+      const result = await restowPackage(packageName);
+      console.log(result.success ? `${colors2.green}${result.message}${colors2.reset}` : `${colors2.red}${result.message}${colors2.reset}`);
+      break;
+    }
+    case "adopt": {
+      if (!packageName) {
+        console.error(`${colors2.red}Error: Package name required${colors2.reset}`);
+        process.exit(1);
+      }
+      const result = await adoptPackage(packageName);
+      console.log(result.success ? `${colors2.green}${result.message}${colors2.reset}` : `${colors2.red}${result.message}${colors2.reset}`);
+      break;
+    }
+    case "list": {
+      const packages = listPackages();
+      console.log(`
+${colors2.cyan}Available packages:${colors2.reset}`);
+      for (const pkg of packages) {
+        console.log(`  ${colors2.blue}•${colors2.reset} ${pkg.name}`);
+      }
+      console.log();
+      break;
+    }
+    case "status":
+      await showStatus();
+      break;
+    case "stow-all":
+      await stowAll();
+      break;
+    case "unstow-all":
+      await unstowAll();
+      break;
+    default:
+      printUsage();
+      break;
+  }
+}
+var isMainModule = process.argv[1]?.includes("config-manager");
+if (isMainModule) {
+  main().catch(console.error);
+}
+
+// src/cli/pkg-sync.ts
+import { parseArgs as parseArgs2 } from "util";
+
+// src/lib/config.ts
+import { existsSync as existsSync4 } from "fs";
+var DEFAULT_CONFIG = {
+  config: {
+    purge: false,
+    purgeInteractive: true,
+    autoUpdate: true
+  },
+  taps: [],
+  packages: [],
+  casks: [],
+  mas: {}
+};
+async function loadPkgConfig(path) {
+  await ensureConfigDir();
+  const configPath = path || PKG_CONFIG_PATH;
+  if (!existsSync4(configPath)) {
+    await savePkgConfig(DEFAULT_CONFIG, configPath);
+    return DEFAULT_CONFIG;
+  }
+  return readJson(configPath);
+}
+async function savePkgConfig(config, path) {
+  await ensureConfigDir();
+  const configPath = path || PKG_CONFIG_PATH;
+  await writeFile(configPath, JSON.stringify(config, null, 2));
+}
+async function loadPkgLock() {
+  if (!existsSync4(PKG_LOCK_PATH)) {
+    return null;
+  }
+  return readJson(PKG_LOCK_PATH);
+}
+async function savePkgLock(lock) {
+  await ensureConfigDir();
+  await writeFile(PKG_LOCK_PATH, JSON.stringify(lock, null, 2));
+}
+
+// src/lib/lockfile.ts
+async function fetchInstalledVersions() {
+  const config = await loadPkgConfig();
+  const now = new Date().toISOString();
+  const formulas = {};
+  const casks = {};
+  if (config.packages.length > 0) {
+    const result = await exec([
+      "brew",
+      "info",
+      "--json=v2",
+      ...config.packages
+    ]);
+    if (result.success && result.stdout) {
+      const info = JSON.parse(result.stdout);
+      for (const formula of info.formulae) {
+        if (formula.installed.length > 0) {
+          formulas[formula.name] = {
+            version: formula.installed[0].version,
+            tap: formula.tap,
+            installedAt: now
+          };
+        }
+      }
+    }
+  }
+  if (config.casks.length > 0) {
+    const result = await exec([
+      "brew",
+      "info",
+      "--json=v2",
+      "--cask",
+      ...config.casks
+    ]);
+    if (result.success && result.stdout) {
+      const info = JSON.parse(result.stdout);
+      for (const cask of info.casks) {
+        if (cask.installed) {
+          casks[cask.token] = {
+            version: cask.installed,
+            installedAt: now
+          };
+        }
+      }
+    }
+  }
+  return { formulas, casks };
+}
+async function generateLockfile() {
+  const { formulas, casks } = await fetchInstalledVersions();
+  return {
+    version: 1,
+    lastUpdated: new Date().toISOString(),
+    formulas,
+    casks
+  };
+}
+async function updateLockfile() {
+  const existing = await loadPkgLock();
+  const { formulas, casks } = await fetchInstalledVersions();
+  const mergedFormulas = {};
+  for (const [name, info] of Object.entries(formulas)) {
+    const prev = existing?.formulas[name];
+    if (prev && prev.version === info.version) {
+      mergedFormulas[name] = prev;
+    } else {
+      mergedFormulas[name] = info;
+    }
+  }
+  const mergedCasks = {};
+  for (const [name, info] of Object.entries(casks)) {
+    const prev = existing?.casks[name];
+    if (prev && prev.version === info.version) {
+      mergedCasks[name] = prev;
+    } else {
+      mergedCasks[name] = info;
+    }
+  }
+  const lock = {
+    version: 1,
+    lastUpdated: new Date().toISOString(),
+    formulas: mergedFormulas,
+    casks: mergedCasks
+  };
+  await savePkgLock(lock);
+  return lock;
+}
+async function getChangedPackages() {
+  const existing = await loadPkgLock();
+  const { formulas, casks } = await fetchInstalledVersions();
+  const added = [];
+  const removed = [];
+  const upgraded = [];
+  if (!existing) {
+    added.push(...Object.keys(formulas), ...Object.keys(casks));
+    return { added, removed, upgraded };
+  }
+  for (const [name, info] of Object.entries(formulas)) {
+    if (!existing.formulas[name]) {
+      added.push(name);
+    } else if (existing.formulas[name].version !== info.version) {
+      upgraded.push({
+        name,
+        from: existing.formulas[name].version,
+        to: info.version
+      });
+    }
+  }
+  for (const name of Object.keys(existing.formulas)) {
+    if (!formulas[name]) {
+      removed.push(name);
+    }
+  }
+  for (const [name, info] of Object.entries(casks)) {
+    if (!existing.casks[name]) {
+      added.push(name);
+    } else if (existing.casks[name].version !== info.version) {
+      upgraded.push({
+        name,
+        from: existing.casks[name].version,
+        to: info.version
+      });
+    }
+  }
+  for (const name of Object.keys(existing.casks)) {
+    if (!casks[name]) {
+      removed.push(name);
+    }
+  }
+  return { added, removed, upgraded };
+}
+
+// src/types/pkg-config.ts
+var SYSTEM_APP_IDS = [
+  409183694,
+  409203825,
+  409201541,
+  408981434,
+  682658836,
+  424389933,
+  424390742,
+  413897608,
+  1274495053,
+  425424353,
+  497799835,
+  634148309,
+  1480068668,
+  803453959,
+  1295203466,
+  1444383602,
+  640199958,
+  899247664,
+  1176895641,
+  1451685025
+];
+
+// src/cli/pkg-sync.ts
+var colors3 = {
+  red: "\x1B[0;31m",
+  green: "\x1B[0;32m",
+  blue: "\x1B[0;34m",
+  yellow: "\x1B[1;33m",
+  cyan: "\x1B[0;36m",
+  bold: "\x1B[1m",
+  reset: "\x1B[0m"
+};
+async function checkDependencies() {
+  if (!await commandExists("brew")) {
+    console.error(`${colors3.red}Error: Homebrew not installed${colors3.reset}`);
+    process.exit(1);
+  }
+}
+async function getOutdatedPackages() {
+  const [formulas, casks] = await Promise.all([
+    exec(["brew", "outdated", "--formula", "--quiet"]),
+    exec(["brew", "outdated", "--cask", "--quiet"])
+  ]);
+  const packages = [];
+  if (formulas.stdout) {
+    packages.push(...formulas.stdout.split(`
+`).filter(Boolean).map((name) => ({ name, type: "formula" })));
+  }
+  if (casks.stdout) {
+    packages.push(...casks.stdout.split(`
+`).filter(Boolean).map((name) => ({ name, type: "cask" })));
+  }
+  return packages;
+}
+async function getOutdatedMas() {
+  const result = await exec(["mas", "outdated"]);
+  if (!result.success || !result.stdout)
+    return [];
+  return result.stdout.split(`
+`).filter(Boolean).map((line) => {
+    const match = line.match(/^(\d+)\s+(.+?)(?:\s+\(|$)/);
+    if (match) {
+      return { id: parseInt(match[1], 10), name: match[2].trim() };
+    }
+    return null;
+  }).filter((app) => app !== null);
+}
+async function upgradeWithVerification() {
+  const result = {
+    attempted: [],
+    succeeded: [],
+    failed: [],
+    stillOutdated: []
+  };
+  console.log(`
+${colors3.cyan}=== Checking for updates ===${colors3.reset}
+`);
+  await execLive(["brew", "update"]);
+  const beforeUpgrade = await getOutdatedPackages();
+  result.attempted = beforeUpgrade.map((p) => p.name);
+  if (beforeUpgrade.length === 0) {
+    console.log(`
+${colors3.green}All brew packages are up to date${colors3.reset}`);
+  } else {
+    console.log(`
+${colors3.yellow}Found ${beforeUpgrade.length} outdated packages${colors3.reset}
+`);
+    console.log(`${colors3.cyan}=== Upgrading formulas ===${colors3.reset}
+`);
+    await execLive(["brew", "upgrade", "--formula"]);
+    console.log(`
+${colors3.cyan}=== Upgrading casks ===${colors3.reset}
+`);
+    await execLive(["brew", "upgrade", "--cask", "--greedy"]);
+    console.log(`
+${colors3.cyan}=== Verifying upgrades ===${colors3.reset}
+`);
+    const afterUpgrade = await getOutdatedPackages();
+    const stillOutdatedSet = new Set(afterUpgrade.map((p) => p.name));
+    for (const pkg of beforeUpgrade) {
+      if (stillOutdatedSet.has(pkg.name)) {
+        result.stillOutdated.push(pkg.name);
+      } else {
+        result.succeeded.push(pkg.name);
+      }
+    }
+    if (result.stillOutdated.length > 0) {
+      console.log(`${colors3.yellow}${result.stillOutdated.length} packages still outdated, retrying individually...${colors3.reset}
+`);
+      for (const pkgName of [...result.stillOutdated]) {
+        const pkg = afterUpgrade.find((p) => p.name === pkgName);
+        if (!pkg)
+          continue;
+        console.log(`  Retrying ${colors3.blue}${pkgName}${colors3.reset}...`);
+        const upgradeCmd = pkg.type === "cask" ? ["brew", "upgrade", "--cask", pkgName] : ["brew", "upgrade", pkgName];
+        const retryResult = await exec(upgradeCmd);
+        const checkResult = await exec([
+          "brew",
+          "outdated",
+          pkg.type === "cask" ? "--cask" : "--formula",
+          "--quiet"
+        ]);
+        const stillOutdatedNow = checkResult.stdout.split(`
+`).filter(Boolean);
+        if (!stillOutdatedNow.includes(pkgName)) {
+          result.succeeded.push(pkgName);
+          result.stillOutdated = result.stillOutdated.filter((n) => n !== pkgName);
+          console.log(`    ${colors3.green}✓ Success${colors3.reset}`);
+        } else {
+          result.failed.push(pkgName);
+          result.stillOutdated = result.stillOutdated.filter((n) => n !== pkgName);
+          console.log(`    ${colors3.red}✗ Failed${colors3.reset} ${retryResult.stderr ? `(${retryResult.stderr.split(`
+`)[0]})` : ""}`);
+        }
+      }
+    }
+  }
+  if (await commandExists("mas")) {
+    const masOutdated = await getOutdatedMas();
+    if (masOutdated.length > 0) {
+      console.log(`
+${colors3.cyan}=== Upgrading Mac App Store apps ===${colors3.reset}
+`);
+      await execLive(["mas", "upgrade"]);
+    }
+  }
+  console.log(`
+${colors3.cyan}=== Cleanup ===${colors3.reset}
+`);
+  await execLive(["brew", "cleanup"]);
+  console.log(`
+${colors3.cyan}=== Updating lockfile ===${colors3.reset}
+`);
+  const lock = await updateLockfile();
+  const lockTotal = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+  console.log(`  Locked ${lockTotal} packages`);
+  return result;
+}
+async function upgradeInteractive() {
+  console.log(`
+${colors3.cyan}=== Checking for updates ===${colors3.reset}
+`);
+  await execLive(["brew", "update"]);
+  const outdated = await getOutdatedPackages();
+  if (outdated.length === 0) {
+    console.log(`
+${colors3.green}All packages are up to date${colors3.reset}
+`);
+    return;
+  }
+  console.log(`
+${colors3.yellow}Found ${outdated.length} outdated packages${colors3.reset}
+`);
+  for (const pkg of outdated) {
+    const question = `Upgrade ${colors3.blue}${pkg.name}${colors3.reset} (${pkg.type})? [y/n/q]: `;
+    const answer = (prompt(question) || "").trim().toLowerCase();
+    if (answer === "q") {
+      console.log(`
+${colors3.yellow}Upgrade cancelled${colors3.reset}`);
+      return;
+    }
+    if (answer === "y" || answer === "yes") {
+      const cmd = pkg.type === "cask" ? ["brew", "upgrade", "--cask", pkg.name] : ["brew", "upgrade", pkg.name];
+      await execLive(cmd);
+    }
+  }
+  const stillOutdated = await getOutdatedPackages();
+  if (stillOutdated.length > 0) {
+    console.log(`
+${colors3.yellow}Still outdated: ${stillOutdated.map((p) => p.name).join(", ")}${colors3.reset}`);
+  } else {
+    console.log(`
+${colors3.green}All selected packages upgraded successfully${colors3.reset}`);
+  }
+  await execLive(["brew", "cleanup"]);
+  console.log(`
+${colors3.cyan}=== Updating lockfile ===${colors3.reset}
+`);
+  await updateLockfile();
+}
+async function syncPackages(config) {
+  if (config.config.autoUpdate) {
+    console.log(`
+${colors3.cyan}=== Updating Homebrew ===${colors3.reset}
+`);
+    await execLive(["brew", "update"]);
+  }
+  console.log(`
+${colors3.cyan}=== Installing taps ===${colors3.reset}
+`);
+  const tappedResult = await exec(["brew", "tap"]);
+  const tapped = tappedResult.stdout.split(`
+`).filter(Boolean);
+  for (const tap of config.taps) {
+    if (!tapped.includes(tap)) {
+      console.log(`  Adding tap: ${colors3.blue}${tap}${colors3.reset}`);
+      await execLive(["brew", "tap", tap]);
+    }
+  }
+  console.log(`
+${colors3.cyan}=== Installing packages ===${colors3.reset}
+`);
+  const installedFormulas = (await exec(["brew", "list", "--formula"])).stdout.split(`
+`).filter(Boolean);
+  for (const pkg of config.packages) {
+    if (!installedFormulas.includes(pkg)) {
+      console.log(`  Installing: ${colors3.blue}${pkg}${colors3.reset}`);
+      await execLive(["brew", "install", pkg]);
+    }
+  }
+  console.log(`
+${colors3.cyan}=== Installing casks ===${colors3.reset}
+`);
+  const installedCasks = (await exec(["brew", "list", "--cask"])).stdout.split(`
+`).filter(Boolean);
+  for (const cask of config.casks) {
+    if (!installedCasks.includes(cask)) {
+      console.log(`  Installing: ${colors3.blue}${cask}${colors3.reset}`);
+      await execLive(["brew", "install", "--cask", cask]);
+    }
+  }
+  if (await commandExists("mas")) {
+    console.log(`
+${colors3.cyan}=== Installing Mac App Store apps ===${colors3.reset}
+`);
+    const masResult = await exec(["mas", "list"]);
+    const installedMas = masResult.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const match = line.match(/^(\d+)/);
+      return match ? parseInt(match[1], 10) : 0;
+    });
+    for (const [name, id] of Object.entries(config.mas)) {
+      if (!installedMas.includes(id)) {
+        console.log(`  Installing: ${colors3.blue}${name}${colors3.reset}`);
+        await execLive(["mas", "install", String(id)]);
+      }
+    }
+  }
+  if (config.config.purge) {
+    await purgeUnlisted(config, config.config.purgeInteractive);
+  }
+  console.log(`
+${colors3.cyan}=== Updating lockfile ===${colors3.reset}
+`);
+  const lock = await updateLockfile();
+  const lockTotal = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+  console.log(`  Locked ${lockTotal} packages`);
+  console.log(`
+${colors3.green}=== Sync complete ===${colors3.reset}
+`);
+}
+async function purgeUnlisted(config, interactive) {
+  console.log(`
+${colors3.cyan}=== Checking for unlisted packages ===${colors3.reset}
+`);
+  const installedFormulas = (await exec(["brew", "list", "--formula"])).stdout.split(`
+`).filter(Boolean);
+  for (const pkg of installedFormulas) {
+    if (!config.packages.includes(pkg)) {
+      const usesResult = await exec(["brew", "uses", "--installed", pkg]);
+      if (usesResult.stdout.trim()) {
+        console.log(`  ${colors3.yellow}Skipping ${pkg} (has dependents)${colors3.reset}`);
+        continue;
+      }
+      if (interactive) {
+        const answer = (prompt(`  Remove ${colors3.red}${pkg}${colors3.reset}? [y/n]: `) || "").trim().toLowerCase();
+        if (answer === "y") {
+          await execLive(["brew", "uninstall", pkg]);
+        }
+      } else {
+        console.log(`  Removing: ${colors3.red}${pkg}${colors3.reset}`);
+        await execLive(["brew", "uninstall", pkg]);
+      }
+    }
+  }
+  const installedCasks = (await exec(["brew", "list", "--cask"])).stdout.split(`
+`).filter(Boolean);
+  for (const cask of installedCasks) {
+    if (!config.casks.includes(cask)) {
+      if (interactive) {
+        const answer = (prompt(`  Remove cask ${colors3.red}${cask}${colors3.reset}? [y/n]: `) || "").trim().toLowerCase();
+        if (answer === "y") {
+          await execLive(["brew", "uninstall", "--cask", cask]);
+        }
+      } else {
+        console.log(`  Removing cask: ${colors3.red}${cask}${colors3.reset}`);
+        await execLive(["brew", "uninstall", "--cask", cask]);
+      }
+    }
+  }
+  if (await commandExists("mas")) {
+    const masResult = await exec(["mas", "list"]);
+    const installedMas = masResult.stdout.split(`
+`).filter(Boolean).map((line) => {
+      const match = line.match(/^(\d+)\s+(.+?)(?:\s+\(|$)/);
+      return match ? { id: parseInt(match[1], 10), name: match[2].trim() } : null;
+    }).filter((app) => app !== null);
+    const configMasIds = Object.values(config.mas);
+    for (const app of installedMas) {
+      if (SYSTEM_APP_IDS.includes(app.id)) {
+        continue;
+      }
+      if (!configMasIds.includes(app.id)) {
+        if (interactive) {
+          const answer = (prompt(`  Remove app ${colors3.red}${app.name}${colors3.reset}? [y/n]: `) || "").trim().toLowerCase();
+          if (answer === "y") {
+            await execLive(["mas", "uninstall", String(app.id)]);
+          }
+        } else {
+          console.log(`  Removing app: ${colors3.red}${app.name}${colors3.reset}`);
+          await execLive(["mas", "uninstall", String(app.id)]);
+        }
+      }
+    }
+  }
+  console.log(`
+${colors3.cyan}=== Cleaning up ===${colors3.reset}
+`);
+  await execLive(["brew", "autoremove"]);
+  await execLive(["brew", "cleanup"]);
+}
+function printUsage2() {
+  console.log(`
+${colors3.cyan}Usage: bun run pkg-sync [options] [config-file]${colors3.reset}
+
+Options:
+  ${colors3.blue}--upgrade-only${colors3.reset}         Only upgrade existing packages (with verification)
+  ${colors3.blue}--upgrade-interactive${colors3.reset}  Interactively select packages to upgrade
+  ${colors3.blue}--purge${colors3.reset}                Force purge mode for this run
+
+Examples:
+  bun run pkg-sync                    Sync packages from pkg-config.json
+  bun run pkg-sync --upgrade-only     Upgrade all packages with verification
+  bun run pkg-sync --purge            Sync and remove unlisted packages
+`);
+}
+async function runPkgSync(args) {
+  const { values, positionals } = parseArgs2({
+    args,
+    options: {
+      "upgrade-only": { type: "boolean", default: false },
+      "upgrade-interactive": { type: "boolean", default: false },
+      purge: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    allowPositionals: true
+  });
+  try {
+    await checkDependencies();
+  } catch {
+    return { output: "Homebrew not installed", success: false };
+  }
+  if (values["upgrade-only"]) {
+    const result = await upgradeWithVerification();
+    let output = `Upgrade complete
+`;
+    if (result.succeeded.length > 0) {
+      output += `Upgraded: ${result.succeeded.join(", ")}
+`;
+    }
+    if (result.failed.length > 0) {
+      output += `Failed: ${result.failed.join(", ")}`;
+    }
+    return { output, success: result.failed.length === 0 };
+  }
+  const configPath = positionals[0];
+  const config = await loadPkgConfig(configPath);
+  if (values.purge) {
+    config.config.purge = true;
+  }
+  await syncPackages(config);
+  return { output: "Sync complete", success: true };
+}
+async function main2() {
+  const { values, positionals } = parseArgs2({
+    args: process.argv.slice(2),
+    options: {
+      "upgrade-only": { type: "boolean", default: false },
+      "upgrade-interactive": { type: "boolean", default: false },
+      purge: { type: "boolean", default: false },
+      help: { type: "boolean", short: "h", default: false }
+    },
+    allowPositionals: true
+  });
+  if (values.help) {
+    printUsage2();
+    process.exit(0);
+  }
+  await checkDependencies();
+  if (values["upgrade-interactive"]) {
+    await upgradeInteractive();
+    return;
+  }
+  if (values["upgrade-only"]) {
+    const result = await upgradeWithVerification();
+    console.log(`
+${colors3.bold}=== Upgrade Summary ===${colors3.reset}
+`);
+    if (result.succeeded.length > 0) {
+      console.log(`${colors3.green}✓ Upgraded (${result.succeeded.length}):${colors3.reset} ${result.succeeded.join(", ")}`);
+    }
+    if (result.failed.length > 0) {
+      console.log(`${colors3.red}✗ Failed (${result.failed.length}):${colors3.reset} ${result.failed.join(", ")}`);
+    }
+    if (result.attempted.length === 0) {
+      console.log(`${colors3.green}Everything is up to date!${colors3.reset}`);
+    } else if (result.failed.length === 0 && result.stillOutdated.length === 0) {
+      console.log(`
+${colors3.green}All upgrades completed successfully!${colors3.reset}`);
+    } else {
+      console.log(`
+${colors3.yellow}Some packages could not be upgraded. Manual intervention may be required.${colors3.reset}`);
+    }
+    return;
+  }
+  const configPath = positionals[0];
+  const config = await loadPkgConfig(configPath);
+  if (values.purge) {
+    config.config.purge = true;
+  }
+  await syncPackages(config);
+}
+var isMainModule2 = process.argv[1]?.includes("pkg-sync");
+if (isMainModule2) {
+  main2().catch(console.error);
+}
+
+// src/cli/pkg-lock.ts
+import { parseArgs as parseArgs3 } from "util";
+var colors4 = {
+  red: "\x1B[0;31m",
+  green: "\x1B[0;32m",
+  blue: "\x1B[0;34m",
+  yellow: "\x1B[1;33m",
+  cyan: "\x1B[0;36m",
+  bold: "\x1B[1m",
+  reset: "\x1B[0m"
+};
+function printUsage3() {
+  console.log(`
+${colors4.cyan}Usage: bun run pkg-lock [command]${colors4.reset}
+
+Commands:
+  ${colors4.blue}update${colors4.reset}    Update lockfile with current installed versions (default)
+  ${colors4.blue}status${colors4.reset}    Show changes since last lock
+  ${colors4.blue}reset${colors4.reset}     Regenerate lockfile from scratch
+  ${colors4.blue}show${colors4.reset}      Display current lockfile contents
+`);
+}
+async function showStatus2() {
+  const lock = await loadPkgLock();
+  if (!lock) {
+    console.log(`${colors4.yellow}No lockfile found. Run 'bun run pkg-lock' to create one.${colors4.reset}`);
+    return;
+  }
+  const changes = await getChangedPackages();
+  if (changes.added.length === 0 && changes.removed.length === 0 && changes.upgraded.length === 0) {
+    console.log(`${colors4.green}Lockfile is up to date.${colors4.reset}`);
+    console.log(`  Last updated: ${lock.lastUpdated}`);
+    return;
+  }
+  console.log(`${colors4.bold}Changes since last lock:${colors4.reset}
+`);
+  if (changes.added.length > 0) {
+    console.log(`${colors4.green}Added:${colors4.reset}`);
+    for (const name of changes.added) {
+      console.log(`  + ${name}`);
+    }
+  }
+  if (changes.removed.length > 0) {
+    console.log(`${colors4.red}Removed:${colors4.reset}`);
+    for (const name of changes.removed) {
+      console.log(`  - ${name}`);
+    }
+  }
+  if (changes.upgraded.length > 0) {
+    console.log(`${colors4.blue}Upgraded:${colors4.reset}`);
+    for (const { name, from, to } of changes.upgraded) {
+      console.log(`  ~ ${name}: ${from} -> ${to}`);
+    }
+  }
+}
+async function showLockfile() {
+  const lock = await loadPkgLock();
+  if (!lock) {
+    console.log(`${colors4.yellow}No lockfile found.${colors4.reset}`);
+    return;
+  }
+  console.log(`${colors4.bold}Package Lockfile${colors4.reset}`);
+  console.log(`Last updated: ${lock.lastUpdated}
+`);
+  const formulaNames = Object.keys(lock.formulas).sort();
+  const caskNames = Object.keys(lock.casks).sort();
+  if (formulaNames.length > 0) {
+    console.log(`${colors4.cyan}Formulas (${formulaNames.length}):${colors4.reset}`);
+    for (const name of formulaNames) {
+      const { version, tap } = lock.formulas[name];
+      console.log(`  ${name} ${colors4.blue}${version}${colors4.reset} (${tap})`);
+    }
+  }
+  if (caskNames.length > 0) {
+    console.log(`
+${colors4.cyan}Casks (${caskNames.length}):${colors4.reset}`);
+    for (const name of caskNames) {
+      const { version } = lock.casks[name];
+      console.log(`  ${name} ${colors4.blue}${version}${colors4.reset}`);
+    }
+  }
+}
+async function runPkgLock(args) {
+  const { positionals } = parseArgs3({
+    args,
+    options: {
+      help: { type: "boolean", short: "h", default: false }
+    },
+    allowPositionals: true
+  });
+  const command = positionals[0] || "update";
+  switch (command) {
+    case "update": {
+      const lock = await updateLockfile();
+      const total = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+      return { output: `Lockfile updated with ${total} packages`, success: true };
+    }
+    case "status": {
+      const lock = await loadPkgLock();
+      if (!lock) {
+        return { output: "No lockfile found", success: false };
+      }
+      const changes = await getChangedPackages();
+      if (changes.added.length === 0 && changes.removed.length === 0 && changes.upgraded.length === 0) {
+        return { output: `Lockfile is up to date (last: ${lock.lastUpdated})`, success: true };
+      }
+      let output = `Changes:
+`;
+      if (changes.added.length > 0)
+        output += `Added: ${changes.added.join(", ")}
+`;
+      if (changes.removed.length > 0)
+        output += `Removed: ${changes.removed.join(", ")}
+`;
+      if (changes.upgraded.length > 0)
+        output += `Upgraded: ${changes.upgraded.map((u) => u.name).join(", ")}`;
+      return { output, success: true };
+    }
+    default:
+      return { output: `Unknown command: ${command}`, success: false };
+  }
+}
+async function main3() {
+  const { values, positionals } = parseArgs3({
+    args: process.argv.slice(2),
+    options: {
+      help: { type: "boolean", short: "h", default: false }
+    },
+    allowPositionals: true
+  });
+  if (values.help) {
+    printUsage3();
+    process.exit(0);
+  }
+  const command = positionals[0] || "update";
+  switch (command) {
+    case "update": {
+      console.log(`${colors4.cyan}Updating lockfile...${colors4.reset}`);
+      const lock = await updateLockfile();
+      const total = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+      console.log(`${colors4.green}Lockfile updated with ${total} packages.${colors4.reset}`);
+      break;
+    }
+    case "status":
+      await showStatus2();
+      break;
+    case "reset": {
+      console.log(`${colors4.cyan}Regenerating lockfile...${colors4.reset}`);
+      const lock = await generateLockfile();
+      await savePkgLock(lock);
+      const total = Object.keys(lock.formulas).length + Object.keys(lock.casks).length;
+      console.log(`${colors4.green}Lockfile regenerated with ${total} packages.${colors4.reset}`);
+      break;
+    }
+    case "show":
+      await showLockfile();
+      break;
+    default:
+      console.error(`${colors4.red}Unknown command: ${command}${colors4.reset}`);
+      printUsage3();
+      process.exit(1);
+  }
+}
+var isMainModule3 = process.argv[1]?.includes("pkg-lock");
+if (isMainModule3) {
+  main3().catch(console.error);
+}
+
+// src/cli/set-theme.ts
+import { parseArgs as parseArgs4 } from "util";
+import { readdirSync as readdirSync4, existsSync as existsSync5, rmSync, symlinkSync, unlinkSync } from "fs";
+import { join as join4 } from "path";
+var colors5 = {
+  red: "\x1B[0;31m",
+  green: "\x1B[0;32m",
+  blue: "\x1B[0;34m",
+  yellow: "\x1B[1;33m",
+  cyan: "\x1B[0;36m",
+  dim: "\x1B[2m",
+  reset: "\x1B[0m"
+};
+async function listThemes() {
+  await ensureConfigDir();
+  if (!existsSync5(THEMES_DIR)) {
+    return [];
+  }
+  const entries = readdirSync4(THEMES_DIR, { withFileTypes: true });
+  const themes = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      const themePath = join4(THEMES_DIR, entry.name);
+      const theme = await parseTheme(themePath, entry.name);
+      themes.push(theme);
+    }
+  }
+  return themes;
+}
+function clearDirectory(dir) {
+  if (existsSync5(dir)) {
+    const entries = readdirSync4(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = join4(dir, entry.name);
+      if (entry.isSymbolicLink() || entry.isFile()) {
+        unlinkSync(fullPath);
+      } else if (entry.isDirectory()) {
+        rmSync(fullPath, { recursive: true, force: true });
+      }
+    }
+  }
+}
+function createSymlink(source, target) {
+  if (existsSync5(target)) {
+    unlinkSync(target);
+  }
+  symlinkSync(source, target);
+}
+async function applyTheme(themeName) {
+  const themeDir = join4(THEMES_DIR, themeName);
+  if (!existsSync5(themeDir)) {
+    return { output: `Theme '${themeName}' not found`, success: false };
+  }
+  await ensureConfigDir();
+  await ensureDir2(THEME_TARGET_DIR);
+  const theme = await parseTheme(themeDir, themeName);
+  clearDirectory(THEME_TARGET_DIR);
+  if (existsSync5(BACKGROUNDS_TARGET_DIR)) {
+    rmSync(BACKGROUNDS_TARGET_DIR, { recursive: true, force: true });
+  }
+  const entries = readdirSync4(themeDir, { withFileTypes: true });
+  for (const entry of entries) {
+    const source = join4(themeDir, entry.name);
+    if (entry.isFile() && entry.name !== "theme.yaml" && entry.name !== "light.mode") {
+      const target = join4(THEME_TARGET_DIR, entry.name);
+      createSymlink(source, target);
+    }
+  }
+  if (theme.hasBackgrounds) {
+    const backgroundsSource = join4(themeDir, "backgrounds");
+    createSymlink(backgroundsSource, BACKGROUNDS_TARGET_DIR);
+  }
+  let output = `Theme '${theme.name}' applied successfully`;
+  if (theme.metadata?.author) {
+    output += `
+Author: ${theme.metadata.author}`;
+  }
+  if (theme.hasBackgrounds) {
+    output += `
+Wallpapers available at: ~/.config/formalconf/current/backgrounds/`;
+  }
+  if (theme.isLightMode) {
+    output += `
+Note: This is a light mode theme`;
+  }
+  return { output, success: true };
+}
+async function showThemeInfo(themeName) {
+  const themeDir = join4(THEMES_DIR, themeName);
+  if (!existsSync5(themeDir)) {
+    console.error(`${colors5.red}Error: Theme '${themeName}' not found${colors5.reset}`);
+    process.exit(1);
+  }
+  const theme = await parseTheme(themeDir, themeName);
+  console.log(`
+${colors5.cyan}Theme: ${theme.name}${colors5.reset}`);
+  if (theme.metadata) {
+    if (theme.metadata.author)
+      console.log(`Author: ${theme.metadata.author}`);
+    if (theme.metadata.description)
+      console.log(`Description: ${theme.metadata.description}`);
+    if (theme.metadata.version)
+      console.log(`Version: ${theme.metadata.version}`);
+    if (theme.metadata.source)
+      console.log(`Source: ${theme.metadata.source}`);
+  }
+  console.log(`
+Files (${theme.files.length}):`);
+  for (const file of theme.files) {
+    console.log(`  ${colors5.blue}•${colors5.reset} ${file.name}`);
+  }
+  if (theme.hasBackgrounds) {
+    console.log(`
+${colors5.green}Has wallpapers${colors5.reset}`);
+  }
+  if (theme.hasPreview) {
+    console.log(`${colors5.green}Has preview image${colors5.reset}`);
+  }
+  if (theme.isLightMode) {
+    console.log(`${colors5.yellow}Light mode theme${colors5.reset}`);
+  }
+}
+async function runSetTheme(themeName) {
+  return applyTheme(themeName);
+}
+async function main4() {
+  const { positionals, values } = parseArgs4({
+    args: process.argv.slice(2),
+    options: {
+      info: { type: "boolean", short: "i" }
+    },
+    allowPositionals: true
+  });
+  const [themeName] = positionals;
+  if (!themeName) {
+    const themes = await listThemes();
+    if (themes.length === 0) {
+      console.log(`${colors5.yellow}No themes available.${colors5.reset}`);
+      console.log(`This system is compatible with omarchy themes.`);
+      console.log(`
+Add themes to: ${colors5.cyan}~/.config/formalconf/themes/${colors5.reset}`);
+      process.exit(0);
+    }
+    console.log(`${colors5.cyan}Usage: formalconf theme <theme-name>${colors5.reset}`);
+    console.log(`       formalconf theme --info <theme-name>
+`);
+    console.log("Available themes:");
+    for (const theme of themes) {
+      const extras = [];
+      if (theme.hasBackgrounds)
+        extras.push("wallpapers");
+      if (theme.isLightMode)
+        extras.push("light");
+      const suffix = extras.length ? ` ${colors5.dim}(${extras.join(", ")})${colors5.reset}` : "";
+      console.log(`  ${colors5.blue}•${colors5.reset} ${theme.name}${suffix}`);
+    }
+    process.exit(0);
+  }
+  if (values.info) {
+    await showThemeInfo(themeName);
+  } else {
+    const result = await applyTheme(themeName);
+    console.log(result.success ? `${colors5.green}${result.output}${colors5.reset}` : `${colors5.red}${result.output}${colors5.reset}`);
+  }
+}
+var isMainModule4 = process.argv[1]?.includes("set-theme");
+if (isMainModule4) {
+  main4().catch(console.error);
+}
+
+// src/cli/formalconf.tsx
+import { jsxDEV as jsxDEV10 } from "react/jsx-dev-runtime";
+function MainMenu({ onSelect }) {
+  const { exit } = useApp();
+  return /* @__PURE__ */ jsxDEV10(Panel, {
+    title: "Main Menu",
+    children: /* @__PURE__ */ jsxDEV10(VimSelect, {
+      options: [
+        { label: "Config Manager", value: "config" },
+        { label: "Package Sync", value: "packages" },
+        { label: "Set Theme", value: "themes" },
+        { label: "Exit", value: "exit" }
+      ],
+      onChange: (value) => {
+        if (value === "exit") {
+          exit();
+          return;
+        }
+        onSelect(value);
+      }
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function ConfigMenu({ onBack }) {
+  const [state, setState] = useState4("menu");
+  const [output, setOutput] = useState4("");
+  const [success, setSuccess] = useState4(true);
+  useInput3((input, key) => {
+    if (state === "menu" && (key.escape || key.leftArrow || input === "h")) {
+      onBack();
+    }
+  });
+  const handleAction = async (action) => {
+    if (action === "back") {
+      onBack();
+      return;
+    }
+    setState("running");
+    const result = await runConfigManager([action]);
+    setOutput(result.output);
+    setSuccess(result.success);
+    setState("result");
+  };
+  if (state === "running") {
+    return /* @__PURE__ */ jsxDEV10(Panel, {
+      title: "Config Manager",
+      children: /* @__PURE__ */ jsxDEV10(Spinner, {
+        label: "Processing..."
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  if (state === "result") {
+    return /* @__PURE__ */ jsxDEV10(CommandOutput, {
+      title: "Config Manager",
+      output,
+      success,
+      onDismiss: () => setState("menu")
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV10(Panel, {
+    title: "Config Manager",
+    children: /* @__PURE__ */ jsxDEV10(VimSelect, {
+      options: [
+        { label: "Stow all packages", value: "stow-all" },
+        { label: "Unstow all packages", value: "unstow-all" },
+        { label: "Check status", value: "status" },
+        { label: "List packages", value: "list" },
+        { label: "Back", value: "back" }
+      ],
+      onChange: handleAction
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function PackageMenu({ onBack }) {
+  const [state, setState] = useState4("menu");
+  const [output, setOutput] = useState4("");
+  const [success, setSuccess] = useState4(true);
+  useInput3((input, key) => {
+    if (state === "menu" && (key.escape || key.leftArrow || input === "h")) {
+      onBack();
+    }
+  });
+  const handleAction = async (action) => {
+    if (action === "back") {
+      onBack();
+      return;
+    }
+    setState("running");
+    let result;
+    switch (action) {
+      case "sync":
+        result = await runPkgSync([]);
+        break;
+      case "sync-purge":
+        result = await runPkgSync(["--purge"]);
+        break;
+      case "upgrade":
+        result = await runPkgSync(["--upgrade-only"]);
+        break;
+      case "upgrade-interactive":
+        result = await runPkgSync(["--upgrade-interactive"]);
+        break;
+      case "lock-update":
+        result = await runPkgLock(["update"]);
+        break;
+      case "lock-status":
+        result = await runPkgLock(["status"]);
+        break;
+      default:
+        result = { output: "Unknown action", success: false };
+    }
+    setOutput(result.output);
+    setSuccess(result.success);
+    setState("result");
+  };
+  if (state === "running") {
+    return /* @__PURE__ */ jsxDEV10(Panel, {
+      title: "Package Sync",
+      children: /* @__PURE__ */ jsxDEV10(Spinner, {
+        label: "Syncing packages..."
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  if (state === "result") {
+    return /* @__PURE__ */ jsxDEV10(CommandOutput, {
+      title: "Package Sync",
+      output,
+      success,
+      onDismiss: () => setState("menu")
+    }, undefined, false, undefined, this);
+  }
+  return /* @__PURE__ */ jsxDEV10(Panel, {
+    title: "Package Sync",
+    children: /* @__PURE__ */ jsxDEV10(VimSelect, {
+      options: [
+        { label: "Sync packages", value: "sync" },
+        { label: "Sync with purge", value: "sync-purge" },
+        { label: "Upgrade all (with verification)", value: "upgrade" },
+        { label: "Upgrade interactive", value: "upgrade-interactive" },
+        { label: "Update lockfile", value: "lock-update" },
+        { label: "Lockfile status", value: "lock-status" },
+        { label: "Back", value: "back" }
+      ],
+      onChange: handleAction
+    }, undefined, false, undefined, this)
+  }, undefined, false, undefined, this);
+}
+function ThemeMenu({ onBack }) {
+  const [themes, setThemes] = useState4([]);
+  const [loading, setLoading] = useState4(true);
+  const [selectedIndex, setSelectedIndex] = useState4(0);
+  const [state, setState] = useState4("menu");
+  const [output, setOutput] = useState4("");
+  const [success, setSuccess] = useState4(true);
+  const { columns, rows } = useTerminalSize();
+  const CARD_HEIGHT = 3;
+  const LAYOUT_OVERHEAD = 20;
+  const cardWidth = useMemo(() => {
+    const availableWidth = columns - 6;
+    const cardsPerRow2 = Math.max(1, Math.floor(availableWidth / 28));
+    return Math.floor(availableWidth / cardsPerRow2);
+  }, [columns]);
+  const cardsPerRow = useMemo(() => {
+    const availableWidth = columns - 6;
+    return Math.max(1, Math.floor(availableWidth / 28));
+  }, [columns]);
+  const visibleRows = useMemo(() => {
+    const availableHeight = rows - LAYOUT_OVERHEAD;
+    return Math.max(1, Math.floor(availableHeight / CARD_HEIGHT));
+  }, [rows]);
+  const selectedRow = Math.floor(selectedIndex / cardsPerRow);
+  const totalRows = Math.ceil(themes.length / cardsPerRow);
+  const [scrollOffset, setScrollOffset] = useState4(0);
+  useEffect3(() => {
+    if (selectedRow < scrollOffset) {
+      setScrollOffset(selectedRow);
+    } else if (selectedRow >= scrollOffset + visibleRows) {
+      setScrollOffset(selectedRow - visibleRows + 1);
+    }
+  }, [selectedRow, scrollOffset, visibleRows]);
+  const visibleThemes = useMemo(() => {
+    const startIdx = scrollOffset * cardsPerRow;
+    const endIdx = (scrollOffset + visibleRows) * cardsPerRow;
+    return themes.slice(startIdx, endIdx);
+  }, [themes, scrollOffset, visibleRows, cardsPerRow]);
+  const visibleStartIndex = scrollOffset * cardsPerRow;
+  useInput3((input, key) => {
+    if (state !== "menu" || loading)
+      return;
+    if (key.escape) {
+      onBack();
+      return;
+    }
+    if (key.rightArrow || input === "l") {
+      if (selectedIndex < themes.length - 1) {
+        setSelectedIndex((i) => i + 1);
+      }
+    }
+    if (key.leftArrow || input === "h") {
+      if (selectedIndex > 0) {
+        setSelectedIndex((i) => i - 1);
+      }
+    }
+    if (key.downArrow || input === "j") {
+      const nextIndex = selectedIndex + cardsPerRow;
+      if (nextIndex < themes.length) {
+        setSelectedIndex(nextIndex);
+      }
+    }
+    if (key.upArrow || input === "k") {
+      const prevIndex = selectedIndex - cardsPerRow;
+      if (prevIndex >= 0) {
+        setSelectedIndex(prevIndex);
+      }
+    }
+    if (key.return) {
+      applyTheme2(themes[selectedIndex]);
+    }
+  });
+  useEffect3(() => {
+    async function loadThemes() {
+      if (!existsSync6(THEMES_DIR)) {
+        setThemes([]);
+        setLoading(false);
+        return;
+      }
+      const entries = readdirSync5(THEMES_DIR, { withFileTypes: true });
+      const loadedThemes = [];
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          const themePath = join5(THEMES_DIR, entry.name);
+          const theme = await parseTheme(themePath, entry.name);
+          loadedThemes.push(theme);
+        }
+      }
+      setThemes(loadedThemes);
+      setLoading(false);
+    }
+    loadThemes();
+  }, []);
+  const applyTheme2 = async (theme) => {
+    setState("running");
+    const themeName = theme.path.split("/").pop();
+    const result = await runSetTheme(themeName);
+    setOutput(result.output);
+    setSuccess(result.success);
+    setState("result");
+  };
+  if (loading || state === "running") {
+    return /* @__PURE__ */ jsxDEV10(Panel, {
+      title: "Select Theme",
+      children: /* @__PURE__ */ jsxDEV10(Spinner, {
+        label: loading ? "Loading themes..." : "Applying theme..."
+      }, undefined, false, undefined, this)
+    }, undefined, false, undefined, this);
+  }
+  if (state === "result") {
+    return /* @__PURE__ */ jsxDEV10(CommandOutput, {
+      title: "Select Theme",
+      output,
+      success,
+      onDismiss: () => setState("menu")
+    }, undefined, false, undefined, this);
+  }
+  if (themes.length === 0) {
+    return /* @__PURE__ */ jsxDEV10(Panel, {
+      title: "Select Theme",
+      children: [
+        /* @__PURE__ */ jsxDEV10(Box10, {
+          flexDirection: "column",
+          children: [
+            /* @__PURE__ */ jsxDEV10(Text9, {
+              color: colors.warning,
+              children: "No themes available."
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV10(Text9, {
+              children: "This system is compatible with omarchy themes."
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV10(Text9, {
+              dimColor: true,
+              children: "Add themes to ~/.config/formalconf/themes/"
+            }, undefined, false, undefined, this)
+          ]
+        }, undefined, true, undefined, this),
+        /* @__PURE__ */ jsxDEV10(Box10, {
+          marginTop: 1,
+          children: /* @__PURE__ */ jsxDEV10(VimSelect, {
+            options: [{ label: "Back", value: "back" }],
+            onChange: () => onBack()
+          }, undefined, false, undefined, this)
+        }, undefined, false, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+  }
+  const showScrollUp = scrollOffset > 0;
+  const showScrollDown = scrollOffset + visibleRows < totalRows;
+  const gridHeight = visibleRows * CARD_HEIGHT;
+  return /* @__PURE__ */ jsxDEV10(Panel, {
+    title: "Select Theme",
+    children: [
+      showScrollUp && /* @__PURE__ */ jsxDEV10(Text9, {
+        dimColor: true,
+        children: [
+          "  ↑ ",
+          scrollOffset,
+          " more row",
+          scrollOffset > 1 ? "s" : ""
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV10(Box10, {
+        flexDirection: "row",
+        flexWrap: "wrap",
+        height: gridHeight,
+        overflow: "hidden",
+        children: visibleThemes.map((theme, index) => /* @__PURE__ */ jsxDEV10(ThemeCard, {
+          theme,
+          isSelected: visibleStartIndex + index === selectedIndex,
+          width: cardWidth
+        }, theme.path, false, undefined, this))
+      }, undefined, false, undefined, this),
+      showScrollDown && /* @__PURE__ */ jsxDEV10(Text9, {
+        dimColor: true,
+        children: [
+          "  ↓ ",
+          totalRows - scrollOffset - visibleRows,
+          " more row",
+          totalRows - scrollOffset - visibleRows > 1 ? "s" : ""
+        ]
+      }, undefined, true, undefined, this),
+      /* @__PURE__ */ jsxDEV10(Box10, {
+        marginTop: 1,
+        children: /* @__PURE__ */ jsxDEV10(Text9, {
+          dimColor: true,
+          children: "←→↑↓/hjkl navigate • Enter select • Esc back"
+        }, undefined, false, undefined, this)
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+function App() {
+  const [screen, setScreen] = useState4("main");
+  const { exit } = useApp();
+  useInput3((input) => {
+    if (input === "q") {
+      exit();
+    }
+  });
+  useEffect3(() => {
+    ensureConfigDir();
+  }, []);
+  const getBreadcrumb = () => {
+    switch (screen) {
+      case "config":
+        return ["Main", "Config Manager"];
+      case "packages":
+        return ["Main", "Package Sync"];
+      case "themes":
+        return ["Main", "Themes"];
+      default:
+        return ["Main"];
+    }
+  };
+  return /* @__PURE__ */ jsxDEV10(Layout, {
+    breadcrumb: getBreadcrumb(),
+    children: [
+      screen === "main" && /* @__PURE__ */ jsxDEV10(MainMenu, {
+        onSelect: setScreen
+      }, undefined, false, undefined, this),
+      screen === "config" && /* @__PURE__ */ jsxDEV10(ConfigMenu, {
+        onBack: () => setScreen("main")
+      }, undefined, false, undefined, this),
+      screen === "packages" && /* @__PURE__ */ jsxDEV10(PackageMenu, {
+        onBack: () => setScreen("main")
+      }, undefined, false, undefined, this),
+      screen === "themes" && /* @__PURE__ */ jsxDEV10(ThemeMenu, {
+        onBack: () => setScreen("main")
+      }, undefined, false, undefined, this)
+    ]
+  }, undefined, true, undefined, this);
+}
+render(/* @__PURE__ */ jsxDEV10(App, {}, undefined, false, undefined, this));