ui-pro-forge-cli 2.5.0

package/assets/skills/brand/scripts/extract-colors.cjs

@@ -0,0 +1,341 @@
+#!/usr/bin/env node
+/**
+ * extract-colors.cjs
+ *
+ * Extract dominant colors from an image and compare against brand palette.
+ * Uses pure Node.js without external image processing dependencies.
+ *
+ * For full color extraction from images, integrate with ai-multimodal skill
+ * or use ImageMagick via shell commands.
+ *
+ * Usage:
+ *   node extract-colors.cjs <image-path>
+ *   node extract-colors.cjs <image-path> --brand-file <path>
+ *   node extract-colors.cjs --palette  # Show brand palette from guidelines
+ *
+ * Integration:
+ *   For image color analysis, use: ai-multimodal skill or ImageMagick
+ *   magick <image> -colors 10 -depth 8 -format "%c" histogram:info:
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// Default brand guidelines path
+const DEFAULT_GUIDELINES_PATH = "docs/brand-guidelines.md";
+
+/**
+ * Extract hex colors from markdown content
+ */
+function extractHexColors(text) {
+  const hexPattern = /#[0-9A-Fa-f]{6}\b/g;
+  return [...new Set(text.match(hexPattern) || [])];
+}
+
+/**
+ * Parse brand guidelines for color palette
+ */
+function parseBrandColors(guidelinesPath) {
+  const resolvedPath = path.isAbsolute(guidelinesPath)
+    ? guidelinesPath
+    : path.join(process.cwd(), guidelinesPath);
+
+  if (!fs.existsSync(resolvedPath)) {
+    return null;
+  }
+
+  const content = fs.readFileSync(resolvedPath, "utf-8");
+
+  const palette = {
+    primary: [],
+    secondary: [],
+    neutral: [],
+    semantic: [],
+    all: [],
+  };
+
+  // Extract colors from different sections
+  const sections = [
+    { name: "primary", regex: /### Primary[\s\S]*?(?=###|##|$)/i },
+    { name: "secondary", regex: /### Secondary[\s\S]*?(?=###|##|$)/i },
+    { name: "neutral", regex: /### Neutral[\s\S]*?(?=###|##|$)/i },
+    { name: "semantic", regex: /### Semantic[\s\S]*?(?=###|##|$)/i },
+  ];
+
+  sections.forEach(({ name, regex }) => {
+    const match = content.match(regex);
+    if (match) {
+      const colors = extractHexColors(match[0]);
+      palette[name] = colors;
+      palette.all.push(...colors);
+    }
+  });
+
+  // Dedupe all
+  palette.all = [...new Set(palette.all)];
+
+  return palette;
+}
+
+/**
+ * Convert hex to RGB
+ */
+function hexToRgb(hex) {
+  const result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
+  return result
+    ? {
+        r: parseInt(result[1], 16),
+        g: parseInt(result[2], 16),
+        b: parseInt(result[3], 16),
+      }
+    : null;
+}
+
+/**
+ * Convert RGB to hex
+ */
+function rgbToHex(r, g, b) {
+  return (
+    "#" +
+    [r, g, b]
+      .map((x) => {
+        const hex = Math.round(x).toString(16);
+        return hex.length === 1 ? "0" + hex : hex;
+      })
+      .join("")
+      .toUpperCase()
+  );
+}
+
+/**
+ * Calculate color distance (Euclidean in RGB space)
+ */
+function colorDistance(color1, color2) {
+  const rgb1 = typeof color1 === "string" ? hexToRgb(color1) : color1;
+  const rgb2 = typeof color2 === "string" ? hexToRgb(color2) : color2;
+
+  if (!rgb1 || !rgb2) return Infinity;
+
+  return Math.sqrt(
+    Math.pow(rgb1.r - rgb2.r, 2) +
+      Math.pow(rgb1.g - rgb2.g, 2) +
+      Math.pow(rgb1.b - rgb2.b, 2)
+  );
+}
+
+/**
+ * Find nearest brand color
+ */
+function findNearestBrandColor(color, brandColors) {
+  let nearest = null;
+  let minDistance = Infinity;
+
+  brandColors.forEach((brandColor) => {
+    const distance = colorDistance(color, brandColor);
+    if (distance < minDistance) {
+      minDistance = distance;
+      nearest = brandColor;
+    }
+  });
+
+  return { color: nearest, distance: minDistance };
+}
+
+/**
+ * Calculate brand compliance percentage
+ * Distance threshold: 50 (out of max ~441 for RGB)
+ */
+function calculateCompliance(extractedColors, brandColors, threshold = 50) {
+  if (!extractedColors || extractedColors.length === 0) return 100;
+  if (!brandColors || brandColors.length === 0) return 0;
+
+  let matchCount = 0;
+
+  extractedColors.forEach((color) => {
+    const nearest = findNearestBrandColor(color, brandColors);
+    if (nearest.distance <= threshold) {
+      matchCount++;
+    }
+  });
+
+  return Math.round((matchCount / extractedColors.length) * 100);
+}
+
+/**
+ * Generate ImageMagick command for color extraction
+ */
+function generateImageMagickCommand(imagePath, numColors = 10) {
+  return `magick "${imagePath}" -colors ${numColors} -depth 8 -format "%c" histogram:info:`;
+}
+
+/**
+ * Parse ImageMagick histogram output to extract colors
+ */
+function parseImageMagickOutput(output) {
+  const colors = [];
+  const lines = output.trim().split("\n");
+
+  lines.forEach((line) => {
+    // Match pattern like: 12345: (255,128,64) #FF8040 srgb(255,128,64)
+    const hexMatch = line.match(/#([0-9A-Fa-f]{6})/);
+    const countMatch = line.match(/^\s*(\d+):/);
+
+    if (hexMatch) {
+      colors.push({
+        hex: "#" + hexMatch[1].toUpperCase(),
+        count: countMatch ? parseInt(countMatch[1]) : 0,
+      });
+    }
+  });
+
+  // Sort by count (most common first)
+  colors.sort((a, b) => b.count - a.count);
+
+  return colors;
+}
+
+/**
+ * Display brand palette
+ */
+function displayPalette(palette) {
+  console.log("\n" + "=".repeat(50));
+  console.log("BRAND COLOR PALETTE");
+  console.log("=".repeat(50));
+
+  if (palette.primary.length > 0) {
+    console.log("\nPrimary Colors:");
+    palette.primary.forEach((c) => console.log(`  ${c}`));
+  }
+
+  if (palette.secondary.length > 0) {
+    console.log("\nSecondary Colors:");
+    palette.secondary.forEach((c) => console.log(`  ${c}`));
+  }
+
+  if (palette.neutral.length > 0) {
+    console.log("\nNeutral Colors:");
+    palette.neutral.forEach((c) => console.log(`  ${c}`));
+  }
+
+  if (palette.semantic.length > 0) {
+    console.log("\nSemantic Colors:");
+    palette.semantic.forEach((c) => console.log(`  ${c}`));
+  }
+
+  console.log("\n" + "=".repeat(50));
+  console.log(`Total: ${palette.all.length} colors in brand palette`);
+  console.log("=".repeat(50) + "\n");
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const args = process.argv.slice(2);
+  const jsonOutput = args.includes("--json");
+  const showPalette = args.includes("--palette");
+  const brandFileIdx = args.indexOf("--brand-file");
+  const brandFile =
+    brandFileIdx !== -1 ? args[brandFileIdx + 1] : DEFAULT_GUIDELINES_PATH;
+  const brandFileValue = brandFileIdx !== -1 ? args[brandFileIdx + 1] : null;
+  const imagePath = args.find(
+    (a) => !a.startsWith("--") && a !== brandFileValue
+  );
+
+  // Load brand palette
+  const brandPalette = parseBrandColors(brandFile);
+
+  if (!brandPalette) {
+    console.error(`Brand guidelines not found at: ${brandFile}`);
+    console.error(`Create brand guidelines or specify path with --brand-file`);
+    process.exit(1);
+  }
+
+  // Show palette mode
+  if (showPalette || !imagePath) {
+    if (jsonOutput) {
+      console.log(JSON.stringify(brandPalette, null, 2));
+    } else {
+      displayPalette(brandPalette);
+
+      if (!imagePath) {
+        console.log("To extract colors from an image:");
+        console.log("  node extract-colors.cjs <image-path>");
+        console.log("\nOr use ImageMagick directly:");
+        console.log('  magick image.png -colors 10 -depth 8 -format "%c" histogram:info:');
+      }
+    }
+    return;
+  }
+
+  // Resolve image path
+  const resolvedPath = path.isAbsolute(imagePath)
+    ? imagePath
+    : path.join(process.cwd(), imagePath);
+
+  if (!fs.existsSync(resolvedPath)) {
+    console.error(`Image not found: ${resolvedPath}`);
+    process.exit(1);
+  }
+
+  // Generate extraction instructions
+  const result = {
+    image: resolvedPath,
+    brandPalette: brandPalette,
+    extractionCommand: generateImageMagickCommand(resolvedPath),
+    instructions: [
+      "1. Run the ImageMagick command to extract colors:",
+      `   ${generateImageMagickCommand(resolvedPath)}`,
+      "",
+      "2. Or use the ai-multimodal skill:",
+      `   python .claude/skills/ai-multimodal/scripts/gemini_batch_process.py \\`,
+      `     --files "${resolvedPath}" \\`,
+      `     --task analyze \\`,
+      `     --prompt "Extract the 10 most dominant colors as hex values"`,
+      "",
+      "3. Then compare extracted colors against brand palette",
+    ],
+    complianceCheck: {
+      threshold: 50,
+      description:
+        "Colors within distance 50 (RGB space) are considered brand-compliant",
+      brandColors: brandPalette.all,
+    },
+  };
+
+  if (jsonOutput) {
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log("\n" + "=".repeat(60));
+    console.log("COLOR EXTRACTION HELPER");
+    console.log("=".repeat(60));
+    console.log(`\nImage: ${result.image}`);
+    console.log(`\nBrand Colors: ${brandPalette.all.length} colors loaded`);
+    console.log("\nTo extract colors from this image:\n");
+    result.instructions.forEach((line) => console.log(line));
+    console.log("\n" + "=".repeat(60));
+
+    // Show brand palette for reference
+    console.log("\nBrand Palette Reference:");
+    console.log(`  Primary: ${brandPalette.primary.join(", ") || "none"}`);
+    console.log(`  Secondary: ${brandPalette.secondary.join(", ") || "none"}`);
+    console.log(`  Neutral: ${brandPalette.neutral.join(", ") || "none"}`);
+    console.log("=".repeat(60) + "\n");
+  }
+}
+
+// Export functions for use as module
+module.exports = {
+  parseBrandColors,
+  hexToRgb,
+  rgbToHex,
+  colorDistance,
+  findNearestBrandColor,
+  calculateCompliance,
+  parseImageMagickOutput,
+};
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}

package/assets/skills/brand/scripts/inject-brand-context.cjs

@@ -0,0 +1,349 @@
+#!/usr/bin/env node
+/**
+ * inject-brand-context.cjs
+ *
+ * Extracts brand context from markdown brand guidelines
+ * and outputs a formatted system prompt addition.
+ *
+ * Usage:
+ *   node inject-brand-context.cjs [path-to-guidelines]
+ *   node inject-brand-context.cjs --json [path-to-guidelines]
+ *
+ * Default path: docs/brand-guidelines.md
+ */
+
+const fs = require("fs");
+const path = require("path");
+
+// Default brand guidelines path
+const DEFAULT_GUIDELINES_PATH = "docs/brand-guidelines.md";
+
+/**
+ * Extract hex colors from text
+ */
+function extractHexColors(text) {
+  const hexPattern = /#[0-9A-Fa-f]{6}\b/g;
+  return [...new Set(text.match(hexPattern) || [])];
+}
+
+/**
+ * Extract color data from markdown table
+ */
+function extractColorsFromTable(content) {
+  const colors = {
+    primary: [],
+    secondary: [],
+    neutral: [],
+    semantic: [],
+  };
+
+  // Find color tables
+  const primaryMatch = content.match(
+    /### Primary Colors[\s\S]*?\|[\s\S]*?(?=###|$)/i
+  );
+  const secondaryMatch = content.match(
+    /### Secondary Colors[\s\S]*?\|[\s\S]*?(?=###|$)/i
+  );
+  const neutralMatch = content.match(
+    /### Neutral[\s\S]*?\|[\s\S]*?(?=###|$)/i
+  );
+  const semanticMatch = content.match(
+    /### Semantic[\s\S]*?\|[\s\S]*?(?=###|$)/i
+  );
+
+  if (primaryMatch) colors.primary = extractHexColors(primaryMatch[0]);
+  if (secondaryMatch) colors.secondary = extractHexColors(secondaryMatch[0]);
+  if (neutralMatch) colors.neutral = extractHexColors(neutralMatch[0]);
+  if (semanticMatch) colors.semantic = extractHexColors(semanticMatch[0]);
+
+  return colors;
+}
+
+/**
+ * Extract typography info
+ */
+function extractTypography(content) {
+  const typography = {
+    heading: null,
+    body: null,
+    mono: null,
+  };
+
+  // Look for font definitions
+  const headingMatch = content.match(/--font-heading:\s*['"]([^'"]+)['"]/);
+  const bodyMatch = content.match(/--font-body:\s*['"]([^'"]+)['"]/);
+  const monoMatch = content.match(/--font-mono:\s*['"]([^'"]+)['"]/);
+
+  // Fallback: look in tables
+  const fontStackMatch = content.match(/### Font Stack[\s\S]*?(?=###|##|$)/i);
+  if (fontStackMatch) {
+    const stackText = fontStackMatch[0];
+    const headingAlt = stackText.match(/heading[^']*['"]([^'"]+)['"]/i);
+    const bodyAlt = stackText.match(/body[^']*['"]([^'"]+)['"]/i);
+
+    if (headingAlt) typography.heading = headingAlt[1];
+    if (bodyAlt) typography.body = bodyAlt[1];
+  }
+
+  if (headingMatch) typography.heading = headingMatch[1];
+  if (bodyMatch) typography.body = bodyMatch[1];
+  if (monoMatch) typography.mono = monoMatch[1];
+
+  return typography;
+}
+
+/**
+ * Extract voice/tone information
+ */
+function extractVoice(content) {
+  const voice = {
+    traits: [],
+    prohibited: [],
+    personality: "",
+  };
+
+  // Extract personality traits from table
+  const personalityMatch = content.match(
+    /### Brand Personality[\s\S]*?\|[\s\S]*?(?=###|##|$)/i
+  );
+  if (personalityMatch) {
+    const traits = personalityMatch[0].match(
+      /\*\*([^*]+)\*\*\s*\|\s*([^|]+)/g
+    );
+    if (traits) {
+      voice.traits = traits.map((t) => {
+        const match = t.match(/\*\*([^*]+)\*\*/);
+        return match ? match[1].trim() : "";
+      }).filter(Boolean);
+    }
+  }
+
+  // Extract prohibited terms
+  const prohibitedMatch = content.match(
+    /### Prohibited[\s\S]*?(?=###|##|$)/i
+  );
+  if (prohibitedMatch) {
+    const terms = prohibitedMatch[0].match(/\|\s*([^|]+)\s*\|/g);
+    if (terms) {
+      voice.prohibited = terms
+        .map((t) => t.replace(/\|/g, "").trim())
+        .filter((t) => t && !t.includes("Avoid") && !t.includes("---"));
+    }
+  }
+
+  // Fallback: look for Forbidden Phrases
+  const forbiddenMatch = content.match(
+    /### Forbidden Phrases[\s\S]*?(?=###|##|$)/i
+  );
+  if (forbiddenMatch && voice.prohibited.length === 0) {
+    const items = forbiddenMatch[0].match(/-\s*["']?([^"'\n(]+)/g);
+    if (items) {
+      voice.prohibited = items
+        .map((item) => item.replace(/^-\s*["']?/, "").trim())
+        .filter(Boolean);
+    }
+  }
+
+  voice.personality = voice.traits.join(", ");
+
+  return voice;
+}
+
+/**
+ * Extract core attributes
+ */
+function extractCoreAttributes(content) {
+  const attributes = [];
+
+  const attributesMatch = content.match(
+    /### Core Attributes[\s\S]*?\|[\s\S]*?(?=###|##|$)/i
+  );
+  if (attributesMatch) {
+    const rows = attributesMatch[0].match(
+      /\|\s*\*\*([^*]+)\*\*\s*\|\s*([^|]+)\|/g
+    );
+    if (rows) {
+      rows.forEach((row) => {
+        const match = row.match(/\*\*([^*]+)\*\*\s*\|\s*([^|]+)/);
+        if (match) {
+          attributes.push({
+            name: match[1].trim(),
+            description: match[2].trim(),
+          });
+        }
+      });
+    }
+  }
+
+  return attributes;
+}
+
+/**
+ * Extract AI image generation context
+ */
+function extractImageStyle(content) {
+  const imageStyle = {
+    basePrompt: "",
+    keywords: [],
+    mood: [],
+    donts: [],
+    examplePrompts: [],
+  };
+
+  // Extract base prompt template (content between ``` blocks after "Base Prompt Template")
+  const basePromptMatch = content.match(
+    /### Base Prompt Template[\s\S]*?```\n?([\s\S]*?)```/i
+  );
+  if (basePromptMatch) {
+    imageStyle.basePrompt = basePromptMatch[1].trim().replace(/\n/g, " ");
+  }
+
+  // Extract style keywords from table
+  const keywordsMatch = content.match(
+    /### Style Keywords[\s\S]*?\|[\s\S]*?(?=###|##|$)/i
+  );
+  if (keywordsMatch) {
+    const keywordRows = keywordsMatch[0].match(/\|\s*\*\*[^*]+\*\*\s*\|\s*([^|]+)\|/g);
+    if (keywordRows) {
+      keywordRows.forEach((row) => {
+        const match = row.match(/\|\s*\*\*[^*]+\*\*\s*\|\s*([^|]+)\|/);
+        if (match) {
+          const keywords = match[1].split(",").map((k) => k.trim()).filter(Boolean);
+          imageStyle.keywords.push(...keywords);
+        }
+      });
+    }
+  }
+
+  // Extract visual mood descriptors (bullet points)
+  const moodMatch = content.match(
+    /### Visual Mood Descriptors[\s\S]*?(?=###|##|$)/i
+  );
+  if (moodMatch) {
+    const moodItems = moodMatch[0].match(/-\s*([^\n]+)/g);
+    if (moodItems) {
+      imageStyle.mood = moodItems.map((item) => item.replace(/^-\s*/, "").trim());
+    }
+  }
+
+  // Extract visual don'ts from table
+  const dontsMatch = content.match(
+    /### Visual Don'ts[\s\S]*?\|[\s\S]*?(?=###|##|$)/i
+  );
+  if (dontsMatch) {
+    const dontRows = dontsMatch[0].match(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/g);
+    if (dontRows) {
+      dontRows.forEach((row) => {
+        const match = row.match(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/);
+        if (match && !match[1].includes("Avoid") && !match[1].includes("---")) {
+          imageStyle.donts.push(match[1].trim());
+        }
+      });
+    }
+  }
+
+  // Extract example prompts (content between ``` blocks after specific headers)
+  const exampleMatch = content.match(/### Example Prompts[\s\S]*?(?=##|$)/i);
+  if (exampleMatch) {
+    const prompts = exampleMatch[0].match(/\*\*([^*]+)\*\*:\s*```\n?([\s\S]*?)```/g);
+    if (prompts) {
+      prompts.forEach((p) => {
+        const match = p.match(/\*\*([^*]+)\*\*:\s*```\n?([\s\S]*?)```/);
+        if (match) {
+          imageStyle.examplePrompts.push({
+            type: match[1].trim(),
+            prompt: match[2].trim().replace(/\n/g, " "),
+          });
+        }
+      });
+    }
+  }
+
+  return imageStyle;
+}
+
+/**
+ * Generate system prompt addition
+ */
+function generatePromptAddition(brandContext) {
+  const { colors, typography, voice, attributes, imageStyle } = brandContext;
+
+  let prompt = `
+BRAND CONTEXT:
+==============
+
+VISUAL IDENTITY:
+- Primary Colors: ${colors.primary.join(", ") || "Not specified"}
+- Secondary Colors: ${colors.secondary.join(", ") || "Not specified"}
+- Typography: ${typography.heading || typography.body || "System fonts"}
+
+BRAND VOICE:
+- Personality: ${voice.personality || "Professional"}
+- Core Attributes: ${attributes.map((a) => a.name).join(", ") || "Not specified"}
+
+CONTENT RULES:
+- Prohibited Terms: ${voice.prohibited.join(", ") || "None specified"}
+`;
+
+  // Add image style context if available
+  if (imageStyle && imageStyle.basePrompt) {
+    prompt += `
+IMAGE GENERATION:
+- Base Prompt: ${imageStyle.basePrompt}
+- Style Keywords: ${imageStyle.keywords.slice(0, 10).join(", ") || "Not specified"}
+- Visual Mood: ${imageStyle.mood.slice(0, 5).join("; ") || "Not specified"}
+- Avoid: ${imageStyle.donts.join(", ") || "None specified"}
+`;
+  }
+
+  prompt += `
+Apply these brand guidelines to all generated content.
+Maintain consistent voice, colors, and messaging.
+`;
+
+  return prompt.trim();
+}
+
+/**
+ * Main function
+ */
+function main() {
+  const args = process.argv.slice(2);
+  const jsonOutput = args.includes("--json");
+  const guidelinesPath = args.find((a) => !a.startsWith("--")) || DEFAULT_GUIDELINES_PATH;
+
+  // Resolve path
+  const resolvedPath = path.isAbsolute(guidelinesPath)
+    ? guidelinesPath
+    : path.join(process.cwd(), guidelinesPath);
+
+  // Check if file exists
+  if (!fs.existsSync(resolvedPath)) {
+    console.error(`Error: Brand guidelines not found at ${resolvedPath}`);
+    console.error(`Create brand guidelines at ${DEFAULT_GUIDELINES_PATH} or specify a path.`);
+    process.exit(1);
+  }
+
+  // Read file
+  const content = fs.readFileSync(resolvedPath, "utf-8");
+
+  // Extract brand context
+  const brandContext = {
+    colors: extractColorsFromTable(content),
+    typography: extractTypography(content),
+    voice: extractVoice(content),
+    attributes: extractCoreAttributes(content),
+    imageStyle: extractImageStyle(content),
+    source: resolvedPath,
+    extractedAt: new Date().toISOString(),
+  };
+
+  // Output
+  if (jsonOutput) {
+    console.log(JSON.stringify(brandContext, null, 2));
+  } else {
+    console.log(generatePromptAddition(brandContext));
+  }
+}
+
+main();