@brickflow/cli 0.0.6 → 0.0.8

package/src/translate/runtime-config.js

@@ -0,0 +1,118 @@
+export const DEFAULT_CONTEXT_MODEL = 'gemini-3.1-flash-lite-preview'
+
+let runtimeConfig = null
+
+export function buildTranslateHelp(command = 'brick translate') {
+  return `${command}
+
+Required options:
+  --product-context "<text>"
+  --terminology "<text>"
+  --tone "<text>"
+  --api-key "<key>"
+
+Optional:
+  --context-model "<model>"  Default: ${DEFAULT_CONTEXT_MODEL}
+
+Example:
+  ${command} \\
+    --product-context "Creators sell adult content collections with free previews and paid unlocks." \\
+    --terminology "Collection=content pack; Unlock=paid access; VIP=paid content" \\
+    --tone "Natural, modern, conversion-oriented, explicit when source is explicit." \\
+    --api-key "your-gemini-api-key" \\
+    --context-model "${DEFAULT_CONTEXT_MODEL}"`
+}
+
+export function getTranslateRuntimeConfig() {
+  if (!runtimeConfig) {
+    throw new Error(
+      'Translate runtime config is not initialized. Pass --product-context, --terminology, --tone, and --api-key.',
+    )
+  }
+
+  return runtimeConfig
+}
+
+export function parseTranslateRuntimeArgs(rawArgs) {
+  const options = {
+    apiKey: null,
+    contextModel: DEFAULT_CONTEXT_MODEL,
+    productContext: null,
+    terminology: null,
+    tone: null,
+  }
+  const positional = []
+
+  for (let index = 0; index < rawArgs.length; index += 1) {
+    const value = rawArgs[index]
+
+    if (value === '--product-context') {
+      options.productContext = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--terminology') {
+      options.terminology = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--tone') {
+      options.tone = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--api-key') {
+      options.apiKey = rawArgs[index + 1] ?? null
+      index += 1
+      continue
+    }
+
+    if (value === '--context-model') {
+      options.contextModel = rawArgs[index + 1] ?? DEFAULT_CONTEXT_MODEL
+      index += 1
+      continue
+    }
+
+    positional.push(value)
+  }
+
+  return {
+    options,
+    positional,
+  }
+}
+
+export function setTranslateRuntimeConfig(config) {
+  validateTranslateRuntimeConfig(config)
+  runtimeConfig = {
+    ...config,
+    contextModel: config.contextModel || DEFAULT_CONTEXT_MODEL,
+  }
+}
+
+export function validateTranslateRuntimeConfig(config) {
+  const missing = []
+
+  if (!config.productContext) {
+    missing.push('--product-context')
+  }
+
+  if (!config.terminology) {
+    missing.push('--terminology')
+  }
+
+  if (!config.tone) {
+    missing.push('--tone')
+  }
+
+  if (!config.apiKey) {
+    missing.push('--api-key')
+  }
+
+  if (missing.length > 0) {
+    throw new Error(`Missing required translate options: ${missing.join(', ')}`)
+  }
+}

