1#!/usr/bin/env node
2/**
3 * inject-brand-context.cjs
4 *
5 * Extracts brand context from markdown brand guidelines
6 * and outputs a formatted system prompt addition.
7 *
8 * Usage:
9 *   node inject-brand-context.cjs [path-to-guidelines]
10 *   node inject-brand-context.cjs --json [path-to-guidelines]
11 *
12 * Default path: docs/brand-guidelines.md
13 */
14 
15const fs = require("fs");
16const path = require("path");
17 
18// Default brand guidelines path
19const DEFAULT_GUIDELINES_PATH = "docs/brand-guidelines.md";
20 
21/**
22 * Extract hex colors from text
23 */
24function extractHexColors(text) {
25  const hexPattern = /#[0-9A-Fa-f]{6}\b/g;
26  return [...new Set(text.match(hexPattern) || [])];
27}
28 
29/**
30 * Extract color data from markdown table
31 */
32function extractColorsFromTable(content) {
33  const colors = {
34    primary: [],
35    secondary: [],
36    neutral: [],
37    semantic: [],
38  };
39 
40  // Find color tables
41  const primaryMatch = content.match(
42    /### Primary Colors[\s\S]*?\|[\s\S]*?(?=###|$)/i
43  );
44  const secondaryMatch = content.match(
45    /### Secondary Colors[\s\S]*?\|[\s\S]*?(?=###|$)/i
46  );
47  const neutralMatch = content.match(
48    /### Neutral[\s\S]*?\|[\s\S]*?(?=###|$)/i
49  );
50  const semanticMatch = content.match(
51    /### Semantic[\s\S]*?\|[\s\S]*?(?=###|$)/i
52  );
53 
54  if (primaryMatch) colors.primary = extractHexColors(primaryMatch[0]);
55  if (secondaryMatch) colors.secondary = extractHexColors(secondaryMatch[0]);
56  if (neutralMatch) colors.neutral = extractHexColors(neutralMatch[0]);
57  if (semanticMatch) colors.semantic = extractHexColors(semanticMatch[0]);
58 
59  return colors;
60}
61 
62/**
63 * Extract typography info
64 */
65function extractTypography(content) {
66  const typography = {
67    heading: null,
68    body: null,
69    mono: null,
70  };
71 
72  // Look for font definitions
73  const headingMatch = content.match(/--font-heading:\s*['"]([^'"]+)['"]/);
74  const bodyMatch = content.match(/--font-body:\s*['"]([^'"]+)['"]/);
75  const monoMatch = content.match(/--font-mono:\s*['"]([^'"]+)['"]/);
76 
77  // Fallback: look in tables
78  const fontStackMatch = content.match(/### Font Stack[\s\S]*?(?=###|##|$)/i);
79  if (fontStackMatch) {
80    const stackText = fontStackMatch[0];
81    const headingAlt = stackText.match(/heading[^']*['"]([^'"]+)['"]/i);
82    const bodyAlt = stackText.match(/body[^']*['"]([^'"]+)['"]/i);
83 
84    if (headingAlt) typography.heading = headingAlt[1];
85    if (bodyAlt) typography.body = bodyAlt[1];
86  }
87 
88  if (headingMatch) typography.heading = headingMatch[1];
89  if (bodyMatch) typography.body = bodyMatch[1];
90  if (monoMatch) typography.mono = monoMatch[1];
91 
92  return typography;
93}
94 
95/**
96 * Extract voice/tone information
97 */
98function extractVoice(content) {
99  const voice = {
100    traits: [],
101    prohibited: [],
102    personality: "",
103  };
104 
105  // Extract personality traits from table
106  const personalityMatch = content.match(
107    /### Brand Personality[\s\S]*?\|[\s\S]*?(?=###|##|$)/i
108  );
109  if (personalityMatch) {
110    const traits = personalityMatch[0].match(
111      /\*\*([^*]+)\*\*\s*\|\s*([^|]+)/g
112    );
113    if (traits) {
114      voice.traits = traits.map((t) => {
115        const match = t.match(/\*\*([^*]+)\*\*/);
116        return match ? match[1].trim() : "";
117      }).filter(Boolean);
118    }
119  }
120 
121  // Extract prohibited terms
122  const prohibitedMatch = content.match(
123    /### Prohibited[\s\S]*?(?=###|##|$)/i
124  );
125  if (prohibitedMatch) {
126    const terms = prohibitedMatch[0].match(/\|\s*([^|]+)\s*\|/g);
127    if (terms) {
128      voice.prohibited = terms
129        .map((t) => t.replace(/\|/g, "").trim())
130        .filter((t) => t && !t.includes("Avoid") && !t.includes("---"));
131    }
132  }
133 
134  // Fallback: look for Forbidden Phrases
135  const forbiddenMatch = content.match(
136    /### Forbidden Phrases[\s\S]*?(?=###|##|$)/i
137  );
138  if (forbiddenMatch && voice.prohibited.length === 0) {
139    const items = forbiddenMatch[0].match(/-\s*["']?([^"'\n(]+)/g);
140    if (items) {
141      voice.prohibited = items
142        .map((item) => item.replace(/^-\s*["']?/, "").trim())
143        .filter(Boolean);
144    }
145  }
146 
147  voice.personality = voice.traits.join(", ");
148 
149  return voice;
150}
151 
152/**
153 * Extract core attributes
154 */
155function extractCoreAttributes(content) {
156  const attributes = [];
157 
158  const attributesMatch = content.match(
159    /### Core Attributes[\s\S]*?\|[\s\S]*?(?=###|##|$)/i
160  );
161  if (attributesMatch) {
162    const rows = attributesMatch[0].match(
163      /\|\s*\*\*([^*]+)\*\*\s*\|\s*([^|]+)\|/g
164    );
165    if (rows) {
166      rows.forEach((row) => {
167        const match = row.match(/\*\*([^*]+)\*\*\s*\|\s*([^|]+)/);
168        if (match) {
169          attributes.push({
170            name: match[1].trim(),
171            description: match[2].trim(),
172          });
173        }
174      });
175    }
176  }
177 
178  return attributes;
179}
180 
181/**
182 * Extract AI image generation context
183 */
184function extractImageStyle(content) {
185  const imageStyle = {
186    basePrompt: "",
187    keywords: [],
188    mood: [],
189    donts: [],
190    examplePrompts: [],
191  };
192 
193  // Extract base prompt template (content between ``` blocks after "Base Prompt Template")
194  const basePromptMatch = content.match(
195    /### Base Prompt Template[\s\S]*?```\n?([\s\S]*?)```/i
196  );
197  if (basePromptMatch) {
198    imageStyle.basePrompt = basePromptMatch[1].trim().replace(/\n/g, " ");
199  }
200 
201  // Extract style keywords from table
202  const keywordsMatch = content.match(
203    /### Style Keywords[\s\S]*?\|[\s\S]*?(?=###|##|$)/i
204  );
205  if (keywordsMatch) {
206    const keywordRows = keywordsMatch[0].match(/\|\s*\*\*[^*]+\*\*\s*\|\s*([^|]+)\|/g);
207    if (keywordRows) {
208      keywordRows.forEach((row) => {
209        const match = row.match(/\|\s*\*\*[^*]+\*\*\s*\|\s*([^|]+)\|/);
210        if (match) {
211          const keywords = match[1].split(",").map((k) => k.trim()).filter(Boolean);
212          imageStyle.keywords.push(...keywords);
213        }
214      });
215    }
216  }
217 
218  // Extract visual mood descriptors (bullet points)
219  const moodMatch = content.match(
220    /### Visual Mood Descriptors[\s\S]*?(?=###|##|$)/i
221  );
222  if (moodMatch) {
223    const moodItems = moodMatch[0].match(/-\s*([^\n]+)/g);
224    if (moodItems) {
225      imageStyle.mood = moodItems.map((item) => item.replace(/^-\s*/, "").trim());
226    }
227  }
228 
229  // Extract visual don'ts from table
230  const dontsMatch = content.match(
231    /### Visual Don'ts[\s\S]*?\|[\s\S]*?(?=###|##|$)/i
232  );
233  if (dontsMatch) {
234    const dontRows = dontsMatch[0].match(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/g);
235    if (dontRows) {
236      dontRows.forEach((row) => {
237        const match = row.match(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/);
238        if (match && !match[1].includes("Avoid") && !match[1].includes("---")) {
239          imageStyle.donts.push(match[1].trim());
240        }
241      });
242    }
243  }
244 
245  // Extract example prompts (content between ``` blocks after specific headers)
246  const exampleMatch = content.match(/### Example Prompts[\s\S]*?(?=##|$)/i);
247  if (exampleMatch) {
248    const prompts = exampleMatch[0].match(/\*\*([^*]+)\*\*:\s*```\n?([\s\S]*?)```/g);
249    if (prompts) {
250      prompts.forEach((p) => {
251        const match = p.match(/\*\*([^*]+)\*\*:\s*```\n?([\s\S]*?)```/);
252        if (match) {
253          imageStyle.examplePrompts.push({
254            type: match[1].trim(),
255            prompt: match[2].trim().replace(/\n/g, " "),
256          });
257        }
258      });
259    }
260  }
261 
262  return imageStyle;
263}
264 
265/**
266 * Generate system prompt addition
267 */
268function generatePromptAddition(brandContext) {
269  const { colors, typography, voice, attributes, imageStyle } = brandContext;
270 
271  let prompt = `
272BRAND CONTEXT:
273==============
274 
275VISUAL IDENTITY:
276- Primary Colors: ${colors.primary.join(", ") || "Not specified"}
277- Secondary Colors: ${colors.secondary.join(", ") || "Not specified"}
278- Typography: ${typography.heading || typography.body || "System fonts"}
279 
280BRAND VOICE:
281- Personality: ${voice.personality || "Professional"}
282- Core Attributes: ${attributes.map((a) => a.name).join(", ") || "Not specified"}
283 
284CONTENT RULES:
285- Prohibited Terms: ${voice.prohibited.join(", ") || "None specified"}
286`;
287 
288  // Add image style context if available
289  if (imageStyle && imageStyle.basePrompt) {
290    prompt += `
291IMAGE GENERATION:
292- Base Prompt: ${imageStyle.basePrompt}
293- Style Keywords: ${imageStyle.keywords.slice(0, 10).join(", ") || "Not specified"}
294- Visual Mood: ${imageStyle.mood.slice(0, 5).join("; ") || "Not specified"}
295- Avoid: ${imageStyle.donts.join(", ") || "None specified"}
296`;
297  }
298 
299  prompt += `
300Apply these brand guidelines to all generated content.
301Maintain consistent voice, colors, and messaging.
302`;
303 
304  return prompt.trim();
305}
306 
307/**
308 * Main function
309 */
310function main() {
311  const args = process.argv.slice(2);
312  const jsonOutput = args.includes("--json");
313  const guidelinesPath = args.find((a) => !a.startsWith("--")) || DEFAULT_GUIDELINES_PATH;
314 
315  // Resolve path
316  const resolvedPath = path.isAbsolute(guidelinesPath)
317    ? guidelinesPath
318    : path.join(process.cwd(), guidelinesPath);
319 
320  // Check if file exists
321  if (!fs.existsSync(resolvedPath)) {
322    console.error(`Error: Brand guidelines not found at ${resolvedPath}`);
323    console.error(`Create brand guidelines at ${DEFAULT_GUIDELINES_PATH} or specify a path.`);
324    process.exit(1);
325  }
326 
327  // Read file
328  const content = fs.readFileSync(resolvedPath, "utf-8");
329 
330  // Extract brand context
331  const brandContext = {
332    colors: extractColorsFromTable(content),
333    typography: extractTypography(content),
334    voice: extractVoice(content),
335    attributes: extractCoreAttributes(content),
336    imageStyle: extractImageStyle(content),
337    source: resolvedPath,
338    extractedAt: new Date().toISOString(),
339  };
340 
341  // Output
342  if (jsonOutput) {
343    console.log(JSON.stringify(brandContext, null, 2));
344  } else {
345    console.log(generatePromptAddition(brandContext));
346  }
347}
348 
349main();
350