@brickflow/cli 0.0.5 → 0.0.7

package/src/latest/index.js

@@ -0,0 +1,105 @@
+import { exec } from 'child_process'
+import fs from 'fs'
+import { globSync } from 'glob'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const args = process.argv.slice(3)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+if (args.length > 0) {
+  printHelp()
+  process.exit(1)
+}
+
+const currentDir = path.dirname(fileURLToPath(import.meta.url))
+const workspaceRoot = path.resolve(currentDir, '../../../..')
+const packageJsonPaths = globSync('**/package.json', {
+  absolute: true,
+  cwd: workspaceRoot,
+  ignore: ['**/node_modules/**'],
+}).sort()
+
+console.log('\x1b[32m', '\rPackage update')
+
+let index = 0
+
+for await (const packageJsonPath of packageJsonPaths) {
+  index += 1
+
+  const packageJson = JSON.parse(
+    fs.readFileSync(packageJsonPath, {
+      encoding: 'utf-8',
+    }),
+  )
+
+  await updateJson(packageJson)
+  fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`)
+
+  const percent = Math.round((index * 100) / packageJsonPaths.length)
+  process.stdout.write(`\r💎 Updating: [${'🔩'.repeat((percent * 10) / 100)}]  ${percent}%`)
+}
+
+process.stdout.write('\n')
+console.log('\x1b[0m', '')
+
+function isWorkspaceVersion(value) {
+  return value === 'workspace:*' || value === 'workspace: *'
+}
+
+function printHelp() {
+  console.log(`brick latest
+
+Usage:
+  brick latest
+
+  Notes:
+  Scans all package.json files in the repository, including the root one
+  Updates dependencies and devDependencies to the latest npm versions
+  Skips workspace:* versions`)
+}
+
+function readLatestVersion(packageName) {
+  return new Promise((resolve) => {
+    exec(`npm view ${packageName} version`, (error, stdout) => {
+      if (error) {
+        console.info(error.message)
+        resolve(null)
+        return
+      }
+
+      resolve(String(stdout).trim().replace('\n', ''))
+    })
+  })
+}
+
+async function updateJson(jsonData) {
+  await Promise.all([
+    ...Object.entries(jsonData.dependencies || {}).map(async ([key, value]) => {
+      if (isWorkspaceVersion(value)) {
+        return
+      }
+
+      const version = await readLatestVersion(key)
+
+      if (version) {
+        jsonData.dependencies[key] = version
+      }
+    }),
+    ...Object.entries(jsonData.devDependencies || {}).map(async ([key, value]) => {
+      if (isWorkspaceVersion(value)) {
+        return
+      }
+
+      const version = await readLatestVersion(key)
+
+      if (version) {
+        jsonData.devDependencies[key] = version
+      }
+    }),
+  ])
+}

package/src/size/index.js

@@ -0,0 +1,64 @@
+import fs from 'fs'
+import { globSync } from 'glob'
+
+const args = process.argv.slice(3)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+if (args.length > 0) {
+  printHelp()
+  process.exit(1)
+}
+
+console.log('\x1b[32m', '\rAssets analyse')
+const imgList = globSync('./**/*.{webp,svg}')
+
+if (imgList.length === 0) {
+  console.log('\nNothing find!')
+}
+
+function bytesToSize(bytes, decimals = 2) {
+  if (!Number(bytes)) {
+    return '0 Bytes'
+  }
+
+  const kbToBytes = 1000
+  const dm = decimals < 0 ? 0 : decimals
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+
+  const index = Math.floor(Math.log(bytes) / Math.log(kbToBytes))
+
+  return `${parseFloat((bytes / kbToBytes ** index).toFixed(dm))} ${sizes[index]}`
+}
+
+let result = ''
+for (let i = 0; i < imgList.length; i++) {
+  const imgPath = imgList[i]
+  const size = fs.statSync(imgPath).size
+  if (size > 400000 && !/-animation.webp$/.test(imgPath)) {
+    result = `${result}
+      🐢 ${bytesToSize(size)}  🗺️ ${imgPath}
+    `
+  }
+}
+if (result.length > 0) {
+  console.log('\x1b[0m', '')
+  throw result
+}
+
+console.log('\x1b[0m', '')
+
+function printHelp() {
+  console.log(`brick size
+
+Usage:
+  brick size
+
+Notes:
+  Scans .webp and .svg files under the current working directory
+  Fails when a file is larger than 400000 bytes
+  Ignores files ending with -animation.webp`)
+}

package/src/svg/index.js

@@ -0,0 +1,97 @@
+import fs from 'fs'
+import { globSync } from 'glob'
+import { optimize } from 'svgo'
+
+const args = process.argv.slice(3)
+
+if (args.includes('--help') || args.includes('-h')) {
+  printHelp()
+  process.exit(0)
+}
+
+if (args.length > 0) {
+  printHelp()
+  process.exit(1)
+}
+
+console.log('\x1b[32m', '\rSVG Optimize')
+const svgList = globSync('./**/*.svg')
+
+for (let i = 0; i < svgList.length; i++) {
+  const svgPath = svgList[i]
+  const svg = fs.readFileSync(svgPath, 'utf8')
+  const svgOptimized = optimize(svg, {
+    js2svg: {
+      indent: '',
+      pretty: true,
+    },
+    path: svgPath,
+    plugins: [
+      // "addAttributesToSVGElement", // adds attributes to an outer <svg> element
+      // "addClassesToSVGElement", // add classnames to an outer <svg> element
+      'cleanupAttrs', // cleanup attributes from newlines, trailing, and repeating spaces Yes
+      'cleanupEnableBackground', // remove or cleanup enable-background attribute when possible Yes
+      'cleanupIds', // remove unused and minify used IDs Yes
+      'cleanupListOfValues', // round numeric values in attributes that take a list of numbers (like viewBox or enable-background)
+      'cleanupNumericValues', // round numeric values to the fixed precision, remove default px units Yes
+      'collapseGroups', // collapse useless groups Yes
+      'convertColors', // convert colors (from rgb() to #rrggbb, from #rrggbb to #rgb) Yes
+      'convertEllipseToCircle', // convert non-eccentric <ellipse> to <circle> Yes
+      'convertPathData', // convert Path data to relative or absolute (whichever is shorter), convert one segment to another, trim useless delimiters, smart rounding, and much more Yes
+      'convertShapeToPath', // convert some basic shapes to <path> Yes
+      'convertStyleToAttrs', // convert styles into attributes
+      'convertTransform', // collapse multiple transforms into one, convert matrices to the short aliases, and much more Yes
+      'inlineStyles', // move and merge styles from <style> elements to element style attributes Yes
+      'mergePaths', // merge multiple Paths into one Yes
+      'mergeStyles', // merge multiple style elements into one Yes
+      'minifyStyles', // minify <style> elements content with CSSO Yes
+      'moveElemsAttrsToGroup', // move elements' attributes to their enclosing group Yes
+      'moveGroupAttrsToElems', // move some group attributes to the contained elements Yes
+      'prefixIds', // prefix IDs and classes with the SVG filename or an arbitrary string
+      // "removeAttributesBySelector", // removes attributes of elements that match a CSS selector
+      // "removeAttrs", // remove attributes by pattern
+      'removeComments', // remove comments Yes
+      'removeDesc', // remove <desc> Yes
+      'removeDimensions', // remove width/height and add viewBox if it's missing (opposite to removeViewBox, disable it first)
+      'removeDoctype', // remove doctype declaration Yes
+      'removeEditorsNSData', // remove editors namespaces, elements, and attributes Yes
+      'removeElementsByAttr', // remove arbitrary elements by ID or className
+      'removeEmptyAttrs', // remove empty attributes Yes
+      'removeEmptyContainers', // remove empty Container elements Yes
+      'removeEmptyText', // remove empty Text elements Yes
+      'removeHiddenElems', // remove hidden elements Yes
+      'removeMetadata', // remove <metadata> Yes
+      'removeNonInheritableGroupAttrs', // remove non-inheritable group's "presentation" attributes Yes
+      'removeOffCanvasPaths', // removes elements that are drawn outside of the viewbox
+      'removeRasterImages', // remove raster images
+      'removeScripts', // remove <script> elements
+      // "removeStyleElement", // remove <style> elements
+      'removeTitle', // remove <title> Yes
+      'removeUnknownsAndDefaults', // remove unknown elements content and attributes, remove attributes with default values Yes
+      'removeUnusedNS', // remove unused namespaces declaration Yes
+      'removeUselessDefs', // remove elements of <defs> without id Yes
+      'removeUselessStrokeAndFill', // remove useless stroke and fill attributes Yes
+      // "removeViewBox", // remove viewBox attribute when possible Yes
+      // "removeXMLNS", // removes the xmlns attribute (for inline SVG)
+      'removeXMLProcInst', // remove XML processing instructions Yes
+      'reusePaths', // Find duplicated elements and replace them with links
+      'sortAttrs', // sort element attributes for epic readability Yes
+      'sortDefsChildren', // sort children of <defs> in order to improve compression Yes
+    ],
+  })
+  fs.writeFileSync(svgPath, svgOptimized.data)
+  const percent = Math.round(((i + 1) * 100) / svgList.length)
+  process.stdout.write(`\r🔅 Optimizing: [${'🌹'.repeat((percent * 10) / 100)}]  ${percent}%`)
+}
+console.log('\x1b[0m', '')
+
+function printHelp() {
+  console.log(`brick svg
+
+Usage:
+  brick svg
+
+Notes:
+  Scans .svg files under the current working directory
+  Optimizes files in place with svgo`)
+}

package/src/translate/ai-context.js

@@ -0,0 +1,321 @@
+#!/usr/bin/env node
+
+import fs from 'fs'
+import { dirname, join, relative, resolve } from 'path'
+import { fileURLToPath } from 'url'
+
+import { generateContentWithLimits } from './gemini.js'
+import {
+  buildTranslateHelp,
+  DEFAULT_CONTEXT_MODEL,
+  getTranslateRuntimeConfig,
+  parseTranslateRuntimeArgs,
+  setTranslateRuntimeConfig,
+} from './runtime-config.js'
+import { getTranslationPaths, listWorkspaceFiles, stringifySortedJson } from './utils.js'
+
+const currentDir = dirname(fileURLToPath(import.meta.url))
+const workspaceRoot = resolve(currentDir, '../../../..')
+const CONTEXT_FILE_NAME = 'ai-context.json'
+const CHANGE_THRESHOLD = readFloat('TRANSLATE_CONTEXT_MIN_CHANGE', 0.3)
+const SOURCE_MAX_CHARS = readPositiveInt('TRANSLATE_CONTEXT_SOURCE_MAX_CHARS', 16000)
+
+export function calculateChangeRatio(previousSource, nextSource) {
+  const before = normalizeSource(previousSource)
+  const after = normalizeSource(nextSource)
+
+  if (before === after) {
+    return 0
+  }
+
+  const beforeLines = before.split('\n')
+  const afterLines = after.split('\n')
+  const commonLines = longestCommonSubsequenceLength(beforeLines, afterLines)
+  const maxLines = Math.max(beforeLines.length, afterLines.length, 1)
+
+  return 1 - commonLines / maxLines
+}
+
+export async function ensureAiContext({ force = false, sample, samplePath, sourceFilePath }) {
+  const state = getAiContextState({ force, samplePath, sourceFilePath })
+
+  if (!state.shouldRegenerate) {
+    return state.description
+  }
+
+  const description = await generateContextDescription({
+    sample,
+    samplePath,
+    sourceCode: state.sourceCode,
+    sourceFilePath: state.sourceFilePath,
+  })
+
+  const next = {
+    changeRatio: state.changeRatio,
+    description,
+    samplePath: relative(workspaceRoot, samplePath),
+    sourceFilePath: relative(workspaceRoot, state.sourceFilePath),
+    sourceSnapshot: state.sourceCode,
+    updatedAt: new Date().toISOString(),
+    version: 1,
+  }
+
+  writeTextPreservingEol(state.contextPath, stringifySortedJson(next))
+
+  return description
+}
+
+export function getAiContextState({ force = false, samplePath, sourceFilePath }) {
+  if (!samplePath || !sourceFilePath || !fs.existsSync(sourceFilePath)) {
+    return {
+      changeRatio: 0,
+      contextPath: samplePath ? getContextFilePath(samplePath) : null,
+      description: null,
+      existing: null,
+      reason: 'missing_source',
+      shouldRegenerate: false,
+      sourceCode: null,
+      sourceFilePath,
+    }
+  }
+
+  const contextPath = getContextFilePath(samplePath)
+  const sourceCode = fs.readFileSync(sourceFilePath, 'utf-8')
+  const existing = readContextFile(contextPath)
+  const changeRatio = existing?.sourceSnapshot ? calculateChangeRatio(existing.sourceSnapshot, sourceCode) : 1
+  const hasDescription = typeof existing?.description === 'string' && existing.description.length > 0
+  const shouldRegenerate = force || !hasDescription || changeRatio >= CHANGE_THRESHOLD
+
+  let reason = 'reuse'
+
+  if (force) {
+    reason = 'force'
+  } else if (!hasDescription) {
+    reason = 'missing_context'
+  } else if (changeRatio >= CHANGE_THRESHOLD) {
+    reason = 'changed_30_percent'
+  }
+
+  return {
+    changeRatio,
+    contextPath,
+    description: hasDescription ? existing.description : null,
+    existing,
+    reason,
+    shouldRegenerate,
+    sourceCode,
+    sourceFilePath,
+  }
+}
+
+export function getContextFilePath(samplePath) {
+  return join(dirname(samplePath), CONTEXT_FILE_NAME)
+}
+
+function buildContextContents({ sampleEntries, samplePath, sourceCode, sourceFilePath }) {
+  return [
+    `Sample path: ${samplePath}`,
+    `Source file: ${sourceFilePath}`,
+    '',
+    'Known translation keys and sample texts:',
+    JSON.stringify(sampleEntries, null, 2),
+    '',
+    'Source code:',
+    sourceCode,
+  ].join('\n')
+}
+
+function buildContextSystemInstruction() {
+  const { productContext, terminology, tone } = getTranslateRuntimeConfig()
+
+  return [
+    'You are generating translation context for a UI component.',
+    'Write a compact but informative description for translators.',
+    'Product context:',
+    productContext,
+    'Terminology:',
+    terminology,
+    'Tone:',
+    tone,
+    'Focus on:',
+    '- what the component or page does',
+    '- main user actions',
+    '- important entities and domain meaning',
+    '- what the shown strings likely refer to',
+    '- tone or UX intent if obvious',
+    'Rules:',
+    '- Return plain text only.',
+    '- Write 4 to 8 short sentences.',
+    '- Be concrete, not generic.',
+    '- Do not repeat raw code.',
+    '- Mention adult-content context only if it is actually visible in the code or strings.',
+  ].join('\n')
+}
+
+function cleanText(text) {
+  return text
+    .replace(/```text/gi, '')
+    .replace(/```/g, '')
+    .trim()
+}
+
+function detectEol(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return '\n'
+  }
+
+  const text = fs.readFileSync(filePath, 'utf-8')
+  return text.includes('\r\n') ? '\r\n' : '\n'
+}
+
+async function generateContextDescription({ sample, samplePath, sourceCode, sourceFilePath }) {
+  const sampleEntries = Object.entries(sample ?? {})
+    .slice(0, 40)
+    .map(([key, text]) => ({
+      key,
+      text,
+    }))
+  const responseText = await generateContentWithLimits({
+    apiKey: getTranslateRuntimeConfig().apiKey,
+    config: {
+      systemInstruction: buildContextSystemInstruction(),
+    },
+    contents: buildContextContents({
+      sampleEntries,
+      samplePath: relative(workspaceRoot, samplePath),
+      sourceCode: sourceCode.slice(0, SOURCE_MAX_CHARS),
+      sourceFilePath: relative(workspaceRoot, sourceFilePath),
+    }),
+    model: getTranslateRuntimeConfig().contextModel || DEFAULT_CONTEXT_MODEL,
+  })
+
+  return cleanText(responseText)
+}
+
+function longestCommonSubsequenceLength(left, right) {
+  const rows = left.length + 1
+  const cols = right.length + 1
+  const dp = Array.from({ length: rows }, () => Array(cols).fill(0))
+
+  for (let i = 1; i < rows; i++) {
+    for (let j = 1; j < cols; j++) {
+      if (left[i - 1] === right[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])
+      }
+    }
+  }
+
+  return dp[left.length][right.length]
+}
+
+function normalizeSource(source) {
+  return String(source)
+    .replace(/\r\n/g, '\n')
+    .replace(/[ \t]+$/gm, '')
+    .trim()
+}
+
+function readContextFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return null
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+  } catch {
+    return null
+  }
+}
+
+function readFloat(name, fallback) {
+  const raw = process.env[name]
+
+  if (!raw) {
+    return fallback
+  }
+
+  const value = Number.parseFloat(raw)
+  return Number.isFinite(value) && value >= 0 ? value : fallback
+}
+
+function readPositiveInt(name, fallback) {
+  const raw = process.env[name]
+
+  if (!raw) {
+    return fallback
+  }
+
+  const value = Number.parseInt(raw, 10)
+  return Number.isFinite(value) && value > 0 ? value : fallback
+}
+
+async function runCli() {
+  const rawArgs = process.argv.slice(2)
+
+  if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
+    console.log(`${buildTranslateHelp('node packages/cli/src/translate/ai-context.js')}\n\nExtra:\n  --force`)
+    process.exit(0)
+  }
+
+  const force = rawArgs.includes('--force')
+  const filteredArgs = rawArgs.filter((arg) => arg !== '--force')
+  const { options, positional } = parseTranslateRuntimeArgs(filteredArgs)
+
+  try {
+    setTranslateRuntimeConfig(options)
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error))
+    console.error('')
+    console.error(`${buildTranslateHelp('node packages/cli/src/translate/ai-context.js')}\n\nExtra:\n  --force`)
+    process.exit(1)
+  }
+
+  const sourceFiles = listWorkspaceFiles(workspaceRoot).filter(
+    (filePath) => /\.(?:js|ts|vue)$/.test(filePath) && !filePath.endsWith('.d.ts'),
+  )
+  const sampleToSource = new Map()
+
+  for (const sourceFilePath of sourceFiles) {
+    const samplePath = getTranslationPaths(sourceFilePath)?.samplePath
+
+    if (samplePath && fs.existsSync(samplePath) && !sampleToSource.has(samplePath)) {
+      sampleToSource.set(samplePath, sourceFilePath)
+    }
+  }
+
+  const targetSamplePaths =
+    positional.length > 0
+      ? positional.map((samplePath) => resolve(workspaceRoot, samplePath))
+      : [...sampleToSource.keys()].sort()
+
+  for (const samplePath of targetSamplePaths) {
+    const sourceFilePath = sampleToSource.get(samplePath)
+
+    if (!sourceFilePath || !fs.existsSync(samplePath)) {
+      continue
+    }
+
+    const description = await ensureAiContext({
+      force,
+      sample: JSON.parse(fs.readFileSync(samplePath, 'utf-8')),
+      samplePath,
+      sourceFilePath,
+    })
+
+    if (description) {
+      console.log(`🧠 Context updated: ${relative(workspaceRoot, samplePath)}`)
+    }
+  }
+}
+
+function writeTextPreservingEol(filePath, content) {
+  const eol = detectEol(filePath)
+  const normalized = String(content).replace(/\r?\n/g, eol)
+  fs.writeFileSync(filePath, normalized, 'utf-8')
+}
+
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  await runCli()
+}