formalconf 2.0.10 → 2.0.12

package/dist/formalconf.js

@@ -467,7 +467,7 @@ function StatusIndicator({
 // package.json
 var package_default = {
   name: "formalconf",
-  version: "2.0.10",
+  version: "2.0.12",
   description: "Dotfiles management TUI for macOS - config management, package sync, and theme switching",
   type: "module",
   main: "./dist/formalconf.js",
@@ -4666,13 +4666,13 @@ function useThemeGrid({
 import { parseArgs as parseArgs4 } from "util";
 import {
   readdirSync as readdirSync9,
-  existsSync as existsSync12,
+  existsSync as existsSync13,
   rmSync,
   symlinkSync,
   unlinkSync as unlinkSync2,
   copyFileSync
 } from "fs";
-import { join as join11, basename as basename4 } from "path";
+import { join as join12, basename as basename4 } from "path";
 
 // src/lib/theme-parser.ts
 init_runtime();
@@ -4784,9 +4784,318 @@ async function runHooks(hookType, env = {}) {
   };
 }
 
+// src/lib/gtk/colloid.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join6 } from "path";
+init_runtime();
+
+// src/lib/gtk/palette.ts
+function hexToRgb(hex) {
+  const clean = hex.replace("#", "");
+  return {
+    r: parseInt(clean.substring(0, 2), 16),
+    g: parseInt(clean.substring(2, 4), 16),
+    b: parseInt(clean.substring(4, 6), 16)
+  };
+}
+function rgbToHex(r, g, b) {
+  const toHex = (n) => Math.round(Math.max(0, Math.min(255, n))).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function interpolateColor(color1, color2, factor) {
+  const c1 = hexToRgb(color1);
+  const c2 = hexToRgb(color2);
+  return rgbToHex(c1.r + (c2.r - c1.r) * factor, c1.g + (c2.g - c1.g) * factor, c1.b + (c2.b - c1.b) * factor);
+}
+function interpolateGreyscale(bg, fg) {
+  const steps = 19;
+  const colors5 = [];
+  for (let i = 0;i < steps; i++) {
+    const factor = i / (steps - 1);
+    colors5.push(interpolateColor(bg, fg, factor));
+  }
+  return colors5;
+}
+function lighten(hex, percent) {
+  const { r, g, b } = hexToRgb(hex);
+  const factor = percent / 100;
+  return rgbToHex(r + (255 - r) * factor, g + (255 - g) * factor, b + (255 - b) * factor);
+}
+function darken(hex, percent) {
+  const { r, g, b } = hexToRgb(hex);
+  const factor = 1 - percent / 100;
+  return rgbToHex(r * factor, g * factor, b * factor);
+}
+function createColloidPalette(palette, mode) {
+  const isDark = mode === "dark";
+  const grey = isDark ? interpolateGreyscale(palette.background, palette.foreground) : interpolateGreyscale(palette.foreground, palette.background);
+  const orderedGrey = isDark ? grey : [...grey].reverse();
+  const accentBase = palette.accent || palette.color4;
+  return {
+    grey: orderedGrey,
+    black: palette.color0,
+    white: palette.color7,
+    red: {
+      dark: darken(palette.color1, 10),
+      light: lighten(palette.color1, 10)
+    },
+    green: {
+      dark: darken(palette.color2, 10),
+      light: lighten(palette.color2, 10)
+    },
+    yellow: {
+      dark: darken(palette.color3, 10),
+      light: lighten(palette.color3, 10)
+    },
+    blue: {
+      dark: darken(palette.color4, 10),
+      light: lighten(palette.color4, 10)
+    },
+    purple: {
+      dark: darken(palette.color5, 10),
+      light: lighten(palette.color5, 10)
+    },
+    teal: {
+      dark: darken(palette.color6, 10),
+      light: lighten(palette.color6, 10)
+    },
+    accent: {
+      dark: darken(accentBase, 10),
+      light: lighten(accentBase, 10)
+    }
+  };
+}
+function generateColloidScss(palette, mode) {
+  const colloid = createColloidPalette(palette, mode);
+  const greyNames = [
+    "050",
+    "100",
+    "150",
+    "200",
+    "250",
+    "300",
+    "350",
+    "400",
+    "450",
+    "500",
+    "550",
+    "600",
+    "650",
+    "700",
+    "750",
+    "800",
+    "850",
+    "900",
+    "950"
+  ];
+  let scss = `// FormalConf Generated Color Palette
+// Auto-generated - do not edit manually
+
+// Greyscale (interpolated from theme background/foreground)
+`;
+  for (let i = 0;i < greyNames.length; i++) {
+    scss += `$grey-${greyNames[i]}: ${colloid.grey[i]};
+`;
+  }
+  scss += `
+// Base colors
+$black: ${colloid.black};
+$white: ${colloid.white};
+
+// Semantic colors - dark variants
+$red-dark: ${colloid.red.dark};
+$green-dark: ${colloid.green.dark};
+$yellow-dark: ${colloid.yellow.dark};
+$blue-dark: ${colloid.blue.dark};
+$purple-dark: ${colloid.purple.dark};
+$teal-dark: ${colloid.teal.dark};
+
+// Semantic colors - light variants
+$red-light: ${colloid.red.light};
+$green-light: ${colloid.green.light};
+$yellow-light: ${colloid.yellow.light};
+$blue-light: ${colloid.blue.light};
+$purple-light: ${colloid.purple.light};
+$teal-light: ${colloid.teal.light};
+
+// Accent colors (primary buttons, links, highlights)
+$default-dark: ${colloid.accent.dark};
+$default-light: ${colloid.accent.light};
+$links: ${palette.accent || palette.color4};
+
+// Backgrounds
+$background: ${palette.background};
+$foreground: ${palette.foreground};
+`;
+  return scss;
+}
+
+// src/lib/gtk/colloid.ts
+var COLLOID_REPO_URL = "https://github.com/vinceliuice/Colloid-gtk-theme.git";
+async function checkGtkDependencies() {
+  const [git, sassc] = await Promise.all([
+    commandExists("git"),
+    commandExists("sassc")
+  ]);
+  const missing = [];
+  if (!git)
+    missing.push("git");
+  if (!sassc)
+    missing.push("sassc");
+  return { git, sassc, missing };
+}
+async function getDependencyInstructions(missing) {
+  if (missing.length === 0)
+    return "";
+  const distro = await getLinuxDistro();
+  const instructions = [];
+  for (const dep of missing) {
+    let instruction = `Missing: ${dep}
+`;
+    switch (distro) {
+      case "arch":
+        instruction += `  Install: sudo pacman -S ${dep}`;
+        break;
+      case "debian":
+      case "ubuntu":
+        instruction += `  Install: sudo apt install ${dep}`;
+        break;
+      case "fedora":
+        instruction += `  Install: sudo dnf install ${dep}`;
+        break;
+      case "opensuse":
+        instruction += `  Install: sudo zypper install ${dep}`;
+        break;
+      default:
+        instruction += `  Install via your package manager`;
+    }
+    instructions.push(instruction);
+  }
+  return instructions.join(`
+`);
+}
+async function cloneColloidRepo() {
+  await ensureDir2(GTK_DIR);
+  const result = await exec([
+    "git",
+    "clone",
+    "--depth",
+    "1",
+    COLLOID_REPO_URL,
+    COLLOID_DIR
+  ]);
+  return result.success;
+}
+async function updateColloidRepo() {
+  const result = await exec(["git", "pull", "--rebase"], COLLOID_DIR);
+  return result.success;
+}
+async function ensureColloidRepo() {
+  if (existsSync7(join6(COLLOID_DIR, ".git"))) {
+    return updateColloidRepo();
+  }
+  return cloneColloidRepo();
+}
+async function writeCustomPalette(palette, mode) {
+  const scss = generateColloidScss(palette, mode);
+  const palettePath = join6(COLLOID_DIR, "src", "sass", "_color-palette-formalconf.scss");
+  await writeFile(palettePath, scss);
+}
+async function patchTweaksFile(themeName) {
+  const tweaksContent = `// FormalConf theme: ${themeName}
+// Auto-patched to use custom color palette
+
+@import 'color-palette-formalconf';
+
+$tweaks: true;
+$colorscheme: true;
+`;
+  const tweaksPath = join6(COLLOID_DIR, "src", "sass", "_tweaks-temp.scss");
+  await writeFile(tweaksPath, tweaksContent);
+}
+async function runColloidInstall(options) {
+  const args = [
+    "./install.sh",
+    "-n",
+    `formalconf-${options.themeName}`,
+    "-c",
+    options.mode === "dark" ? "dark" : "light"
+  ];
+  if (options.installLibadwaita !== false) {
+    args.push("-l");
+  }
+  const tweaks = options.tweaks && options.tweaks.length > 0 ? options.tweaks : ["normal"];
+  args.push("--tweaks", ...tweaks);
+  const result = await exec(args, COLLOID_DIR);
+  return result.exitCode;
+}
+function getGtkThemeName(themeName, mode) {
+  const modeCapitalized = mode === "dark" ? "Dark" : "Light";
+  return `Colloid-formalconf-${themeName}-${modeCapitalized}`;
+}
+async function applyGtkTheme(theme, mode) {
+  if (getOS() !== "linux") {
+    return {
+      success: true,
+      themeName: "",
+      skipped: true,
+      skipReason: "GTK theming only available on Linux"
+    };
+  }
+  const palette = mode === "dark" ? theme.dark : theme.light;
+  if (!palette) {
+    return {
+      success: false,
+      themeName: "",
+      error: `Theme does not have a ${mode} palette`
+    };
+  }
+  const themeName = theme.title.toLowerCase().replace(/\s+/g, "-");
+  const deps = await checkGtkDependencies();
+  if (deps.missing.length > 0) {
+    const instructions = await getDependencyInstructions(deps.missing);
+    return {
+      success: false,
+      themeName: "",
+      error: `Missing dependencies:
+${instructions}`
+    };
+  }
+  const repoReady = await ensureColloidRepo();
+  if (!repoReady) {
+    return {
+      success: false,
+      themeName: "",
+      error: "Failed to clone/update Colloid repository"
+    };
+  }
+  await writeCustomPalette(palette, mode);
+  await patchTweaksFile(themeName);
+  const gtkConfig = theme.gtk || {};
+  const options = {
+    themeName,
+    mode,
+    variant: gtkConfig.variant,
+    tweaks: gtkConfig.tweaks,
+    installLibadwaita: true
+  };
+  const exitCode = await runColloidInstall(options);
+  if (exitCode !== 0) {
+    return {
+      success: false,
+      themeName: "",
+      error: `Colloid install.sh failed with exit code ${exitCode}`
+    };
+  }
+  const installedThemeName = getGtkThemeName(themeName, mode);
+  return {
+    success: true,
+    themeName: installedThemeName
+  };
+}
 // src/lib/theme-config.ts
 import { hostname } from "os";
-import { existsSync as existsSync7, readFileSync, writeFileSync } from "fs";
+import { existsSync as existsSync8, readFileSync, writeFileSync } from "fs";
 var DEFAULT_CONFIG = {
   version: 1,
   defaultTheme: null,
@@ -4796,7 +5105,7 @@ function getDeviceHostname() {
   return hostname();
 }
 function loadThemeConfig() {
-  if (!existsSync7(THEME_CONFIG_PATH)) {
+  if (!existsSync8(THEME_CONFIG_PATH)) {
     return { ...DEFAULT_CONFIG, devices: {} };
   }
   try {
@@ -4862,8 +5171,8 @@ function getDefaultTheme() {
 
 // 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";
+import { existsSync as existsSync9, readdirSync as readdirSync5 } from "fs";
+import { join as join7, basename as basename2 } from "path";
 
 // src/lib/theme-v2/color.ts
 function isValidHex(hex) {
@@ -4881,7 +5190,7 @@ function normalizeHex(hex) {
   }
   return hex.toUpperCase();
 }
-function hexToRgb(hex) {
+function hexToRgb2(hex) {
   const normalized = normalizeHex(hex);
   if (!isValidHex(normalized)) {
     throw new Error(`Invalid hex color: ${hex}`);
@@ -4893,7 +5202,7 @@ function hexToRgb(hex) {
 }
 function hexToColorVariable(hex) {
   const normalized = normalizeHex(hex);
-  const { r, g, b } = hexToRgb(normalized);
+  const { r, g, b } = hexToRgb2(normalized);
   return {
     hex: normalized,
     strip: normalized.slice(1),
@@ -5142,7 +5451,7 @@ ${validationErrors}`);
   }
 }
 async function loadThemeJson(themePath) {
-  if (!existsSync8(themePath)) {
+  if (!existsSync9(themePath)) {
     throw new ThemeLoadError(themePath, "file not found");
   }
   let content;
@@ -5172,14 +5481,14 @@ function getAvailableModes(theme) {
   return modes;
 }
 async function listJsonThemes() {
-  if (!existsSync8(THEMES_DIR)) {
+  if (!existsSync9(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);
+      const path = join7(THEMES_DIR, entry.name);
       try {
         const theme = await loadThemeJson(path);
         themes.push({
@@ -5198,7 +5507,7 @@ async function listJsonThemes() {
 
 // src/lib/template-engine/engine.ts
 init_runtime();
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 
 // src/lib/template-engine/modifiers.ts
 var VALID_MODIFIERS = [
@@ -5331,14 +5640,14 @@ function renderDualModeTemplate(template, contexts) {
 
 // src/lib/template-engine/versioning.ts
 init_runtime();
-import { existsSync as existsSync9, readdirSync as readdirSync6 } from "fs";
-import { join as join7 } from "path";
+import { existsSync as existsSync10, readdirSync as readdirSync6 } from "fs";
+import { join as join8 } from "path";
 var DEFAULT_MANIFEST = {
   version: 1,
   templates: {}
 };
 async function loadTemplatesManifest() {
-  if (!existsSync9(TEMPLATES_MANIFEST_PATH)) {
+  if (!existsSync10(TEMPLATES_MANIFEST_PATH)) {
     return { ...DEFAULT_MANIFEST };
   }
   try {
@@ -5353,7 +5662,7 @@ async function saveTemplatesManifest(manifest) {
   await writeFile(TEMPLATES_MANIFEST_PATH, JSON.stringify(manifest, null, 2));
 }
 async function loadBundledManifest() {
-  if (!existsSync9(BUNDLED_MANIFEST_PATH)) {
+  if (!existsSync10(BUNDLED_MANIFEST_PATH)) {
     return { version: 1, templates: {} };
   }
   try {
@@ -5404,13 +5713,13 @@ async function installTemplate(templateName) {
   if (!bundledMeta) {
     throw new Error(`Template '${templateName}' not found in bundled templates`);
   }
-  const sourcePath = join7(BUNDLED_TEMPLATES_DIR, templateName);
-  if (!existsSync9(sourcePath)) {
+  const sourcePath = join8(BUNDLED_TEMPLATES_DIR, templateName);
+  if (!existsSync10(sourcePath)) {
     throw new Error(`Template file not found: ${sourcePath}`);
   }
   await ensureDir2(TEMPLATES_DIR);
   const content = await readText(sourcePath);
-  const destPath = join7(TEMPLATES_DIR, templateName);
+  const destPath = join8(TEMPLATES_DIR, templateName);
   await writeFile(destPath, content);
   const manifest = await loadTemplatesManifest();
   manifest.templates[templateName] = {
@@ -5472,7 +5781,7 @@ function getOutputFilename(templateName) {
   return output;
 }
 async function listInstalledTemplates() {
-  if (!existsSync9(TEMPLATES_DIR)) {
+  if (!existsSync10(TEMPLATES_DIR)) {
     return [];
   }
   const entries = readdirSync6(TEMPLATES_DIR, { withFileTypes: true });
@@ -5481,7 +5790,7 @@ async function listInstalledTemplates() {
     if (entry.isFile() && entry.name.endsWith(".template")) {
       templates.push({
         name: entry.name,
-        path: join7(TEMPLATES_DIR, entry.name),
+        path: join8(TEMPLATES_DIR, entry.name),
         outputName: getOutputFilename(entry.name),
         type: getTemplateType(entry.name),
         partialMode: getPartialMode(entry.name)
@@ -5655,7 +5964,7 @@ async function renderTemplateFile(templateFile, theme, mode) {
   return {
     template: templateFile,
     content,
-    outputPath: join8(GENERATED_DIR, templateFile.outputName)
+    outputPath: join9(GENERATED_DIR, templateFile.outputName)
   };
 }
 async function renderAllTemplates(theme, mode) {
@@ -5689,7 +5998,7 @@ async function generateNeovimConfigFile(theme, mode) {
     return null;
   }
   const content = generateNeovimConfig(theme, mode);
-  const outputPath = join8(GENERATED_DIR, "neovim.lua");
+  const outputPath = join9(GENERATED_DIR, "neovim.lua");
   await writeFile(outputPath, content);
   return {
     template: {
@@ -5714,8 +6023,8 @@ async function generateThemeConfigs(theme, mode) {
 
 // src/lib/migration/extractor.ts
 init_runtime();
-import { existsSync as existsSync10, readdirSync as readdirSync7 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync11, readdirSync as readdirSync7 } from "fs";
+import { join as join10 } from "path";
 function normalizeHex2(hex) {
   hex = hex.replace(/^(#|0x)/i, "");
   if (hex.length === 3) {
@@ -5856,7 +6165,7 @@ async function extractFromGhostty(path) {
   return { colors: colors5, source: "ghostty" };
 }
 async function extractColors(filePath) {
-  if (!existsSync10(filePath)) {
+  if (!existsSync11(filePath)) {
     return null;
   }
   const filename = filePath.toLowerCase();
@@ -5878,7 +6187,7 @@ async function extractColors(filePath) {
   return null;
 }
 async function extractFromLegacyTheme(themePath) {
-  if (!existsSync10(themePath)) {
+  if (!existsSync11(themePath)) {
     return null;
   }
   const files = readdirSync7(themePath, { withFileTypes: true });
@@ -5890,12 +6199,12 @@ async function extractFromLegacyTheme(themePath) {
   for (const preferred of preferredFiles) {
     const match = files.find((f) => f.name.toLowerCase() === preferred.toLowerCase());
     if (match) {
-      return extractColors(join9(themePath, match.name));
+      return extractColors(join10(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));
+      const result = await extractColors(join10(themePath, file.name));
       if (result && Object.keys(result.colors).length > 0) {
         return result;
       }
@@ -5984,19 +6293,19 @@ function generateThemeJson(name, colors5, options = {}) {
 init_runtime();
 
 // src/lib/wallpaper.ts
-import { existsSync as existsSync11, readdirSync as readdirSync8, unlinkSync } from "fs";
-import { join as join10 } from "path";
+import { existsSync as existsSync12, readdirSync as readdirSync8, unlinkSync } from "fs";
+import { join as join11 } from "path";
 init_runtime();
 var DEFAULT_TIMEOUT_MS = 30000;
 var MAX_FILE_SIZE = 50 * 1024 * 1024;
 function clearBackgroundsDir() {
-  if (!existsSync11(BACKGROUNDS_TARGET_DIR)) {
+  if (!existsSync12(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));
+      unlinkSync(join11(BACKGROUNDS_TARGET_DIR, entry.name));
     }
   }
 }
@@ -6060,7 +6369,7 @@ async function downloadWallpaper(url, filename, timeoutMs = DEFAULT_TIMEOUT_MS)
       };
     }
     const ext = getExtension(url, contentType);
-    const outputPath = join10(BACKGROUNDS_TARGET_DIR, `${filename}.${ext}`);
+    const outputPath = join11(BACKGROUNDS_TARGET_DIR, `${filename}.${ext}`);
     await writeBuffer(outputPath, arrayBuffer);
     return { success: true, path: outputPath };
   } catch (err) {
@@ -6117,11 +6426,11 @@ async function listAllThemes() {
       });
     }
   }
-  if (existsSync12(THEMES_DIR)) {
+  if (existsSync13(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 themePath = join12(THEMES_DIR, entry.name);
         const theme = await parseTheme(themePath, entry.name);
         themes.push({
           displayName: theme.name,
@@ -6138,10 +6447,10 @@ async function listAllThemes() {
   return themes;
 }
 function clearDirectory(dir) {
-  if (existsSync12(dir)) {
+  if (existsSync13(dir)) {
     const entries = readdirSync9(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const fullPath = join11(dir, entry.name);
+      const fullPath = join12(dir, entry.name);
       if (entry.isSymbolicLink() || entry.isFile()) {
         unlinkSync2(fullPath);
       } else if (entry.isDirectory()) {
@@ -6151,7 +6460,7 @@ function clearDirectory(dir) {
   }
 }
 function createSymlink(source, target) {
-  if (existsSync12(target)) {
+  if (existsSync13(target)) {
     unlinkSync2(target);
   }
   symlinkSync(source, target);
@@ -6175,19 +6484,19 @@ async function applyJsonTheme(themePath, mode, saveMapping, identifier) {
     await installAllTemplates();
   }
   clearDirectory(THEME_TARGET_DIR);
-  if (existsSync12(BACKGROUNDS_TARGET_DIR)) {
+  if (existsSync13(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");
+  const ghosttyThemesDir = join12(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);
+      const targetPath2 = join12(ghosttyThemesDir, filename);
       copyFileSync(result.outputPath, targetPath2);
     }
-    const targetPath = join11(THEME_TARGET_DIR, filename);
+    const targetPath = join12(THEME_TARGET_DIR, filename);
     copyFileSync(result.outputPath, targetPath);
   }
   let wallpaperPaths = [];
@@ -6197,6 +6506,10 @@ async function applyJsonTheme(themePath, mode, saveMapping, identifier) {
     wallpaperPaths = wallpaperResult.paths;
     wallpaperErrors = wallpaperResult.errors;
   }
+  let gtkResult = null;
+  if (getOS() === "linux") {
+    gtkResult = await applyGtkTheme(theme, mode);
+  }
   if (saveMapping) {
     await setDeviceTheme(identifier);
   }
@@ -6223,6 +6536,15 @@ Wallpapers (${wallpaperPaths.length}):`;
     output += `
   Warning: ${error}`;
   }
+  if (gtkResult && !gtkResult.skipped) {
+    if (gtkResult.success) {
+      output += `
+GTK theme: ${gtkResult.themeName}`;
+    } else {
+      output += `
+  Warning: GTK theme failed - ${gtkResult.error}`;
+    }
+  }
   const hookEnv = {
     FORMALCONF_THEME: identifier,
     FORMALCONF_THEME_MODE: mode,
@@ -6231,6 +6553,9 @@ Wallpapers (${wallpaperPaths.length}):`;
   if (wallpaperPaths.length > 0) {
     hookEnv.FORMALCONF_WALLPAPER_PATHS = wallpaperPaths.join(":");
   }
+  if (gtkResult?.success && gtkResult.themeName) {
+    hookEnv.FORMALCONF_GTK_THEME = gtkResult.themeName;
+  }
   const hookSummary = await runHooks("theme-change", hookEnv);
   if (hookSummary.executed > 0) {
     output += `
@@ -6245,27 +6570,27 @@ Hooks: ${hookSummary.succeeded}/${hookSummary.executed} succeeded`;
   return { output, success: true };
 }
 async function applyLegacyTheme(themeName, saveMapping) {
-  const themeDir = join11(THEMES_DIR, themeName);
-  if (!existsSync12(themeDir)) {
+  const themeDir = join12(THEMES_DIR, themeName);
+  if (!existsSync13(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 (existsSync12(BACKGROUNDS_TARGET_DIR)) {
+  if (existsSync13(BACKGROUNDS_TARGET_DIR)) {
     rmSync(BACKGROUNDS_TARGET_DIR, { recursive: true, force: true });
   }
   const entries = readdirSync9(themeDir, { withFileTypes: true });
   for (const entry of entries) {
-    const source = join11(themeDir, entry.name);
+    const source = join12(themeDir, entry.name);
     if (entry.isFile() && entry.name !== "theme.yaml" && entry.name !== "light.mode") {
-      const target = join11(THEME_TARGET_DIR, entry.name);
+      const target = join12(THEME_TARGET_DIR, entry.name);
       createSymlink(source, target);
     }
   }
   if (theme.hasBackgrounds) {
-    const backgroundsSource = join11(themeDir, "backgrounds");
+    const backgroundsSource = join12(themeDir, "backgrounds");
     createSymlink(backgroundsSource, BACKGROUNDS_TARGET_DIR);
   }
   if (saveMapping) {
@@ -6305,12 +6630,12 @@ Hooks: ${hookSummary.succeeded}/${hookSummary.executed} succeeded`;
 }
 async function applyTheme(themeIdentifier, saveMapping = false) {
   const { name, mode } = parseThemeIdentifier(themeIdentifier);
-  const jsonPath = join11(THEMES_DIR, `${name}.json`);
-  if (existsSync12(jsonPath) && mode) {
+  const jsonPath = join12(THEMES_DIR, `${name}.json`);
+  if (existsSync13(jsonPath) && mode) {
     return applyJsonTheme(jsonPath, mode, saveMapping, themeIdentifier);
   }
-  const legacyPath = join11(THEMES_DIR, name);
-  if (existsSync12(legacyPath)) {
+  const legacyPath = join12(THEMES_DIR, name);
+  if (existsSync13(legacyPath)) {
     return applyLegacyTheme(name, saveMapping);
   }
   const allThemes = await listAllThemes();
@@ -6329,8 +6654,8 @@ Did you mean:`;
 }
 async function showThemeInfo(themeIdentifier) {
   const { name, mode } = parseThemeIdentifier(themeIdentifier);
-  const jsonPath = join11(THEMES_DIR, `${name}.json`);
-  if (existsSync12(jsonPath)) {
+  const jsonPath = join12(THEMES_DIR, `${name}.json`);
+  if (existsSync13(jsonPath)) {
     const theme2 = await loadThemeJson(jsonPath);
     const modes = getAvailableModes(theme2);
     console.log(`
@@ -6370,8 +6695,8 @@ ${colors5.green}Wallpapers:${colors5.reset}`);
     }
     return;
   }
-  const themeDir = join11(THEMES_DIR, name);
-  if (!existsSync12(themeDir)) {
+  const themeDir = join12(THEMES_DIR, name);
+  if (!existsSync13(themeDir)) {
     console.error(`${colors5.red}Error: Theme '${themeIdentifier}' not found${colors5.reset}`);
     process.exit(1);
   }
@@ -6480,8 +6805,8 @@ To add themes:`);
   }
 }
 async function migrateTheme(themeName) {
-  const legacyPath = join11(THEMES_DIR, themeName);
-  if (!existsSync12(legacyPath)) {
+  const legacyPath = join12(THEMES_DIR, themeName);
+  if (!existsSync13(legacyPath)) {
     console.error(`${colors5.red}Error: Legacy theme '${themeName}' not found${colors5.reset}`);
     process.exit(1);
   }
@@ -6498,13 +6823,13 @@ async function migrateTheme(themeName) {
     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 isLight = existsSync13(join12(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)) {
+  const outputPath = join12(THEMES_DIR, `${themeName}.json`);
+  if (existsSync13(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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "formalconf",
-  "version": "2.0.10",
+  "version": "2.0.12",
   "description": "Dotfiles management TUI for macOS - config management, package sync, and theme switching",
   "type": "module",
   "main": "./dist/formalconf.js",