@brickflow/cli 0.0.8 → 0.0.10

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @brickflow/cli
 
+## 0.0.10
+
+### Patch Changes
+
+- Remove cli upgrade
+
+## 0.0.9
+
+### Patch Changes
+
+- fix entry cd
+
 ## 0.0.8
 
 ### Patch Changes

package/index.mjs

@@ -10,10 +10,24 @@ const commandsDir = path.join(cliDir, 'src')
 async function getAvailableCommands() {
   const entries = await readdir(commandsDir, { withFileTypes: true })
 
-  return entries
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name)
-    .sort()
+  const commands = await Promise.all(
+    entries
+      .filter((entry) => entry.isDirectory())
+      .map(async (entry) => ((await hasCommandEntry(entry.name)) ? entry.name : null)),
+  )
+
+  return commands.filter(Boolean).sort()
+}
+
+async function hasCommandEntry(command) {
+  const commandEntry = path.join(commandsDir, command, 'index.js')
+
+  try {
+    await access(commandEntry)
+    return true
+  } catch {
+    return false
+  }
 }
 
 function isValidCommandName(command) {
@@ -45,14 +59,11 @@ async function runCommand(command) {
     return false
   }
 
-  const commandEntry = path.join(commandsDir, command, 'index.js')
-
-  try {
-    await access(commandEntry)
-  } catch {
+  if (!(await hasCommandEntry(command))) {
     return false
   }
 
+  const commandEntry = path.join(commandsDir, command, 'index.js')
   await import(pathToFileURL(commandEntry).href)
   return true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brickflow/cli",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "description": "",
   "type": "module",
   "main": "index.mjs",

package/src/latest/index.js

@@ -1,28 +1,36 @@
 import { exec } from 'child_process'
 import fs from 'fs'
 import { globSync } from 'glob'
-import path from 'path'
-import { fileURLToPath } from 'url'
+
+import { resolveWorkspaceRoot } from '../shared/workspace-root.js'
 
 const args = process.argv.slice(3)
+const filters = args.filter((arg) => arg !== '--help' && arg !== '-h')
 
 if (args.includes('--help') || args.includes('-h')) {
   printHelp()
   process.exit(0)
 }
 
-if (args.length > 0) {
+if (filters.some((filter) => !isValidFilter(filter))) {
   printHelp()
   process.exit(1)
 }
 
-const currentDir = path.dirname(fileURLToPath(import.meta.url))
-const workspaceRoot = path.resolve(currentDir, './')
+const workspaceRoot = resolveWorkspaceRoot()
 const packageJsonPaths = globSync('**/package.json', {
   absolute: true,
   cwd: workspaceRoot,
   ignore: ['**/node_modules/**'],
 }).sort()
+const latestVersions = await readLatestVersions(packageJsonPaths, filters)
+
+if (latestVersions.size === 0) {
+  const scopeLabel = filters.length > 0 ? ` matching "${filters.join('", "')}"` : ''
+
+  console.log(`No packages found${scopeLabel}`)
+  process.exit(0)
+}
 
 console.log('\x1b[32m', '\rPackage update')
 
@@ -37,7 +45,7 @@ for await (const packageJsonPath of packageJsonPaths) {
     }),
   )
 
-  await updateJson(packageJson)
+  updateJson(packageJson, latestVersions)
   fs.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`)
 
   const percent = Math.round((index * 100) / packageJsonPaths.length)
@@ -47,19 +55,66 @@ for await (const packageJsonPath of packageJsonPaths) {
 process.stdout.write('\n')
 console.log('\x1b[0m', '')
 
+function collectPackageNames(filePaths, packageFilters) {
+  const packageNames = new Set()
+
+  for (const filePath of filePaths) {
+    const packageJson = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+
+    for (const [dependencyName, dependencyVersion] of Object.entries(packageJson.dependencies || {})) {
+      if (shouldUpdateDependency(dependencyName, dependencyVersion, packageFilters)) {
+        packageNames.add(dependencyName)
+      }
+    }
+
+    for (const [dependencyName, dependencyVersion] of Object.entries(packageJson.devDependencies || {})) {
+      if (shouldUpdateDependency(dependencyName, dependencyVersion, packageFilters)) {
+        packageNames.add(dependencyName)
+      }
+    }
+  }
+
+  return [...packageNames].sort()
+}
+
+function escapeRegex(value) {
+  return value.replace(/[|\\{}()[\]^$+?.]/g, '\\$&')
+}
+
+function isValidFilter(value) {
+  return typeof value === 'string' && value.length > 0
+}
+
 function isWorkspaceVersion(value) {
   return value === 'workspace:*' || value === 'workspace: *'
 }
 
+function matchesAnyFilter(packageName, packageFilters) {
+  if (packageFilters.length === 0) {
+    return true
+  }
+
+  return packageFilters.some((filter) => matchesFilter(packageName, filter))
+}
+
+function matchesFilter(packageName, filter) {
+  const pattern = escapeRegex(filter).replace(/\*/g, '.*').replace(/\?/g, '.')
+
+  return new RegExp(`^${pattern}$`).test(packageName)
+}
+
 function printHelp() {
   console.log(`brick latest
 
 Usage:
   brick latest
+  brick latest "@brickflow/*"
+  brick latest "vue" "@brickflow/*"
 
   Notes:
   Scans all package.json files in the repository, including the root one
   Updates dependencies and devDependencies to the latest npm versions
+  Optional wildcard filters limit which package names are updated
   Skips workspace:* versions`)
 }
 
@@ -77,29 +132,45 @@ function readLatestVersion(packageName) {
   })
 }
 
-async function updateJson(jsonData) {
-  await Promise.all([
-    ...Object.entries(jsonData.dependencies || {}).map(async ([key, value]) => {
-      if (isWorkspaceVersion(value)) {
-        return
-      }
+async function readLatestVersions(filePaths, packageFilters) {
+  const packageNames = collectPackageNames(filePaths, packageFilters)
+  const versionsMap = new Map()
 
-      const version = await readLatestVersion(key)
+  await Promise.all(
+    packageNames.map(async (packageName) => {
+      const version = await readLatestVersion(packageName)
 
       if (version) {
-        jsonData.dependencies[key] = version
+        versionsMap.set(packageName, version)
       }
     }),
-    ...Object.entries(jsonData.devDependencies || {}).map(async ([key, value]) => {
-      if (isWorkspaceVersion(value)) {
-        return
-      }
+  )
 
-      const version = await readLatestVersion(key)
+  return versionsMap
+}
 
-      if (version) {
-        jsonData.devDependencies[key] = version
-      }
-    }),
-  ])
+function shouldUpdateDependency(packageName, version, packageFilters) {
+  return !isWorkspaceVersion(version) && matchesAnyFilter(packageName, packageFilters)
+}
+
+function updateJson(jsonData, versionsMap) {
+  for (const [dependencyName, version] of Object.entries(jsonData.dependencies || {})) {
+    if (isWorkspaceVersion(version)) {
+      continue
+    }
+
+    if (versionsMap.has(dependencyName)) {
+      jsonData.dependencies[dependencyName] = versionsMap.get(dependencyName)
+    }
+  }
+
+  for (const [dependencyName, version] of Object.entries(jsonData.devDependencies || {})) {
+    if (isWorkspaceVersion(version)) {
+      continue
+    }
+
+    if (versionsMap.has(dependencyName)) {
+      jsonData.devDependencies[dependencyName] = versionsMap.get(dependencyName)
+    }
+  }
 }

package/src/shared/workspace-root.js

@@ -0,0 +1,31 @@
+import fs from 'fs'
+import path from 'path'
+
+const WORKSPACE_MARKERS = ['.git', 'pnpm-workspace.yaml', 'lerna.json', 'turbo.json']
+
+export function resolveWorkspaceRoot(startDir = process.cwd()) {
+  let currentDir = path.resolve(startDir)
+  let packageRoot = null
+
+  while (true) {
+    if (hasAnyFile(currentDir, WORKSPACE_MARKERS)) {
+      return currentDir
+    }
+
+    if (fs.existsSync(path.join(currentDir, 'package.json'))) {
+      packageRoot = currentDir
+    }
+
+    const parentDir = path.dirname(currentDir)
+
+    if (parentDir === currentDir) {
+      return packageRoot || startDir
+    }
+
+    currentDir = parentDir
+  }
+}
+
+function hasAnyFile(directoryPath, fileNames) {
+  return fileNames.some((fileName) => fs.existsSync(path.join(directoryPath, fileName)))
+}

package/src/translate/ai-context.js

@@ -20,6 +20,10 @@ 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 buildAiContextHelp(command = 'brick translate-context') {
+  return `${buildTranslateHelp(command)}\n\nExtra:\n  --force`
+}
+
 export function calculateChangeRatio(previousSource, nextSource) {
   const before = normalizeSource(previousSource)
   const after = normalizeSource(nextSource)
@@ -112,6 +116,52 @@ export function getContextFilePath(samplePath) {
   return join(dirname(samplePath), CONTEXT_FILE_NAME)
 }
 
+export async function runAiContextCli(rawArgs = process.argv.slice(3), command = 'brick translate-context') {
+  const helpText = buildAiContextHelp(command)
+
+  if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
+    console.log(helpText)
+    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(helpText)
+    process.exit(1)
+  }
+
+  const targets = listTranslationTargets(workspaceRoot)
+  const requestedSamplePaths =
+    positional.length > 0 ? new Set(positional.map((samplePath) => resolve(workspaceRoot, samplePath))) : null
+  const targetEntries = requestedSamplePaths
+    ? targets.filter(({ samplePath }) => requestedSamplePaths.has(samplePath))
+    : targets
+
+  for (const { samplePath, sourceFilePath } of targetEntries) {
+    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 buildContextContents({ sampleEntries, samplePath, sourceCode, sourceFilePath }) {
   return [
     `Sample path: ${samplePath}`,
@@ -251,56 +301,6 @@ function readPositiveInt(name, fallback) {
   return Number.isFinite(value) && value > 0 ? value : fallback
 }
 
-export function buildAiContextHelp(command = 'brick translate-context') {
-  return `${buildTranslateHelp(command)}\n\nExtra:\n  --force`
-}
-
-export async function runAiContextCli(rawArgs = process.argv.slice(3), command = 'brick translate-context') {
-  const helpText = buildAiContextHelp(command)
-
-  if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
-    console.log(helpText)
-    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(helpText)
-    process.exit(1)
-  }
-
-  const targets = listTranslationTargets(workspaceRoot)
-  const requestedSamplePaths =
-    positional.length > 0 ? new Set(positional.map((samplePath) => resolve(workspaceRoot, samplePath))) : null
-  const targetEntries = requestedSamplePaths
-    ? targets.filter(({ samplePath }) => requestedSamplePaths.has(samplePath))
-    : targets
-
-  for (const { samplePath, sourceFilePath } of targetEntries) {
-    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)

package/src/translate/utils.js

@@ -235,28 +235,6 @@ export function getTranslationPaths(id) {
   }
 }
 
-export function listWorkspaceFiles(workspaceRoot) {
-  try {
-    const output = execFileSync('git', ['ls-files', '-co', '--exclude-standard', '-z'], {
-      cwd: workspaceRoot,
-      encoding: 'utf-8',
-    })
-
-    return output
-      .split('\0')
-      .filter(Boolean)
-      .map((file) => resolve(workspaceRoot, file))
-      .filter((filePath) => existsSync(filePath))
-  } catch {
-    return globSync('**/*', {
-      absolute: true,
-      cwd: workspaceRoot,
-      ignore: IGNORED_GLOB_PATTERNS,
-      nodir: true,
-    })
-  }
-}
-
 export function listTranslationSamplePaths(workspaceRoot) {
   return globSync(TRANSLATION_SAMPLE_GLOB, {
     absolute: true,
@@ -286,6 +264,28 @@ export function listTranslationTargets(workspaceRoot) {
   }))
 }
 
+export function listWorkspaceFiles(workspaceRoot) {
+  try {
+    const output = execFileSync('git', ['ls-files', '-co', '--exclude-standard', '-z'], {
+      cwd: workspaceRoot,
+      encoding: 'utf-8',
+    })
+
+    return output
+      .split('\0')
+      .filter(Boolean)
+      .map((file) => resolve(workspaceRoot, file))
+      .filter((filePath) => existsSync(filePath))
+  } catch {
+    return globSync('**/*', {
+      absolute: true,
+      cwd: workspaceRoot,
+      ignore: IGNORED_GLOB_PATTERNS,
+      nodir: true,
+    })
+  }
+}
+
 export function normalize(input) {
   return input.trim().toLowerCase().replace(/\s+/g, ' ')
 }

package/src/upgrade/index.js

@@ -1,168 +0,0 @@
-import { exec } from 'child_process'
-import fs from 'fs'
-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 = findPackageJsonPaths()
-const localPackageNames = collectLocalBrickflowPackageNames(packageJsonPaths)
-
-if (localPackageNames.length === 0) {
-  console.log('No local @brickflow/* packages found in the repository')
-  process.exit(0)
-}
-
-const latestVersions = new Map()
-
-for (const packageName of localPackageNames) {
-  const version = await readLatestVersion(packageName)
-
-  if (version) {
-    latestVersions.set(packageName, version)
-  }
-}
-
-if (latestVersions.size === 0) {
-  throw new Error('Could not resolve latest versions for local @brickflow/* packages')
-}
-
-console.log('\x1b[32m', '\rBrickflow package upgrade')
-
-let changedFiles = 0
-let index = 0
-
-for (const packageJsonPath of packageJsonPaths) {
-  index += 1
-
-  const packageJson = readJson(packageJsonPath)
-  const before = JSON.stringify(packageJson)
-
-  updateDependencySections(packageJson, latestVersions)
-
-  if (JSON.stringify(packageJson) !== before) {
-    writeJson(packageJsonPath, packageJson)
-    changedFiles += 1
-    console.log(`\n📦 Updated ${getPackageLabel(packageJsonPath)}`)
-  }
-
-  const percent = Math.round((index * 100) / packageJsonPaths.length)
-  process.stdout.write(`\r🔩 Upgrade: [${'█'.repeat(Math.round(percent / 10)).padEnd(10, ' ')}] ${percent}%`)
-}
-
-process.stdout.write('\n')
-console.log(`Updated ${changedFiles} package.json file(s)`)
-console.log('\x1b[0m', '')
-
-function collectLocalBrickflowPackageNames(filePaths) {
-  return filePaths
-    .map((filePath) => readJson(filePath).name)
-    .filter((packageName) => isBrickflowPackageName(packageName))
-    .sort()
-}
-
-function findPackageJsonPaths() {
-  return walkDirectoryForPackageJson(workspaceRoot).sort()
-}
-
-function getDependencySections(packageJson) {
-  return ['dependencies', 'devDependencies', 'peerDependencies', 'optionalDependencies']
-    .map((sectionName) => ({
-      name: sectionName,
-      value: packageJson[sectionName],
-    }))
-    .filter((section) => section.value && typeof section.value === 'object')
-}
-
-function getPackageLabel(packageJsonPath) {
-  const relativePath = path.relative(workspaceRoot, packageJsonPath).replace(/\\/g, '/')
-  const packageDir = path.dirname(relativePath)
-
-  return packageDir === '.' ? 'root' : packageDir
-}
-
-function isBrickflowPackageName(packageName) {
-  return typeof packageName === 'string' && packageName.startsWith('@brickflow/')
-}
-
-function printHelp() {
-  console.log(`brick upgrade
-
-Usage:
-  brick upgrade
-
-Notes:
-  Finds local @brickflow/* package names from package.json files in the repository
-  Fetches the latest published version for each of those packages
-  Updates matching dependencies, devDependencies, peerDependencies and optionalDependencies in all package.json files`)
-}
-
-function readJson(filePath) {
-  return JSON.parse(fs.readFileSync(filePath, 'utf8'))
-}
-
-function readLatestVersion(packageName) {
-  return new Promise((resolve) => {
-    exec(`npm view ${packageName} version`, (error, stdout) => {
-      if (error) {
-        console.warn(`Skipping ${packageName}: ${error.message}`)
-        resolve(null)
-        return
-      }
-
-      resolve(String(stdout).trim().replace('\n', ''))
-    })
-  })
-}
-
-function updateDependencySections(packageJson, latestVersionsMap) {
-  for (const section of getDependencySections(packageJson)) {
-    for (const dependencyName of Object.keys(section.value)) {
-      const latestVersion = latestVersionsMap.get(dependencyName)
-
-      if (latestVersion) {
-        section.value[dependencyName] = latestVersion
-      }
-    }
-  }
-}
-
-function writeJson(filePath, value) {
-  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`)
-}
-
-function walkDirectoryForPackageJson(directoryPath) {
-  const entries = fs.readdirSync(directoryPath, { withFileTypes: true })
-  const filePaths = []
-
-  for (const entry of entries) {
-    if (entry.name === 'node_modules') {
-      continue
-    }
-
-    const entryPath = path.join(directoryPath, entry.name)
-
-    if (entry.isDirectory()) {
-      filePaths.push(...walkDirectoryForPackageJson(entryPath))
-      continue
-    }
-
-    if (entry.isFile() && entry.name === 'package.json') {
-      filePaths.push(entryPath)
-    }
-  }
-
-  return filePaths
-}