package/src/translate/sync.js

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'fs'
+import { globSync } from 'glob'
+import { dirname, resolve } from 'path'
+import { fileURLToPath } from 'url'
+
+import {
+  compileVueToJS,
+  extractStrings,
+  getTranslationPaths,
+  listWorkspaceFiles,
+  sortObjectKeys,
+  stringifySortedJson,
+} from './utils.js'
+
+const currentDir = dirname(fileURLToPath(import.meta.url))
+const workspaceRoot = resolve(currentDir, '../../../..')
+const activeGeneratedDirs = new Set()
+const cleanupRoots = new Set()
+const STATIC_CLEANUP_ROOTS = [
+  resolve(workspaceRoot, 'packages/brick/global'),
+  ...globSync('apps/*/global', {
+    absolute: true,
+    cwd: workspaceRoot,
+  }),
+]
+
+function cleanupGeneratedDirs() {
+  for (const rootDir of cleanupRoots) {
+    if (!existsSync(rootDir)) {
+      continue
+    }
+
+    for (const entry of readdirSync(rootDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) {
+        continue
+      }
+
+      const targetDir = resolve(rootDir, entry.name)
+
+      if (!activeGeneratedDirs.has(targetDir)) {
+        removeDir(targetDir)
+      }
+    }
+  }
+}
+
+function createProgress(total) {
+  let done = 0
+  const start = Date.now()
+
+  return function update(currentFile) {
+    done += 1
+
+    const percent = Math.round((done * 100) / total)
+    const filled = Math.round(percent / 5)
+    const empty = 20 - filled
+
+    const elapsed = ((Date.now() - start) / 1000).toFixed(1)
+
+    const shortName = currentFile.split('/').slice(-3).join('/')
+
+    process.stdout.write(
+      `\r⚙️  Processing: [${'█'.repeat(filled)}${' '.repeat(empty)}] ` +
+        `${percent}% (${done}/${total}) ` +
+        `⏱ ${elapsed}s ` +
+        `\x1b[90m${shortName}\x1b[0m\x1b[K`,
+    )
+  }
+}
+
+// ---------- progress ----------
+
+function detectEol(filePath) {
+  if (!existsSync(filePath)) {
+    return '\n'
+  }
+
+  const text = readFileSync(filePath, 'utf-8')
+  return text.includes('\r\n') ? '\r\n' : '\n'
+}
+
+// ---------- core ----------
+
+function ensureSortedJsonFile(filePath) {
+  if (!existsSync(filePath)) {
+    return false
+  }
+
+  const currentText = readFileSync(filePath, 'utf-8')
+  const parsed = JSON.parse(currentText)
+  const sortedText = stringifySortedJson(parsed)
+
+  if (normalizeJsonEol(currentText) === normalizeJsonEol(sortedText)) {
+    return false
+  }
+
+  writeTextPreservingEol(filePath, sortedText)
+  return true
+}
+
+function ensureSortedTranslationJsons(baseDir, samplePath) {
+  const filesToCheck = [samplePath, resolve(baseDir, 'ai-context.json')]
+  const generatedDir = resolve(baseDir, 'generated')
+
+  if (existsSync(generatedDir)) {
+    for (const entry of readdirSync(generatedDir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith('.json')) {
+        filesToCheck.push(resolve(generatedDir, entry.name))
+      }
+    }
+  }
+
+  for (const filePath of filesToCheck) {
+    try {
+      if (ensureSortedJsonFile(filePath)) {
+        console.log('\n🔤 Sorted keys:', filePath)
+      }
+    } catch (error) {
+      console.error('\n❌ invalid translation json:', filePath, error)
+    }
+  }
+}
+
+function normalizeJsonEol(content) {
+  return String(content).replace(/\r\n/g, '\n')
+}
+
+// ---------- core ----------
+
+function processFile(filePath) {
+  let code = readFileSync(filePath, 'utf-8')
+
+  try {
+    if (filePath.endsWith('.vue')) {
+      code = compileVueToJS(code, filePath)
+    }
+
+    const strings = extractStrings(code, filePath)
+
+    writeTranslations(filePath, strings)
+  } catch (e) {
+    console.error('\n❌ error:', filePath, e)
+  }
+}
+
+// ---------- translations ----------
+
+function removeDir(dir) {
+  if (existsSync(dir)) {
+    rmSync(dir, { force: true, recursive: true })
+  }
+}
+
+function writeTextPreservingEol(filePath, content) {
+  const eol = detectEol(filePath)
+  const normalized = String(content).replace(/\r?\n/g, eol)
+  writeFileSync(filePath, normalized, 'utf-8')
+}
+
+function writeTranslations(id, strings) {
+  const paths = getTranslationPaths(id)
+
+  if (!paths) {
+    return
+  }
+
+  const { baseDir, isComponent, isLayout, isPage, isScript, samplePath } = paths
+
+  if (isPage || isLayout || isScript) {
+    cleanupRoots.add(dirname(baseDir))
+  }
+
+  if (strings.size === 0) {
+    if (isComponent || isPage || isLayout || isScript) {
+      removeDir(baseDir)
+    }
+    return
+  }
+
+  if (isPage || isLayout || isScript) {
+    activeGeneratedDirs.add(baseDir)
+  }
+
+  mkdirSync(baseDir, { recursive: true })
+
+  let prev = {}
+
+  if (existsSync(samplePath)) {
+    try {
+      prev = JSON.parse(readFileSync(samplePath, 'utf-8'))
+    } catch {
+      prev = {}
+    }
+  }
+
+  const next = {}
+
+  for (const [k, v] of strings) {
+    next[k] = v
+  }
+
+  const sortedNext = sortObjectKeys(next)
+  const isSame =
+    Object.keys(prev).length === Object.keys(sortedNext).length &&
+    Object.keys(prev).every((k) => prev[k] === sortedNext[k])
+
+  if (!isSame) {
+    writeTextPreservingEol(samplePath, stringifySortedJson(sortedNext))
+    console.log('\n🧪 Updated:', samplePath)
+  }
+
+  ensureSortedTranslationJsons(baseDir, samplePath)
+}
+
+// ---------- run ----------
+
+const files = listWorkspaceFiles(workspaceRoot).filter(
+  (file) => /\.(?:js|ts|vue)$/.test(file) && !file.endsWith('.d.ts'),
+)
+
+const filtered = files.filter((file) => getTranslationPaths(file))
+for (const rootDir of STATIC_CLEANUP_ROOTS) {
+  cleanupRoots.add(rootDir)
+}
+
+const progress = createProgress(filtered.length)
+
+for (const file of filtered) {
+  processFile(file)
+  progress(file)
+}
+
+cleanupGeneratedDirs()
+
+process.stdout.write('\n')
+console.log('✅ Done')