formalconf 2.0.8 → 2.0.9

package/dist/formalconf.js

@@ -6,12 +6,14 @@ 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";
-async function exec(command, cwd) {
+async function exec(command, cwd, env) {
+  const mergedEnv = env ? { ...process.env, ...env } : undefined;
   if (isBun) {
     const proc = Bun.spawn(command, {
       stdout: "pipe",
       stderr: "pipe",
-      cwd
+      cwd,
+      env: mergedEnv
     });
     const [stdout, stderr] = await Promise.all([
       new Response(proc.stdout).text(),
@@ -27,7 +29,7 @@ async function exec(command, cwd) {
   }
   return new Promise((resolve) => {
     const [cmd, ...args] = command;
-    const proc = nodeSpawn(cmd, args, { cwd, shell: false });
+    const proc = nodeSpawn(cmd, args, { cwd, shell: false, env: mergedEnv });
     let stdout = "";
     let stderr = "";
     proc.stdout?.on("data", (data) => {
@@ -315,9 +317,17 @@ 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 HOOKS_DIR = join(CONFIG_DIR, "hooks");
 var PKG_CONFIG_PATH = join(CONFIG_DIR, "pkg-config.json");
 var PKG_LOCK_PATH = join(CONFIG_DIR, "pkg-lock.json");
 var THEME_CONFIG_PATH = join(CONFIG_DIR, "theme-config.json");
+var TEMPLATES_DIR = join(CONFIG_DIR, "templates");
+var TEMPLATES_MANIFEST_PATH = join(TEMPLATES_DIR, "templates.json");
+var GENERATED_DIR = join(CONFIG_DIR, "generated");
+var BUNDLED_TEMPLATES_DIR = join(ROOT_DIR, "templates");
+var BUNDLED_MANIFEST_PATH = join(BUNDLED_TEMPLATES_DIR, "templates.json");
+var GTK_DIR = join(CONFIG_DIR, "gtk");
+var COLLOID_DIR = join(GTK_DIR, "colloid-gtk-theme");
 async function ensureDir2(path) {
   await ensureDir(path);
 }
@@ -327,6 +337,8 @@ async function ensureConfigDir() {
   await ensureDir2(THEMES_DIR);
   await ensureDir2(THEME_TARGET_DIR);
   await ensureDir2(BACKGROUNDS_TARGET_DIR);
+  await ensureDir2(TEMPLATES_DIR);
+  await ensureDir2(GENERATED_DIR);
 }
 async function dirHasContents(path) {
   try {
@@ -447,7 +459,7 @@ function StatusIndicator({
 // package.json
 var package_default = {
   name: "formalconf",
-  version: "2.0.8",
+  version: "2.0.9",
   description: "Dotfiles management TUI for macOS - config management, package sync, and theme switching",
   type: "module",
   main: "./dist/formalconf.js",
@@ -4503,23 +4515,34 @@ function PackageMenu({ onBack }) {
 // src/components/menus/ThemeMenu.tsx
 import { useState as useState10, useEffect as useEffect6, useMemo as useMemo4 } from "react";
 import { Box as Box16, Text as Text15 } from "ink";
-import { existsSync as existsSync8, readdirSync as readdirSync5 } from "fs";
-import { join as join6 } from "path";
 
 // src/components/ThemeCard.tsx
 import { Box as Box15, Text as Text14 } from "ink";
 import { jsxDEV as jsxDEV18 } from "react/jsx-dev-runtime";
+function isLegacyTheme(theme) {
+  return "files" in theme;
+}
 function ThemeCard({ theme, isSelected, width, isDeviceTheme }) {
   const borderColor = isSelected ? colors.accent : colors.border;
   const nameColor = isSelected ? colors.primary : colors.text;
   const indicators = [];
   if (isDeviceTheme)
     indicators.push("device");
-  if (theme.hasBackgrounds)
-    indicators.push("bg");
-  if (theme.isLightMode)
-    indicators.push("light");
+  if (isLegacyTheme(theme)) {
+    if (theme.hasBackgrounds)
+      indicators.push("bg");
+    if (theme.isLightMode)
+      indicators.push("light");
+  } else {
+    if (theme.type === "json")
+      indicators.push("json");
+    if (theme.hasBackgrounds)
+      indicators.push("bg");
+    if (theme.isLightMode)
+      indicators.push("light");
+  }
   const indicatorText = indicators.length > 0 ? ` [${indicators.join(" ")}]` : "";
+  const displayName = isLegacyTheme(theme) ? theme.name : theme.displayName;
   return /* @__PURE__ */ jsxDEV18(Box15, {
     flexDirection: "column",
     width,
@@ -4536,7 +4559,7 @@ function ThemeCard({ theme, isSelected, width, isDeviceTheme }) {
           color: nameColor,
           bold: true,
           wrap: "truncate",
-          children: theme.name
+          children: displayName
         }, undefined, false, undefined, this),
         /* @__PURE__ */ jsxDEV18(Text14, {
           color: colors.primaryDim,
@@ -4631,6 +4654,18 @@ function useThemeGrid({
   };
 }
 
+// src/cli/set-theme.ts
+import { parseArgs as parseArgs4 } from "util";
+import {
+  readdirSync as readdirSync9,
+  existsSync as existsSync12,
+  rmSync,
+  symlinkSync,
+  unlinkSync as unlinkSync2,
+  copyFileSync
+} from "fs";
+import { join as join11, basename as basename4 } from "path";
+
 // src/lib/theme-parser.ts
 init_runtime();
 import { existsSync as existsSync5, readdirSync as readdirSync3 } from "fs";
@@ -4706,14 +4741,44 @@ async function parseTheme(themePath, themeName) {
   };
 }
 
-// src/cli/set-theme.ts
-import { parseArgs as parseArgs4 } from "util";
-import { readdirSync as readdirSync4, existsSync as existsSync7, rmSync, symlinkSync, unlinkSync } from "fs";
+// src/lib/hooks.ts
+init_runtime();
 import { join as join5 } from "path";
+import { existsSync as existsSync6, readdirSync as readdirSync4, statSync } from "fs";
+async function runHooks(hookType, env = {}) {
+  const hookDir = join5(HOOKS_DIR, hookType);
+  if (!existsSync6(hookDir)) {
+    return { executed: 0, succeeded: 0, failed: 0, results: [] };
+  }
+  const entries = readdirSync4(hookDir).filter((name) => !name.startsWith(".")).sort();
+  const results = [];
+  for (const entry of entries) {
+    const scriptPath2 = join5(hookDir, entry);
+    const stat = statSync(scriptPath2);
+    if (stat.isDirectory()) {
+      continue;
+    }
+    const result = await exec([scriptPath2], undefined, env);
+    results.push({
+      script: entry,
+      success: result.success,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode: result.exitCode
+    });
+  }
+  const succeeded = results.filter((r) => r.success).length;
+  return {
+    executed: results.length,
+    succeeded,
+    failed: results.length - succeeded,
+    results
+  };
+}
 
 // src/lib/theme-config.ts
 import { hostname } from "os";
-import { existsSync as existsSync6, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync7, readFileSync, writeFileSync } from "fs";
 var DEFAULT_CONFIG = {
   version: 1,
   defaultTheme: null,
@@ -4723,7 +4788,7 @@ function getDeviceHostname() {
   return hostname();
 }
 function loadThemeConfig() {
-  if (!existsSync6(THEME_CONFIG_PATH)) {
+  if (!existsSync7(THEME_CONFIG_PATH)) {
     return { ...DEFAULT_CONFIG, devices: {} };
   }
   try {
@@ -4787,6 +4852,1236 @@ function getDefaultTheme() {
   return config.defaultTheme;
 }
 
+// src/lib/theme-v2/loader.ts
+init_runtime();
+import { existsSync as existsSync8, readdirSync as readdirSync5 } from "fs";
+import { join as join6, basename as basename2 } from "path";
+
+// src/lib/theme-v2/color.ts
+function isValidHex(hex) {
+  return /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(hex);
+}
+function normalizeHex(hex) {
+  if (!hex.startsWith("#")) {
+    hex = `#${hex}`;
+  }
+  if (hex.length === 4) {
+    const r = hex[1];
+    const g = hex[2];
+    const b = hex[3];
+    hex = `#${r}${r}${g}${g}${b}${b}`;
+  }
+  return hex.toUpperCase();
+}
+function hexToRgb(hex) {
+  const normalized = normalizeHex(hex);
+  if (!isValidHex(normalized)) {
+    throw new Error(`Invalid hex color: ${hex}`);
+  }
+  const r = parseInt(normalized.slice(1, 3), 16);
+  const g = parseInt(normalized.slice(3, 5), 16);
+  const b = parseInt(normalized.slice(5, 7), 16);
+  return { r, g, b };
+}
+function hexToColorVariable(hex) {
+  const normalized = normalizeHex(hex);
+  const { r, g, b } = hexToRgb(normalized);
+  return {
+    hex: normalized,
+    strip: normalized.slice(1),
+    rgb: `rgb(${r},${g},${b})`,
+    rgba: `rgba(${r},${g},${b},1)`,
+    r,
+    g,
+    b,
+    red: r / 255,
+    green: g / 255,
+    blue: b / 255
+  };
+}
+function hexToColorVariableOrDefault(hex, fallback) {
+  return hexToColorVariable(hex ?? fallback);
+}
+
+// src/lib/theme-v2/validator.ts
+var REQUIRED_PALETTE_COLORS = [
+  "color0",
+  "color1",
+  "color2",
+  "color3",
+  "color4",
+  "color5",
+  "color6",
+  "color7",
+  "color8",
+  "color9",
+  "color10",
+  "color11",
+  "color12",
+  "color13",
+  "color14",
+  "color15",
+  "background",
+  "foreground",
+  "cursor"
+];
+var OPTIONAL_PALETTE_COLORS = [
+  "selection_background",
+  "selection_foreground",
+  "accent",
+  "border"
+];
+function validateColor(value, path) {
+  if (typeof value !== "string") {
+    return { path, message: "must be a string" };
+  }
+  if (!isValidHex(value)) {
+    return { path, message: `invalid hex color: ${value}` };
+  }
+  return null;
+}
+function isValidUrl(value) {
+  try {
+    const url = new URL(value);
+    return ["http:", "https:"].includes(url.protocol);
+  } catch {
+    return false;
+  }
+}
+function validateUrlArray(arr, path) {
+  const errors = [];
+  if (!Array.isArray(arr)) {
+    errors.push({ path, message: "must be an array" });
+    return errors;
+  }
+  if (arr.length === 0) {
+    errors.push({ path, message: "must have at least one URL" });
+    return errors;
+  }
+  for (let i = 0;i < arr.length; i++) {
+    const item = arr[i];
+    if (typeof item !== "string") {
+      errors.push({ path: `${path}[${i}]`, message: "must be a string" });
+    } else if (!isValidUrl(item)) {
+      errors.push({ path: `${path}[${i}]`, message: "must be a valid http/https URL" });
+    }
+  }
+  return errors;
+}
+function validateWallpapers(config, path) {
+  const errors = [];
+  if (typeof config !== "object" || config === null) {
+    errors.push({ path, message: "must be an object" });
+    return errors;
+  }
+  const obj = config;
+  if (!("dark" in obj)) {
+    errors.push({ path: `${path}.dark`, message: "is required" });
+  } else {
+    errors.push(...validateUrlArray(obj.dark, `${path}.dark`));
+  }
+  if ("light" in obj) {
+    errors.push(...validateUrlArray(obj.light, `${path}.light`));
+  }
+  return errors;
+}
+function validatePalette(palette, path) {
+  const errors = [];
+  if (typeof palette !== "object" || palette === null) {
+    errors.push({ path, message: "must be an object" });
+    return errors;
+  }
+  const obj = palette;
+  for (const color of REQUIRED_PALETTE_COLORS) {
+    if (!(color in obj)) {
+      errors.push({ path: `${path}.${color}`, message: "is required" });
+    } else {
+      const error = validateColor(obj[color], `${path}.${color}`);
+      if (error)
+        errors.push(error);
+    }
+  }
+  for (const color of OPTIONAL_PALETTE_COLORS) {
+    if (color in obj) {
+      const error = validateColor(obj[color], `${path}.${color}`);
+      if (error)
+        errors.push(error);
+    }
+  }
+  return errors;
+}
+function validateNeovimConfig(config, path) {
+  const errors = [];
+  if (typeof config !== "object" || config === null) {
+    errors.push({ path, message: "must be an object" });
+    return errors;
+  }
+  const obj = config;
+  if (!("repo" in obj) || typeof obj.repo !== "string") {
+    errors.push({ path: `${path}.repo`, message: "is required and must be a string" });
+  }
+  if (!("colorscheme" in obj) || typeof obj.colorscheme !== "string") {
+    errors.push({
+      path: `${path}.colorscheme`,
+      message: "is required and must be a string"
+    });
+  }
+  if ("light_colorscheme" in obj && typeof obj.light_colorscheme !== "string") {
+    errors.push({
+      path: `${path}.light_colorscheme`,
+      message: "must be a string"
+    });
+  }
+  if ("opts" in obj && (typeof obj.opts !== "object" || obj.opts === null)) {
+    errors.push({ path: `${path}.opts`, message: "must be an object" });
+  }
+  return errors;
+}
+function validateGtkConfig(config, path) {
+  const errors = [];
+  if (typeof config !== "object" || config === null) {
+    errors.push({ path, message: "must be an object" });
+    return errors;
+  }
+  const obj = config;
+  if ("variant" in obj && typeof obj.variant !== "string") {
+    errors.push({ path: `${path}.variant`, message: "must be a string" });
+  }
+  if ("tweaks" in obj) {
+    if (!Array.isArray(obj.tweaks)) {
+      errors.push({ path: `${path}.tweaks`, message: "must be an array" });
+    } else {
+      for (let i = 0;i < obj.tweaks.length; i++) {
+        if (typeof obj.tweaks[i] !== "string") {
+          errors.push({
+            path: `${path}.tweaks[${i}]`,
+            message: "must be a string"
+          });
+        }
+      }
+    }
+  }
+  return errors;
+}
+function validateThemeJson(data) {
+  const errors = [];
+  if (typeof data !== "object" || data === null) {
+    return {
+      valid: false,
+      errors: [{ path: "", message: "theme must be an object" }]
+    };
+  }
+  const obj = data;
+  if (!("title" in obj) || typeof obj.title !== "string") {
+    errors.push({ path: "title", message: "is required and must be a string" });
+  }
+  const optionalStrings = ["description", "author", "version", "source"];
+  for (const field of optionalStrings) {
+    if (field in obj && typeof obj[field] !== "string") {
+      errors.push({ path: field, message: "must be a string" });
+    }
+  }
+  if (!("dark" in obj) && !("light" in obj)) {
+    errors.push({
+      path: "",
+      message: "at least one of 'dark' or 'light' palette is required"
+    });
+  }
+  if ("dark" in obj) {
+    errors.push(...validatePalette(obj.dark, "dark"));
+  }
+  if ("light" in obj) {
+    errors.push(...validatePalette(obj.light, "light"));
+  }
+  if ("neovim" in obj) {
+    errors.push(...validateNeovimConfig(obj.neovim, "neovim"));
+  }
+  if ("gtk" in obj) {
+    errors.push(...validateGtkConfig(obj.gtk, "gtk"));
+  }
+  if ("wallpapers" in obj) {
+    errors.push(...validateWallpapers(obj.wallpapers, "wallpapers"));
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function formatValidationErrors(errors) {
+  return errors.map((e) => e.path ? `${e.path}: ${e.message}` : e.message).join(`
+`);
+}
+
+// src/lib/theme-v2/loader.ts
+class ThemeLoadError extends Error {
+  path;
+  constructor(path, message) {
+    super(`Failed to load theme at ${path}: ${message}`);
+    this.path = path;
+    this.name = "ThemeLoadError";
+  }
+}
+
+class ThemeValidationError extends Error {
+  path;
+  validationErrors;
+  constructor(path, validationErrors) {
+    super(`Invalid theme at ${path}:
+${validationErrors}`);
+    this.path = path;
+    this.validationErrors = validationErrors;
+    this.name = "ThemeValidationError";
+  }
+}
+async function loadThemeJson(themePath) {
+  if (!existsSync8(themePath)) {
+    throw new ThemeLoadError(themePath, "file not found");
+  }
+  let content;
+  try {
+    content = await readText(themePath);
+  } catch (err) {
+    throw new ThemeLoadError(themePath, `could not read file: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch (err) {
+    throw new ThemeLoadError(themePath, `invalid JSON: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  const validation = validateThemeJson(parsed);
+  if (!validation.valid) {
+    throw new ThemeValidationError(themePath, formatValidationErrors(validation.errors));
+  }
+  return parsed;
+}
+function getAvailableModes(theme) {
+  const modes = [];
+  if (theme.dark)
+    modes.push("dark");
+  if (theme.light)
+    modes.push("light");
+  return modes;
+}
+async function listJsonThemes() {
+  if (!existsSync8(THEMES_DIR)) {
+    return [];
+  }
+  const entries = readdirSync5(THEMES_DIR, { withFileTypes: true });
+  const themes = [];
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".json")) {
+      const path = join6(THEMES_DIR, entry.name);
+      try {
+        const theme = await loadThemeJson(path);
+        themes.push({
+          name: basename2(entry.name, ".json"),
+          path,
+          theme,
+          availableModes: getAvailableModes(theme)
+        });
+      } catch {
+        continue;
+      }
+    }
+  }
+  return themes;
+}
+
+// src/lib/template-engine/engine.ts
+init_runtime();
+import { join as join8 } from "path";
+
+// src/lib/template-engine/modifiers.ts
+var VALID_MODIFIERS = [
+  "hex",
+  "strip",
+  "rgb",
+  "rgba",
+  "r",
+  "g",
+  "b",
+  "red",
+  "green",
+  "blue"
+];
+function isValidModifier(modifier) {
+  return VALID_MODIFIERS.includes(modifier);
+}
+function applyModifier(color, modifier) {
+  if (!modifier) {
+    return color.hex;
+  }
+  switch (modifier) {
+    case "hex":
+      return color.hex;
+    case "strip":
+      return color.strip;
+    case "rgb":
+      return color.rgb;
+    case "rgba":
+      return color.rgba;
+    case "r":
+      return String(color.r);
+    case "g":
+      return String(color.g);
+    case "b":
+      return String(color.b);
+    case "red":
+      return color.red.toFixed(6);
+    case "green":
+      return color.green.toFixed(6);
+    case "blue":
+      return color.blue.toFixed(6);
+    default:
+      return color.hex;
+  }
+}
+function parseVariableReference(variable) {
+  const parts = variable.split(".");
+  if (parts[0] === "theme" && parts.length === 2) {
+    return { name: variable };
+  }
+  if (parts.length === 2 && isValidModifier(parts[1])) {
+    return { name: parts[0], modifier: parts[1] };
+  }
+  return { name: variable };
+}
+
+// src/lib/template-engine/parser.ts
+var VARIABLE_REGEX = /\{\{([a-zA-Z0-9_.]+)\}\}/g;
+var COLOR_VARIABLES = [
+  "color0",
+  "color1",
+  "color2",
+  "color3",
+  "color4",
+  "color5",
+  "color6",
+  "color7",
+  "color8",
+  "color9",
+  "color10",
+  "color11",
+  "color12",
+  "color13",
+  "color14",
+  "color15",
+  "background",
+  "foreground",
+  "cursor",
+  "selection_background",
+  "selection_foreground",
+  "accent",
+  "border"
+];
+function isColorVariable(name) {
+  return COLOR_VARIABLES.includes(name);
+}
+function getContextValue(context, variableName, modifier) {
+  if (variableName.startsWith("theme.")) {
+    const key = variableName.slice(6);
+    const value = context.theme[key];
+    return value !== undefined ? String(value) : undefined;
+  }
+  if (variableName === "mode") {
+    return context.mode;
+  }
+  if (isColorVariable(variableName)) {
+    const color = context[variableName];
+    return applyModifier(color, modifier);
+  }
+  return;
+}
+function renderTemplate(template, context) {
+  return template.replace(VARIABLE_REGEX, (match, variable) => {
+    const { name, modifier } = parseVariableReference(variable);
+    const value = getContextValue(context, name, modifier);
+    if (value === undefined) {
+      return match;
+    }
+    return value;
+  });
+}
+function renderDualModeTemplate(template, contexts) {
+  let result = template.replace(/\{\{dark\.([a-zA-Z0-9_.]+)\}\}/g, (match, variable) => {
+    const { name, modifier } = parseVariableReference(variable);
+    const value = getContextValue(contexts.dark, name, modifier);
+    return value ?? match;
+  });
+  result = result.replace(/\{\{light\.([a-zA-Z0-9_.]+)\}\}/g, (match, variable) => {
+    const { name, modifier } = parseVariableReference(variable);
+    const value = getContextValue(contexts.light, name, modifier);
+    return value ?? match;
+  });
+  result = result.replace(/\{\{theme\.([a-zA-Z0-9_]+)\}\}/g, (match, key) => {
+    const value = contexts.theme[key];
+    return value !== undefined ? String(value) : match;
+  });
+  return result;
+}
+
+// src/lib/template-engine/versioning.ts
+init_runtime();
+import { existsSync as existsSync9, readdirSync as readdirSync6 } from "fs";
+import { join as join7 } from "path";
+var DEFAULT_MANIFEST = {
+  version: 1,
+  templates: {}
+};
+async function loadTemplatesManifest() {
+  if (!existsSync9(TEMPLATES_MANIFEST_PATH)) {
+    return { ...DEFAULT_MANIFEST };
+  }
+  try {
+    const content = await readText(TEMPLATES_MANIFEST_PATH);
+    return JSON.parse(content);
+  } catch {
+    return { ...DEFAULT_MANIFEST };
+  }
+}
+async function saveTemplatesManifest(manifest) {
+  await ensureDir2(TEMPLATES_DIR);
+  await writeFile(TEMPLATES_MANIFEST_PATH, JSON.stringify(manifest, null, 2));
+}
+async function loadBundledManifest() {
+  if (!existsSync9(BUNDLED_MANIFEST_PATH)) {
+    return { version: 1, templates: {} };
+  }
+  try {
+    const content = await readText(BUNDLED_MANIFEST_PATH);
+    return JSON.parse(content);
+  } catch {
+    return { version: 1, templates: {} };
+  }
+}
+function compareVersions(a, b) {
+  const [aMajor = 0, aMinor = 0, aPatch = 0] = a.split(".").map(Number);
+  const [bMajor = 0, bMinor = 0, bPatch = 0] = b.split(".").map(Number);
+  if (aMajor !== bMajor)
+    return aMajor - bMajor;
+  if (aMinor !== bMinor)
+    return aMinor - bMinor;
+  return aPatch - bPatch;
+}
+async function checkTemplateUpdates() {
+  const installed = await loadTemplatesManifest();
+  const bundled = await loadBundledManifest();
+  const updates = [];
+  for (const [name, bundledMeta] of Object.entries(bundled.templates)) {
+    const installedMeta = installed.templates[name];
+    if (!installedMeta) {
+      updates.push({
+        name,
+        installedVersion: "0.0.0",
+        bundledVersion: bundledMeta.version,
+        customOverride: false,
+        updateAvailable: true
+      });
+    } else if (compareVersions(bundledMeta.version, installedMeta.version) > 0) {
+      updates.push({
+        name,
+        installedVersion: installedMeta.version,
+        bundledVersion: bundledMeta.version,
+        customOverride: installedMeta.customOverride,
+        updateAvailable: !installedMeta.customOverride
+      });
+    }
+  }
+  return updates;
+}
+async function installTemplate(templateName) {
+  const bundled = await loadBundledManifest();
+  const bundledMeta = bundled.templates[templateName];
+  if (!bundledMeta) {
+    throw new Error(`Template '${templateName}' not found in bundled templates`);
+  }
+  const sourcePath = join7(BUNDLED_TEMPLATES_DIR, templateName);
+  if (!existsSync9(sourcePath)) {
+    throw new Error(`Template file not found: ${sourcePath}`);
+  }
+  await ensureDir2(TEMPLATES_DIR);
+  const content = await readText(sourcePath);
+  const destPath = join7(TEMPLATES_DIR, templateName);
+  await writeFile(destPath, content);
+  const manifest = await loadTemplatesManifest();
+  manifest.templates[templateName] = {
+    version: bundledMeta.version,
+    installedAt: new Date().toISOString(),
+    customOverride: false
+  };
+  await saveTemplatesManifest(manifest);
+}
+async function installAllTemplates() {
+  const bundled = await loadBundledManifest();
+  for (const name of Object.keys(bundled.templates)) {
+    await installTemplate(name);
+  }
+}
+function getTemplateType(filename) {
+  const dualModeTemplates = ["ghostty.conf.template", "neovim.lua.template", "lynk.css.template"];
+  if (dualModeTemplates.includes(filename)) {
+    return "dual";
+  }
+  if (filename.includes("-dark.") || filename.includes("-light.")) {
+    return "partial";
+  }
+  return "single";
+}
+function getPartialMode(filename) {
+  if (filename.includes("-dark."))
+    return "dark";
+  if (filename.includes("-light."))
+    return "light";
+  return;
+}
+function getOutputFilename(templateName) {
+  let output = templateName.replace(/\.template$/, "");
+  if (templateName.startsWith("kitty-dark")) {
+    return "dark-theme.auto.conf";
+  }
+  if (templateName.startsWith("kitty-light")) {
+    return "light-theme.auto.conf";
+  }
+  if (templateName.startsWith("waybar-dark")) {
+    return "style-dark.css";
+  }
+  if (templateName.startsWith("waybar-light")) {
+    return "style-light.css";
+  }
+  if (templateName === "ghostty-dark.theme.template") {
+    return "formalconf-dark";
+  }
+  if (templateName === "ghostty-light.theme.template") {
+    return "formalconf-light";
+  }
+  if (templateName.startsWith("btop-dark")) {
+    return "formalconf-dark.theme";
+  }
+  if (templateName.startsWith("btop-light")) {
+    return "formalconf-light.theme";
+  }
+  return output;
+}
+async function listInstalledTemplates() {
+  if (!existsSync9(TEMPLATES_DIR)) {
+    return [];
+  }
+  const entries = readdirSync6(TEMPLATES_DIR, { withFileTypes: true });
+  const templates = [];
+  for (const entry of entries) {
+    if (entry.isFile() && entry.name.endsWith(".template")) {
+      templates.push({
+        name: entry.name,
+        path: join7(TEMPLATES_DIR, entry.name),
+        outputName: getOutputFilename(entry.name),
+        type: getTemplateType(entry.name),
+        partialMode: getPartialMode(entry.name)
+      });
+    }
+  }
+  return templates;
+}
+
+// src/lib/neovim/generator.ts
+function toLua(value, indent = 2) {
+  const spaces = " ".repeat(indent);
+  if (value === null || value === undefined) {
+    return "nil";
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    const escaped = value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"");
+    return `"${escaped}"`;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "{}";
+    }
+    const items = value.map((v) => `${spaces}${toLua(v, indent + 2)}`);
+    return `{
+${items.join(`,
+`)}
+${" ".repeat(indent - 2)}}`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return "{}";
+    }
+    const items = entries.map(([k, v]) => {
+      const key = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(k) ? k : `["${k}"]`;
+      return `${spaces}${key} = ${toLua(v, indent + 2)}`;
+    });
+    return `{
+${items.join(`,
+`)}
+${" ".repeat(indent - 2)}}`;
+  }
+  return "nil";
+}
+function generateOptsSection(opts) {
+  if (!opts || Object.keys(opts).length === 0) {
+    return "";
+  }
+  return `    opts = ${toLua(opts, 6)},`;
+}
+function generateNeovimConfig(theme, mode) {
+  if (!theme.neovim) {
+    return "";
+  }
+  const { repo, colorscheme, light_colorscheme, opts } = theme.neovim;
+  const effectiveColorscheme = mode === "light" && light_colorscheme ? light_colorscheme : colorscheme;
+  const optsSection = generateOptsSection(opts);
+  const hasDualMode = light_colorscheme && light_colorscheme !== colorscheme;
+  const lines = [
+    `-- ${theme.title} (${mode}) - Generated by FormalConf`,
+    `-- Neovim colorscheme configuration for LazyVim`,
+    ``,
+    `return {`,
+    `  {`,
+    `    "${repo}",`,
+    `    name = "${theme.title.toLowerCase().replace(/\s+/g, "-")}",`,
+    `    priority = 1000,`
+  ];
+  if (optsSection) {
+    lines.push(optsSection);
+  }
+  lines.push(`  },`, `  {`, `    "LazyVim/LazyVim",`, `    opts = {`, `      colorscheme = "${effectiveColorscheme}",`, `    },`, `  },`);
+  if (hasDualMode) {
+    lines.push(`  {`, `    "f-person/auto-dark-mode.nvim",`, `    opts = {`, `      update_background = false,`, `      set_dark_mode = function()`, `        vim.cmd("colorscheme ${colorscheme}")`, `      end,`, `      set_light_mode = function()`, `        vim.cmd("colorscheme ${light_colorscheme}")`, `      end,`, `    },`, `  },`);
+  }
+  lines.push(`}`);
+  return lines.join(`
+`) + `
+`;
+}
+function hasNeovimConfig(theme) {
+  return !!theme.neovim?.repo && !!theme.neovim?.colorscheme;
+}
+
+// src/lib/template-engine/engine.ts
+function buildThemeMetadata(theme, mode) {
+  return {
+    title: theme.title,
+    author: theme.author ?? "",
+    version: theme.version ?? "",
+    description: theme.description ?? "",
+    source: theme.source ?? "",
+    mode
+  };
+}
+function buildTemplateContext(theme, palette, mode) {
+  return {
+    color0: hexToColorVariable(palette.color0),
+    color1: hexToColorVariable(palette.color1),
+    color2: hexToColorVariable(palette.color2),
+    color3: hexToColorVariable(palette.color3),
+    color4: hexToColorVariable(palette.color4),
+    color5: hexToColorVariable(palette.color5),
+    color6: hexToColorVariable(palette.color6),
+    color7: hexToColorVariable(palette.color7),
+    color8: hexToColorVariable(palette.color8),
+    color9: hexToColorVariable(palette.color9),
+    color10: hexToColorVariable(palette.color10),
+    color11: hexToColorVariable(palette.color11),
+    color12: hexToColorVariable(palette.color12),
+    color13: hexToColorVariable(palette.color13),
+    color14: hexToColorVariable(palette.color14),
+    color15: hexToColorVariable(palette.color15),
+    background: hexToColorVariable(palette.background),
+    foreground: hexToColorVariable(palette.foreground),
+    cursor: hexToColorVariable(palette.cursor),
+    selection_background: hexToColorVariableOrDefault(palette.selection_background, palette.color0),
+    selection_foreground: hexToColorVariableOrDefault(palette.selection_foreground, palette.foreground),
+    accent: hexToColorVariableOrDefault(palette.accent, palette.color4),
+    border: hexToColorVariableOrDefault(palette.border, palette.color0),
+    theme: buildThemeMetadata(theme, mode),
+    mode
+  };
+}
+function buildDualModeContext(theme) {
+  if (!theme.dark || !theme.light) {
+    return null;
+  }
+  return {
+    dark: buildTemplateContext(theme, theme.dark, "dark"),
+    light: buildTemplateContext(theme, theme.light, "light"),
+    theme: buildThemeMetadata(theme, "dark")
+  };
+}
+async function renderTemplateFile(templateFile, theme, mode) {
+  const templateContent = await readText(templateFile.path);
+  let content;
+  if (templateFile.type === "dual") {
+    const dualContext = buildDualModeContext(theme);
+    if (!dualContext) {
+      const palette = theme[mode] ?? theme.dark ?? theme.light;
+      if (!palette) {
+        throw new Error(`Theme '${theme.title}' does not have any palette`);
+      }
+      const context = buildTemplateContext(theme, palette, mode);
+      const fallbackDualContext = {
+        dark: context,
+        light: context,
+        theme: buildThemeMetadata(theme, mode)
+      };
+      content = renderDualModeTemplate(templateContent, fallbackDualContext);
+    } else {
+      content = renderDualModeTemplate(templateContent, dualContext);
+    }
+  } else {
+    const effectiveMode = templateFile.partialMode ?? mode;
+    const palette = theme[effectiveMode];
+    if (!palette) {
+      throw new Error(`Theme '${theme.title}' does not have a ${effectiveMode} palette`);
+    }
+    const context = buildTemplateContext(theme, palette, effectiveMode);
+    content = renderTemplate(templateContent, context);
+  }
+  return {
+    template: templateFile,
+    content,
+    outputPath: join8(GENERATED_DIR, templateFile.outputName)
+  };
+}
+async function renderAllTemplates(theme, mode) {
+  const templates = await listInstalledTemplates();
+  const results = [];
+  for (const template of templates) {
+    if (template.type === "partial" && template.partialMode !== mode) {
+      if (theme[template.partialMode]) {
+        const result = await renderTemplateFile(template, theme, mode);
+        results.push(result);
+      }
+      continue;
+    }
+    try {
+      const result = await renderTemplateFile(template, theme, mode);
+      results.push(result);
+    } catch (err) {
+      console.error(`Warning: Could not render ${template.name}: ${err}`);
+    }
+  }
+  return results;
+}
+async function writeRenderedTemplates(results) {
+  await ensureDir2(GENERATED_DIR);
+  for (const result of results) {
+    await writeFile(result.outputPath, result.content);
+  }
+}
+async function generateNeovimConfigFile(theme, mode) {
+  if (!hasNeovimConfig(theme)) {
+    return null;
+  }
+  const content = generateNeovimConfig(theme, mode);
+  const outputPath = join8(GENERATED_DIR, "neovim.lua");
+  await writeFile(outputPath, content);
+  return {
+    template: {
+      name: "neovim.lua",
+      path: "",
+      outputName: "neovim.lua",
+      type: "single"
+    },
+    content,
+    outputPath
+  };
+}
+async function generateThemeConfigs(theme, mode) {
+  const results = await renderAllTemplates(theme, mode);
+  await writeRenderedTemplates(results);
+  const neovimResult = await generateNeovimConfigFile(theme, mode);
+  if (neovimResult) {
+    results.push(neovimResult);
+  }
+  return results;
+}
+
+// src/lib/migration/extractor.ts
+init_runtime();
+import { existsSync as existsSync10, readdirSync as readdirSync7 } from "fs";
+import { join as join9 } from "path";
+function normalizeHex2(hex) {
+  hex = hex.replace(/^(#|0x)/i, "");
+  if (hex.length === 3) {
+    hex = hex[0] + hex[0] + hex[1] + hex[1] + hex[2] + hex[2];
+  }
+  return `#${hex.toLowerCase()}`;
+}
+async function extractFromKitty(path) {
+  const content = await readText(path);
+  const colors5 = {};
+  const colorMappings = {
+    foreground: "foreground",
+    background: "background",
+    cursor: "cursor",
+    selection_foreground: "selection_foreground",
+    selection_background: "selection_background",
+    color0: "color0",
+    color1: "color1",
+    color2: "color2",
+    color3: "color3",
+    color4: "color4",
+    color5: "color5",
+    color6: "color6",
+    color7: "color7",
+    color8: "color8",
+    color9: "color9",
+    color10: "color10",
+    color11: "color11",
+    color12: "color12",
+    color13: "color13",
+    color14: "color14",
+    color15: "color15"
+  };
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const match = trimmed.match(/^(\w+)\s+(#?[0-9a-fA-F]{3,6})/);
+    if (match) {
+      const [, key, value] = match;
+      if (key in colorMappings) {
+        colors5[colorMappings[key]] = normalizeHex2(value);
+      }
+    }
+  }
+  return { colors: colors5, source: "kitty" };
+}
+async function extractFromAlacritty(path) {
+  const content = await readText(path);
+  const colors5 = {};
+  const colorRegex = /(\w+)\s*=\s*["']?(#?[0-9a-fA-F]{3,6})["']?/g;
+  const sectionMappings = {
+    "colors.primary": {
+      background: "background",
+      foreground: "foreground"
+    },
+    "colors.cursor": {
+      cursor: "cursor"
+    },
+    "colors.selection": {
+      background: "selection_background",
+      foreground: "selection_foreground"
+    },
+    "colors.normal": {
+      black: "color0",
+      red: "color1",
+      green: "color2",
+      yellow: "color3",
+      blue: "color4",
+      magenta: "color5",
+      cyan: "color6",
+      white: "color7"
+    },
+    "colors.bright": {
+      black: "color8",
+      red: "color9",
+      green: "color10",
+      yellow: "color11",
+      blue: "color12",
+      magenta: "color13",
+      cyan: "color14",
+      white: "color15"
+    }
+  };
+  let currentSection = "";
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    const sectionMatch = trimmed.match(/^\[([^\]]+)\]/);
+    if (sectionMatch) {
+      currentSection = sectionMatch[1];
+      continue;
+    }
+    const colorMatch = trimmed.match(/^(\w+)\s*=\s*["']?(#?[0-9a-fA-F]{3,6})["']?/);
+    if (colorMatch && currentSection in sectionMappings) {
+      const [, key, value] = colorMatch;
+      const sectionMap = sectionMappings[currentSection];
+      if (key in sectionMap) {
+        colors5[sectionMap[key]] = normalizeHex2(value);
+      }
+    }
+  }
+  return { colors: colors5, source: "alacritty" };
+}
+async function extractFromGhostty(path) {
+  const content = await readText(path);
+  const colors5 = {};
+  const mappings = {
+    foreground: "foreground",
+    background: "background",
+    "cursor-color": "cursor",
+    "selection-foreground": "selection_foreground",
+    "selection-background": "selection_background"
+  };
+  for (const line of content.split(`
+`)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#"))
+      continue;
+    const paletteMatch = trimmed.match(/^palette\s*=\s*(\d+)=([0-9a-fA-F]{6})/);
+    if (paletteMatch) {
+      const [, index, value] = paletteMatch;
+      const colorKey = `color${index}`;
+      if (parseInt(index) <= 15) {
+        colors5[colorKey] = normalizeHex2(value);
+      }
+      continue;
+    }
+    const colorMatch = trimmed.match(/^([\w-]+)\s*=\s*([0-9a-fA-F]{6})/);
+    if (colorMatch) {
+      const [, key, value] = colorMatch;
+      if (key in mappings) {
+        colors5[mappings[key]] = normalizeHex2(value);
+      }
+    }
+  }
+  return { colors: colors5, source: "ghostty" };
+}
+async function extractColors(filePath) {
+  if (!existsSync10(filePath)) {
+    return null;
+  }
+  const filename = filePath.toLowerCase();
+  if (filename.includes("kitty") || filename.endsWith(".conf")) {
+    const content = await readText(filePath);
+    if (content.includes("foreground") && content.includes("color0")) {
+      return extractFromKitty(filePath);
+    }
+  }
+  if (filename.includes("alacritty") || filename.endsWith(".toml")) {
+    return extractFromAlacritty(filePath);
+  }
+  if (filename.includes("ghostty")) {
+    return extractFromGhostty(filePath);
+  }
+  if (filename.endsWith(".conf")) {
+    return extractFromKitty(filePath);
+  }
+  return null;
+}
+async function extractFromLegacyTheme(themePath) {
+  if (!existsSync10(themePath)) {
+    return null;
+  }
+  const files = readdirSync7(themePath, { withFileTypes: true });
+  const preferredFiles = [
+    "kitty.conf",
+    "alacritty.toml",
+    "ghostty.conf"
+  ];
+  for (const preferred of preferredFiles) {
+    const match = files.find((f) => f.name.toLowerCase() === preferred.toLowerCase());
+    if (match) {
+      return extractColors(join9(themePath, match.name));
+    }
+  }
+  for (const file of files) {
+    if (file.isFile() && (file.name.endsWith(".conf") || file.name.endsWith(".toml"))) {
+      const result = await extractColors(join9(themePath, file.name));
+      if (result && Object.keys(result.colors).length > 0) {
+        return result;
+      }
+    }
+  }
+  return null;
+}
+function validatePalette2(colors5) {
+  const required = [
+    "color0",
+    "color1",
+    "color2",
+    "color3",
+    "color4",
+    "color5",
+    "color6",
+    "color7",
+    "color8",
+    "color9",
+    "color10",
+    "color11",
+    "color12",
+    "color13",
+    "color14",
+    "color15",
+    "background",
+    "foreground",
+    "cursor"
+  ];
+  const missing = [];
+  for (const key of required) {
+    if (!colors5[key]) {
+      missing.push(key);
+    }
+  }
+  return missing;
+}
+function fillMissingColors(colors5) {
+  const defaults = {
+    color0: "#000000",
+    color1: "#cc0000",
+    color2: "#4e9a06",
+    color3: "#c4a000",
+    color4: "#3465a4",
+    color5: "#75507b",
+    color6: "#06989a",
+    color7: "#d3d7cf",
+    color8: "#555753",
+    color9: "#ef2929",
+    color10: "#8ae234",
+    color11: "#fce94f",
+    color12: "#739fcf",
+    color13: "#ad7fa8",
+    color14: "#34e2e2",
+    color15: "#eeeeec",
+    background: "#1e1e1e",
+    foreground: "#d4d4d4",
+    cursor: "#ffffff"
+  };
+  return {
+    ...defaults,
+    ...colors5,
+    selection_background: colors5.selection_background ?? colors5.color0 ?? defaults.color0,
+    selection_foreground: colors5.selection_foreground ?? colors5.foreground ?? defaults.foreground,
+    accent: colors5.accent ?? colors5.color4 ?? defaults.color4,
+    border: colors5.border ?? colors5.color0 ?? defaults.color0
+  };
+}
+function generateThemeJson(name, colors5, options = {}) {
+  const palette = fillMissingColors(colors5);
+  const theme = {
+    title: name,
+    description: options.description,
+    author: options.author,
+    version: "1.0.0"
+  };
+  if (options.isLight) {
+    theme.light = palette;
+  } else {
+    theme.dark = palette;
+  }
+  return theme;
+}
+
+// src/cli/set-theme.ts
+init_runtime();
+
+// src/lib/wallpaper.ts
+import { existsSync as existsSync11, readdirSync as readdirSync8, unlinkSync } from "fs";
+import { join as join10 } from "path";
+var DEFAULT_TIMEOUT_MS = 30000;
+var MAX_FILE_SIZE = 50 * 1024 * 1024;
+function clearBackgroundsDir() {
+  if (!existsSync11(BACKGROUNDS_TARGET_DIR)) {
+    return;
+  }
+  const entries = readdirSync8(BACKGROUNDS_TARGET_DIR, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isFile() || entry.isSymbolicLink()) {
+      unlinkSync(join10(BACKGROUNDS_TARGET_DIR, entry.name));
+    }
+  }
+}
+function getExtension(url, contentType) {
+  const urlPath = new URL(url).pathname;
+  const urlExt = urlPath.split(".").pop()?.toLowerCase();
+  if (urlExt && ["png", "jpg", "jpeg", "webp", "gif", "bmp"].includes(urlExt)) {
+    return urlExt;
+  }
+  const typeMap = {
+    "image/png": "png",
+    "image/jpeg": "jpg",
+    "image/jpg": "jpg",
+    "image/webp": "webp",
+    "image/gif": "gif",
+    "image/bmp": "bmp"
+  };
+  return typeMap[contentType] || "png";
+}
+async function downloadWallpaper(url, filename, timeoutMs = DEFAULT_TIMEOUT_MS) {
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(url);
+    if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+      return { success: false, error: "URL must use http or https protocol" };
+    }
+  } catch {
+    return { success: false, error: "Invalid URL" };
+  }
+  await ensureDir2(BACKGROUNDS_TARGET_DIR);
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const response = await fetch(url, { signal: controller.signal });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      return {
+        success: false,
+        error: `HTTP error: ${response.status} ${response.statusText}`
+      };
+    }
+    const contentType = response.headers.get("content-type") || "";
+    if (!contentType.startsWith("image/")) {
+      return {
+        success: false,
+        error: `Invalid content type: ${contentType} (expected image/*)`
+      };
+    }
+    const contentLength = response.headers.get("content-length");
+    if (contentLength && parseInt(contentLength, 10) > MAX_FILE_SIZE) {
+      return {
+        success: false,
+        error: `File too large: ${Math.round(parseInt(contentLength, 10) / 1024 / 1024)}MB (max 50MB)`
+      };
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    if (arrayBuffer.byteLength > MAX_FILE_SIZE) {
+      return {
+        success: false,
+        error: `File too large: ${Math.round(arrayBuffer.byteLength / 1024 / 1024)}MB (max 50MB)`
+      };
+    }
+    const ext = getExtension(url, contentType);
+    const outputPath = join10(BACKGROUNDS_TARGET_DIR, `${filename}.${ext}`);
+    await Bun.write(outputPath, arrayBuffer);
+    return { success: true, path: outputPath };
+  } catch (err) {
+    clearTimeout(timeoutId);
+    if (err instanceof Error && err.name === "AbortError") {
+      return { success: false, error: `Download timed out after ${timeoutMs / 1000}s` };
+    }
+    return {
+      success: false,
+      error: err instanceof Error ? err.message : "Unknown error"
+    };
+  }
+}
+async function downloadThemeWallpapers(wallpapers, mode) {
+  clearBackgroundsDir();
+  const urls = mode === "light" && wallpapers.light && wallpapers.light.length > 0 ? wallpapers.light : wallpapers.dark;
+  const paths = [];
+  const errors = [];
+  for (let i = 0;i < urls.length; i++) {
+    const filename = urls.length === 1 ? "wallpaper" : `wallpaper-${i + 1}`;
+    const result = await downloadWallpaper(urls[i], filename);
+    if (result.success && result.path) {
+      paths.push(result.path);
+    } else if (result.error) {
+      errors.push(`[${i + 1}] ${result.error}`);
+    }
+  }
+  return { paths, errors };
+}
+
 // src/cli/set-theme.ts
 var colors5 = {
   red: "\x1B[0;31m",
@@ -4797,29 +6092,49 @@ var colors5 = {
   dim: "\x1B[2m",
   reset: "\x1B[0m"
 };
-async function listThemes() {
+async function listAllThemes() {
   await ensureConfigDir();
-  if (!existsSync7(THEMES_DIR)) {
-    return [];
-  }
-  const entries = readdirSync4(THEMES_DIR, { withFileTypes: true });
   const themes = [];
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      const themePath = join5(THEMES_DIR, entry.name);
-      const theme = await parseTheme(themePath, entry.name);
-      themes.push(theme);
+  const jsonThemes = await listJsonThemes();
+  for (const item of jsonThemes) {
+    for (const mode of item.availableModes) {
+      themes.push({
+        displayName: `${item.theme.title} (${mode})`,
+        identifier: `${item.name}:${mode}`,
+        type: "json",
+        mode,
+        path: item.path,
+        author: item.theme.author
+      });
+    }
+  }
+  if (existsSync12(THEMES_DIR)) {
+    const entries = readdirSync9(THEMES_DIR, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const themePath = join11(THEMES_DIR, entry.name);
+        const theme = await parseTheme(themePath, entry.name);
+        themes.push({
+          displayName: theme.name,
+          identifier: theme.name,
+          type: "legacy",
+          path: themePath,
+          author: theme.metadata?.author,
+          hasBackgrounds: theme.hasBackgrounds,
+          isLightMode: theme.isLightMode
+        });
+      }
     }
   }
   return themes;
 }
 function clearDirectory(dir) {
-  if (existsSync7(dir)) {
-    const entries = readdirSync4(dir, { withFileTypes: true });
+  if (existsSync12(dir)) {
+    const entries = readdirSync9(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join5(dir, entry.name);
+      const fullPath = join11(dir, entry.name);
       if (entry.isSymbolicLink() || entry.isFile()) {
-        unlinkSync(fullPath);
+        unlinkSync2(fullPath);
       } else if (entry.isDirectory()) {
         rmSync(fullPath, { recursive: true, force: true });
       }
@@ -4827,33 +6142,121 @@ function clearDirectory(dir) {
   }
 }
 function createSymlink(source, target) {
-  if (existsSync7(target)) {
-    unlinkSync(target);
+  if (existsSync12(target)) {
+    unlinkSync2(target);
   }
   symlinkSync(source, target);
 }
-async function applyTheme(themeName, saveMapping = false) {
-  const themeDir = join5(THEMES_DIR, themeName);
-  if (!existsSync7(themeDir)) {
+function parseThemeIdentifier(identifier) {
+  if (identifier.includes(":")) {
+    const [name, mode] = identifier.split(":");
+    if (mode === "dark" || mode === "light") {
+      return { name, mode };
+    }
+  }
+  return { name: identifier };
+}
+async function applyJsonTheme(themePath, mode, saveMapping, identifier) {
+  const theme = await loadThemeJson(themePath);
+  await ensureConfigDir();
+  await ensureDir2(THEME_TARGET_DIR);
+  await ensureDir2(GENERATED_DIR);
+  const installedTemplates = await listInstalledTemplates();
+  if (installedTemplates.length === 0) {
+    await installAllTemplates();
+  }
+  clearDirectory(THEME_TARGET_DIR);
+  if (existsSync12(BACKGROUNDS_TARGET_DIR)) {
+    rmSync(BACKGROUNDS_TARGET_DIR, { recursive: true, force: true });
+  }
+  const results = await generateThemeConfigs(theme, mode);
+  const ghosttyThemesDir = join11(HOME_DIR, ".config", "ghostty", "themes");
+  for (const result of results) {
+    const filename = basename4(result.outputPath);
+    if (filename === "formalconf-dark" || filename === "formalconf-light") {
+      await ensureDir2(ghosttyThemesDir);
+      const targetPath2 = join11(ghosttyThemesDir, filename);
+      copyFileSync(result.outputPath, targetPath2);
+    }
+    const targetPath = join11(THEME_TARGET_DIR, filename);
+    copyFileSync(result.outputPath, targetPath);
+  }
+  let wallpaperPaths = [];
+  let wallpaperErrors = [];
+  if (theme.wallpapers) {
+    const wallpaperResult = await downloadThemeWallpapers(theme.wallpapers, mode);
+    wallpaperPaths = wallpaperResult.paths;
+    wallpaperErrors = wallpaperResult.errors;
+  }
+  if (saveMapping) {
+    await setDeviceTheme(identifier);
+  }
+  let output = `Theme '${theme.title} (${mode})' applied successfully`;
+  output += `
+Generated ${results.length} config files`;
+  if (saveMapping) {
+    output += `
+Saved as device preference for '${getDeviceHostname()}'`;
+  }
+  if (theme.author) {
+    output += `
+Author: ${theme.author}`;
+  }
+  if (wallpaperPaths.length > 0) {
+    output += `
+Wallpapers (${wallpaperPaths.length}):`;
+    for (const path of wallpaperPaths) {
+      output += `
+  ${path}`;
+    }
+  }
+  for (const error of wallpaperErrors) {
+    output += `
+  Warning: ${error}`;
+  }
+  const hookEnv = {
+    FORMALCONF_THEME: identifier,
+    FORMALCONF_THEME_MODE: mode,
+    FORMALCONF_THEME_FILE: themePath
+  };
+  if (wallpaperPaths.length > 0) {
+    hookEnv.FORMALCONF_WALLPAPER_PATHS = wallpaperPaths.join(":");
+  }
+  const hookSummary = await runHooks("theme-change", hookEnv);
+  if (hookSummary.executed > 0) {
+    output += `
+Hooks: ${hookSummary.succeeded}/${hookSummary.executed} succeeded`;
+    for (const result of hookSummary.results) {
+      if (!result.success) {
+        output += `
+  Warning: ${result.script} failed (exit ${result.exitCode})`;
+      }
+    }
+  }
+  return { output, success: true };
+}
+async function applyLegacyTheme(themeName, saveMapping) {
+  const themeDir = join11(THEMES_DIR, themeName);
+  if (!existsSync12(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 (existsSync7(BACKGROUNDS_TARGET_DIR)) {
+  if (existsSync12(BACKGROUNDS_TARGET_DIR)) {
     rmSync(BACKGROUNDS_TARGET_DIR, { recursive: true, force: true });
   }
-  const entries = readdirSync4(themeDir, { withFileTypes: true });
+  const entries = readdirSync9(themeDir, { withFileTypes: true });
   for (const entry of entries) {
-    const source = join5(themeDir, entry.name);
+    const source = join11(themeDir, entry.name);
     if (entry.isFile() && entry.name !== "theme.yaml" && entry.name !== "light.mode") {
-      const target = join5(THEME_TARGET_DIR, entry.name);
+      const target = join11(THEME_TARGET_DIR, entry.name);
       createSymlink(source, target);
     }
   }
   if (theme.hasBackgrounds) {
-    const backgroundsSource = join5(themeDir, "backgrounds");
+    const backgroundsSource = join11(themeDir, "backgrounds");
     createSymlink(backgroundsSource, BACKGROUNDS_TARGET_DIR);
   }
   if (saveMapping) {
@@ -4875,17 +6278,98 @@ Wallpapers available at: ~/.config/formalconf/current/backgrounds/`;
     output += `
 Note: This is a light mode theme`;
   }
+  const hookSummary = await runHooks("theme-change", {
+    FORMALCONF_THEME: themeName,
+    FORMALCONF_THEME_DIR: themeDir
+  });
+  if (hookSummary.executed > 0) {
+    output += `
+Hooks: ${hookSummary.succeeded}/${hookSummary.executed} succeeded`;
+    for (const result of hookSummary.results) {
+      if (!result.success) {
+        output += `
+  Warning: ${result.script} failed (exit ${result.exitCode})`;
+      }
+    }
+  }
   return { output, success: true };
 }
-async function showThemeInfo(themeName) {
-  const themeDir = join5(THEMES_DIR, themeName);
-  if (!existsSync7(themeDir)) {
-    console.error(`${colors5.red}Error: Theme '${themeName}' not found${colors5.reset}`);
+async function applyTheme(themeIdentifier, saveMapping = false) {
+  const { name, mode } = parseThemeIdentifier(themeIdentifier);
+  const jsonPath = join11(THEMES_DIR, `${name}.json`);
+  if (existsSync12(jsonPath) && mode) {
+    return applyJsonTheme(jsonPath, mode, saveMapping, themeIdentifier);
+  }
+  const legacyPath = join11(THEMES_DIR, name);
+  if (existsSync12(legacyPath)) {
+    return applyLegacyTheme(name, saveMapping);
+  }
+  const allThemes = await listAllThemes();
+  const suggestions = allThemes.filter((t) => t.displayName.toLowerCase().includes(name.toLowerCase())).slice(0, 3);
+  let output = `Theme '${themeIdentifier}' not found`;
+  if (suggestions.length > 0) {
+    output += `
+
+Did you mean:`;
+    for (const s of suggestions) {
+      output += `
+  - ${s.identifier}`;
+    }
+  }
+  return { output, success: false };
+}
+async function showThemeInfo(themeIdentifier) {
+  const { name, mode } = parseThemeIdentifier(themeIdentifier);
+  const jsonPath = join11(THEMES_DIR, `${name}.json`);
+  if (existsSync12(jsonPath)) {
+    const theme2 = await loadThemeJson(jsonPath);
+    const modes = getAvailableModes(theme2);
+    console.log(`
+${colors5.cyan}Theme: ${theme2.title}${colors5.reset}`);
+    console.log(`Type: JSON template-based theme`);
+    if (theme2.author)
+      console.log(`Author: ${theme2.author}`);
+    if (theme2.description)
+      console.log(`Description: ${theme2.description}`);
+    if (theme2.version)
+      console.log(`Version: ${theme2.version}`);
+    if (theme2.source)
+      console.log(`Source: ${theme2.source}`);
+    console.log(`Available modes: ${modes.join(", ")}`);
+    if (theme2.neovim) {
+      console.log(`
+${colors5.green}Neovim integration:${colors5.reset}`);
+      console.log(`  Plugin: ${theme2.neovim.repo}`);
+      console.log(`  Colorscheme: ${theme2.neovim.colorscheme}`);
+      if (theme2.neovim.light_colorscheme) {
+        console.log(`  Light colorscheme: ${theme2.neovim.light_colorscheme}`);
+      }
+    }
+    if (theme2.wallpapers) {
+      console.log(`
+${colors5.green}Wallpapers:${colors5.reset}`);
+      console.log(`  Dark (${theme2.wallpapers.dark.length}):`);
+      for (const url of theme2.wallpapers.dark) {
+        console.log(`    ${url}`);
+      }
+      if (theme2.wallpapers.light && theme2.wallpapers.light.length > 0) {
+        console.log(`  Light (${theme2.wallpapers.light.length}):`);
+        for (const url of theme2.wallpapers.light) {
+          console.log(`    ${url}`);
+        }
+      }
+    }
+    return;
+  }
+  const themeDir = join11(THEMES_DIR, name);
+  if (!existsSync12(themeDir)) {
+    console.error(`${colors5.red}Error: Theme '${themeIdentifier}' not found${colors5.reset}`);
     process.exit(1);
   }
-  const theme = await parseTheme(themeDir, themeName);
+  const theme = await parseTheme(themeDir, name);
   console.log(`
 ${colors5.cyan}Theme: ${theme.name}${colors5.reset}`);
+  console.log(`Type: Legacy directory-based theme`);
   if (theme.metadata) {
     if (theme.metadata.author)
       console.log(`Author: ${theme.metadata.author}`);
@@ -4938,35 +6422,116 @@ function showDeviceMappings() {
   }
 }
 async function showThemeList() {
-  const themes = await listThemes();
+  const themes = await listAllThemes();
   const deviceTheme = getDeviceTheme();
   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}`);
+To add themes:`);
+    console.log(`  - JSON themes: ${colors5.cyan}~/.config/formalconf/themes/*.json${colors5.reset}`);
+    console.log(`  - Legacy themes: ${colors5.cyan}~/.config/formalconf/themes/<name>/${colors5.reset}`);
     return;
   }
-  console.log(`${colors5.cyan}Usage: formalconf theme <theme-name>${colors5.reset}`);
-  console.log(`       formalconf theme <theme-name> --save  ${colors5.dim}(save as device preference)${colors5.reset}`);
+  console.log(`${colors5.cyan}Usage: formalconf theme <theme-id>${colors5.reset}`);
+  console.log(`       formalconf theme <theme-id> --save  ${colors5.dim}(save as device preference)${colors5.reset}`);
   console.log(`       formalconf theme --apply              ${colors5.dim}(apply device's theme)${colors5.reset}`);
   console.log(`       formalconf theme --list-devices       ${colors5.dim}(show device mappings)${colors5.reset}`);
-  console.log(`       formalconf theme --default <name>     ${colors5.dim}(set default theme)${colors5.reset}`);
+  console.log(`       formalconf theme --default <id>       ${colors5.dim}(set default theme)${colors5.reset}`);
   console.log(`       formalconf theme --clear-default      ${colors5.dim}(remove default theme)${colors5.reset}`);
   console.log(`       formalconf theme --clear              ${colors5.dim}(remove device mapping)${colors5.reset}`);
-  console.log(`       formalconf theme --info <theme-name>  ${colors5.dim}(show theme details)${colors5.reset}
+  console.log(`       formalconf theme --info <theme-id>    ${colors5.dim}(show theme details)${colors5.reset}
 `);
-  console.log("Available themes:");
-  for (const theme of themes) {
-    const extras = [];
-    if (theme.hasBackgrounds)
-      extras.push("wallpapers");
-    if (theme.isLightMode)
-      extras.push("light");
-    if (theme.name === deviceTheme)
-      extras.push("device");
-    const suffix = extras.length ? ` ${colors5.dim}(${extras.join(", ")})${colors5.reset}` : "";
-    console.log(`  ${colors5.blue}•${colors5.reset} ${theme.name}${suffix}`);
+  const jsonThemes = themes.filter((t) => t.type === "json");
+  const legacyThemes = themes.filter((t) => t.type === "legacy");
+  if (jsonThemes.length > 0) {
+    console.log(`${colors5.cyan}Template-based themes:${colors5.reset}`);
+    for (const theme of jsonThemes) {
+      const extras = [];
+      if (theme.identifier === deviceTheme)
+        extras.push("device");
+      const suffix = extras.length ? ` ${colors5.dim}(${extras.join(", ")})${colors5.reset}` : "";
+      console.log(`  ${colors5.blue}•${colors5.reset} ${theme.displayName} ${colors5.dim}[${theme.identifier}]${colors5.reset}${suffix}`);
+    }
+  }
+  if (legacyThemes.length > 0) {
+    if (jsonThemes.length > 0)
+      console.log("");
+    console.log(`${colors5.cyan}Legacy themes:${colors5.reset}`);
+    for (const theme of legacyThemes) {
+      const extras = [];
+      if (theme.hasBackgrounds)
+        extras.push("wallpapers");
+      if (theme.isLightMode)
+        extras.push("light");
+      if (theme.identifier === deviceTheme)
+        extras.push("device");
+      const suffix = extras.length ? ` ${colors5.dim}(${extras.join(", ")})${colors5.reset}` : "";
+      console.log(`  ${colors5.blue}•${colors5.reset} ${theme.displayName}${suffix}`);
+    }
+  }
+}
+async function migrateTheme(themeName) {
+  const legacyPath = join11(THEMES_DIR, themeName);
+  if (!existsSync12(legacyPath)) {
+    console.error(`${colors5.red}Error: Legacy theme '${themeName}' not found${colors5.reset}`);
+    process.exit(1);
+  }
+  console.log(`Extracting colors from '${themeName}'...`);
+  const result = await extractFromLegacyTheme(legacyPath);
+  if (!result) {
+    console.error(`${colors5.red}Error: Could not extract colors from theme${colors5.reset}`);
+    console.error(`No supported config files found (kitty.conf, alacritty.toml, ghostty.conf)`);
+    process.exit(1);
+  }
+  console.log(`Found colors in: ${result.source}`);
+  const missing = validatePalette2(result.colors);
+  if (missing.length > 0) {
+    console.log(`${colors5.yellow}Warning: Missing colors will be filled with defaults:${colors5.reset}`);
+    console.log(`  ${missing.join(", ")}`);
+  }
+  const isLight = existsSync12(join11(legacyPath, "light.mode"));
+  const themeJson = generateThemeJson(themeName, result.colors, {
+    description: `Migrated from legacy theme`,
+    isLight
+  });
+  const outputPath = join11(THEMES_DIR, `${themeName}.json`);
+  if (existsSync12(outputPath)) {
+    console.error(`${colors5.red}Error: JSON theme '${themeName}.json' already exists${colors5.reset}`);
+    console.error(`Delete or rename it first, then try again.`);
+    process.exit(1);
+  }
+  await writeFile(outputPath, JSON.stringify(themeJson, null, 2));
+  console.log(`${colors5.green}Theme migrated successfully to '${themeName}.json'${colors5.reset}`);
+  console.log(`
+Next steps:`);
+  console.log(`  1. Review and edit ${outputPath}`);
+  console.log(`  2. Add a light palette if needed`);
+  console.log(`  3. Add neovim configuration if desired`);
+  console.log(`  4. Test with: bun run theme ${themeName}:${isLight ? "light" : "dark"}`);
+}
+async function showTemplateStatus() {
+  const installed = await listInstalledTemplates();
+  const updates = await checkTemplateUpdates();
+  console.log(`${colors5.cyan}Template Status${colors5.reset}
+`);
+  if (installed.length === 0) {
+    console.log(`${colors5.yellow}No templates installed.${colors5.reset}`);
+    console.log(`Run 'formalconf theme --install-templates' to install bundled templates.`);
+    return;
+  }
+  console.log(`Installed templates (${installed.length}):`);
+  for (const template of installed) {
+    console.log(`  ${colors5.blue}•${colors5.reset} ${template.name}`);
+  }
+  if (updates.length > 0) {
+    console.log(`
+${colors5.yellow}Updates available:${colors5.reset}`);
+    for (const update of updates) {
+      if (update.updateAvailable) {
+        const locked = update.customOverride ? ` ${colors5.dim}(locked)${colors5.reset}` : "";
+        console.log(`  ${colors5.blue}•${colors5.reset} ${update.name}: ${update.installedVersion} -> ${update.bundledVersion}${locked}`);
+      }
+    }
   }
 }
 async function main4() {
@@ -4979,11 +6544,27 @@ async function main4() {
       "list-devices": { type: "boolean", short: "l" },
       default: { type: "string", short: "d" },
       "clear-default": { type: "boolean" },
-      clear: { type: "boolean", short: "c" }
+      clear: { type: "boolean", short: "c" },
+      "install-templates": { type: "boolean" },
+      "template-status": { type: "boolean" },
+      migrate: { type: "string", short: "m" }
     },
     allowPositionals: true
   });
   const [themeName] = positionals;
+  if (values["template-status"]) {
+    await showTemplateStatus();
+    return;
+  }
+  if (values["install-templates"]) {
+    await installAllTemplates();
+    console.log(`${colors5.green}Templates installed successfully.${colors5.reset}`);
+    return;
+  }
+  if (values.migrate) {
+    await migrateTheme(values.migrate);
+    return;
+  }
   if (values["list-devices"]) {
     showDeviceMappings();
     return;
@@ -5004,8 +6585,9 @@ async function main4() {
     return;
   }
   if (values.default !== undefined) {
-    const themeDir = join5(THEMES_DIR, values.default);
-    if (!existsSync7(themeDir)) {
+    const allThemes = await listAllThemes();
+    const exists = allThemes.some((t) => t.identifier === values.default);
+    if (!exists) {
       console.error(`${colors5.red}Error: Theme '${values.default}' not found${colors5.reset}`);
       process.exit(1);
     }
@@ -5063,20 +6645,7 @@ function ThemeMenu({ onBack }) {
   });
   useEffect6(() => {
     async function loadThemes() {
-      if (!existsSync8(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 = join6(THEMES_DIR, entry.name);
-          const theme = await parseTheme(themePath, entry.name);
-          loadedThemes.push(theme);
-        }
-      }
+      const loadedThemes = await listAllThemes();
       setThemes(loadedThemes);
       setDeviceThemeName(getDeviceTheme());
       setLoading(false);
@@ -5084,10 +6653,9 @@ function ThemeMenu({ onBack }) {
     loadThemes();
   }, []);
   const applyTheme2 = async (theme, saveAsDeviceDefault) => {
-    const themeName = theme.path.split("/").pop();
-    await execute(() => runSetTheme(themeName, saveAsDeviceDefault));
+    await execute(() => runSetTheme(theme.identifier, saveAsDeviceDefault));
     if (saveAsDeviceDefault) {
-      setDeviceThemeName(themeName);
+      setDeviceThemeName(theme.identifier);
     }
   };
   const visibleThemes = useMemo4(() => {
@@ -5119,11 +6687,15 @@ function ThemeMenu({ onBack }) {
               children: "No themes available."
             }, undefined, false, undefined, this),
             /* @__PURE__ */ jsxDEV19(Text15, {
-              children: "This system is compatible with omarchy themes."
+              children: "Add themes to one of the following locations:"
+            }, undefined, false, undefined, this),
+            /* @__PURE__ */ jsxDEV19(Text15, {
+              dimColor: true,
+              children: "  JSON themes: ~/.config/formalconf/themes/*.json"
             }, undefined, false, undefined, this),
             /* @__PURE__ */ jsxDEV19(Text15, {
               dimColor: true,
-              children: "Add themes to ~/.config/formalconf/themes/"
+              children: "  Legacy themes: ~/.config/formalconf/themes/name/"
             }, undefined, false, undefined, this)
           ]
         }, undefined, true, undefined, this),
@@ -5159,8 +6731,8 @@ function ThemeMenu({ onBack }) {
           theme,
           isSelected: grid.visibleStartIndex + index === grid.selectedIndex,
           width: grid.cardWidth,
-          isDeviceTheme: theme.name === deviceTheme
-        }, theme.path, false, undefined, this))
+          isDeviceTheme: theme.identifier === deviceTheme
+        }, theme.identifier, false, undefined, this))
       }, undefined, false, undefined, this),
       grid.showScrollDown && /* @__PURE__ */ jsxDEV19(Text15, {
         dimColor: true,