@drone1/alt 1.1.1 → 1.1.3

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "enableAllProjectMcpServers": false,
+  "permissions": {
+    "allow": [
+      "Bash(npm run test:mock:*)"
+    ]
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@drone1/alt",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "An AI-powered localization tool",
   "main": "src/index.mjs",
   "bin": {
@@ -10,7 +10,6 @@
   "scripts": {
     "test": "ALT_TEST=1 mocha",
     "test:targeted": "ALT_TEST=1 mocha --grep 'multiple target'",
-    "test": "ALT_TEST=1 mocha",
     "test:coverage": "ALT_TEST=1 nyc mocha",
     "localize-display-strings": "./alt.mjs",
     "print-all-help": "rm -f help.txt && (./alt.mjs help && echo -e '\n---\n' && ./alt.mjs help translate && echo -e '\n---\n' && ./alt.mjs help list-models) > help.txt",

package/src/commands/prune.js

@@ -0,0 +1,156 @@
+import * as path from 'path'
+import { localize, localizeFormatted } from '../localizer/localize.js'
+import { readJsonFile, writeJsonFile, normalizeOutputPath } from '../lib/io.js'
+import { loadConfig } from '../lib/config.js'
+import { loadReferenceFile } from '../lib/reference-loader.js'
+import { assertIsObj } from '../lib/assert.js'
+import { shutdown } from '../shutdown.js'
+
+export async function runPrune({ appState, options, log }) {
+	let exitCode = 0
+	try {
+		// Load config
+		const config = await loadConfig({
+			configFile: options.configFile,
+			log
+		})
+		assertIsObj(config)
+
+		const referenceFile = options.referenceFile ?? config.referenceFile
+		if (!referenceFile?.length) {
+			throw new Error(
+				localize({
+					token: 'error-no-reference-file-specified',
+					lang: appState.lang,
+					log
+				})
+			)
+		}
+		log.D(`referenceFile=${referenceFile}`)
+
+		// Load reference file
+		const refFileDir = path.dirname(referenceFile)
+		const outputDir = path.resolve(options.outputDir ?? config.outputDir ?? refFileDir)
+		log.D(`outputDir=${outputDir}`)
+
+		// Create a tmp dir for storing the .mjs reference file
+		const { mkTmpDir } = await import('../lib/io.js')
+		const tmpDir = await mkTmpDir()
+		appState.tmpDir = tmpDir
+
+		// Resolve referenceExportedVarName
+		let referenceExportedVarName
+		const { getFileExtension } = await import('../lib/utils.js')
+		const referenceFileExt = getFileExtension(referenceFile)
+		if (['js','mjs'].includes(referenceFileExt)) {
+			log.D(`Searching for reference exported var name for .${referenceFileExt} extension...`)
+			if (options.referenceExportedVarName?.length) {
+				log.D(`Found reference exported var name via --reference-exported-var-name`)
+				referenceExportedVarName = options.referenceExportedVarName
+			} else if (config.referenceExportedVarName?.length) {
+				log.D(`Found reference exported var name in config, via 'referenceExportedVarName'`)
+				referenceExportedVarName = config.referenceExportedVarName
+			}
+		}
+		log.D(`referenceExportedVarName=${referenceExportedVarName}`)
+
+		// Load reference data
+		const referenceData = await loadReferenceFile({
+			appLang: appState.lang,
+			referenceFile,
+			referenceExportedVarName,
+			tmpDir,
+			log
+		})
+
+		if (!referenceData) {
+			throw new Error(
+				localizeFormatted({
+					token: 'error-no-reference-data-in-variable',
+					data: {
+						referenceExportedVarName,
+						referenceFile,
+					},
+					lang: appState.lang,
+					log
+				})
+			)
+		}
+
+		const referenceKeys = new Set(Object.keys(referenceData))
+		log.V(`Reference file contains ${referenceKeys.size} keys`)
+
+		// Get target languages
+		const targetLanguages = options.targetLanguages || config.targetLanguages
+		if (!targetLanguages || !targetLanguages.length) {
+			throw new Error(
+				localize({ token: 'error-no-target-languages', lang: appState.lang, log })
+			)
+		}
+
+		const normalizeOutputFilenames = options.normalizeOutputFilenames || config.normalizeOutputFilenames
+
+		let totalKeysRemoved = 0
+		let filesModified = 0
+
+		// Process each target language file
+		for (const targetLang of targetLanguages) {
+			const outputFilePath = normalizeOutputPath({
+				dir: outputDir,
+				filename: `${targetLang}.json`,
+				normalize: normalizeOutputFilenames
+			})
+			log.D(`Processing ${outputFilePath}...`)
+
+			// Read existing output data
+			const outputData = await readJsonFile(outputFilePath)
+			if (!outputData) {
+				log.V(`File ${outputFilePath} does not exist, skipping...`)
+				continue
+			}
+
+			const keysToRemove = []
+			for (const key of Object.keys(outputData)) {
+				if (!referenceKeys.has(key)) {
+					keysToRemove.push(key)
+				}
+			}
+
+			if (keysToRemove.length > 0) {
+				log.I(`Found ${keysToRemove.length} obsolete key(s) in ${targetLang}.json:`)
+				keysToRemove.forEach(key => {
+					log.I(`  - ${key}`)
+					delete outputData[key]
+				})
+
+				// Write the pruned file
+				if (!options.dryRun) {
+					writeJsonFile(outputFilePath, outputData, log)
+					log.V(`Wrote ${outputFilePath}`)
+					filesModified++
+				}
+				totalKeysRemoved += keysToRemove.length
+			} else {
+				log.V(`No obsolete keys found in ${targetLang}.json`)
+			}
+		}
+
+		if (options.dryRun) {
+			log.I(`\nDry run complete. Would have removed ${totalKeysRemoved} key(s) from ${filesModified} file(s).`)
+		} else if (totalKeysRemoved > 0) {
+			log.I(`\nRemoved ${totalKeysRemoved} obsolete key(s) from ${filesModified} file(s).`)
+		} else {
+			log.I(`\nNo obsolete keys found. All target files are up to date.`)
+		}
+
+	} catch (error) {
+		log.E(error)
+		exitCode = 2
+	}
+
+	await shutdown(appState, false)
+
+	if (exitCode > 0) {
+		process.exit(exitCode)
+	}
+}

package/src/commands/translate.js

@@ -366,6 +366,11 @@ export async function runTranslation({ appState, options, log }) {
 			log.T(taskInfo)
 			const progress = 100 * Math.floor(100 * taskInfoIdx / totalTasks) / 100
 
+      // Broadcast progress for CI
+      if (process.env.CI) {
+          console.log(`::notice::${progress}% - ${taskInfo.targetLang}/${taskInfo.key}`)
+      }
+
 			await new Listr([
 				{
 					title: localizeFormatted({

package/src/main.mjs

@@ -15,6 +15,7 @@ import { keyList, languageList } from './lib/options.js'
 import { runTranslation } from './commands/translate.js'
 import { registerSignalHandlers } from './shutdown.js'
 import { runListModels } from './commands/list-models.js'
+import { runPrune } from './commands/prune.js'
 
 const __dirname = path.dirname(
 	fileURLToPath(import.meta.url)
@@ -99,6 +100,10 @@ export async function run() {
 				case 'list-models':
 					await runListModels({ appState, options, log })
 					break
+
+				case 'prune':
+					await runPrune({ appState, options, log })
+					break
 			}
 		}
 
@@ -145,6 +150,23 @@ export async function run() {
 				.action(runCommand)
 		})
 
+		program
+			.command('prune')
+			.description('Remove keys from target files that no longer exist in the reference file')
+			.option('-c, --config-file <path>', `Path to config file; defaults to "${DEFAULT_CONFIG_FILENAME}" in the current working directory if not specified`)
+			.option('-r, --reference-file <path>', `Path to reference file of source strings. This file can be in .js, .mjs, .json, or .jsonc formats; overrides any 'referenceFile' config setting`)
+			.option('-o, --output-dir <path>', `Output directory for localized files; overrides any 'outputDir' config setting`)
+			.option('-tl, --target-languages <list>', `Comma-separated list of language codes; overrides any 'targetLanguages' config setting`, value => languageList(value, log))
+			.option('-R, --reference-exported-var-name <var name>', `For .js or .mjs reference files only, this will be the exported variable, e.g. for 'export default = {...}' you'd use 'default' here, or 'data' for 'export const data = { ... }'. For .json or .jsonc reference files, this value is ignored.`, 'default')
+			.option('-n, --normalize-output-filenames', `Normalizes output filenames (to all lower-case); overrides any 'normalizeOutputFilenames' in config setting`, false)
+			.option('--dry-run', 'Show what would be removed without actually modifying files', false)
+			.option('-N, --no-logo', `Suppress logo printout`, true)  // NB: maps to options.logo, not options.noLogo
+			.option('-v, --verbose', `Enables verbose spew`, false)
+			.option('-d, --debug', `Enables debug spew`, false)
+			.option('-t, --trace', `Enables trace spew`, false)
+			.option('--dev', `Enable dev mode, which prints stack traces with errors`, false)
+			.action(runCommand)
+
 		program.parse(process.argv)
 	} catch (error) {
 		log.E(error)

package/test/common.mjs

@@ -23,7 +23,7 @@ export function cleanupFile(file) {
 
 export function cleanupDir(dir) {
 	if (!fs.existsSync(dir)) return
-	fs.rmdirSync(dir, { recursive: true })
+	fs.rmSync(dir, { recursive: true, force: true })
 }
 
 

package/test/prune-command.test.js

@@ -0,0 +1,320 @@
+import { execa } from 'execa'
+import { expect } from 'chai'
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { dirname } from 'path'
+import crypto from 'crypto'
+import { SRC_DATA_DIR, cleanupFile, cleanupCacheFile } from './common.mjs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+describe('prune command', () => {
+	it('should remove obsolete keys from target files', async function() {
+		this.timeout(10000)
+
+		// Generate a random ID for the reference file
+		const randomId = crypto.randomBytes(4).toString('hex')
+		const refFileName = `ref-${randomId}.json`
+		const refFilePath = path.join(SRC_DATA_DIR, refFileName)
+
+		try {
+			// Create a reference file with only 2 keys
+			const referenceData = {
+				'msg-test': 'Nothing to do',
+				'error-finished': 'Finished with %%errorsEncountered%% error%%s%%'
+			}
+			fs.writeFileSync(refFilePath, JSON.stringify(referenceData, null, 2), 'utf8')
+
+			// Create a target file with 3 keys (one obsolete)
+			const targetFilePath = path.join(SRC_DATA_DIR, 'fr-FR.json')
+			const targetData = {
+				'msg-test': 'Rien à faire',
+				'error-finished': 'Terminé avec %%errorsEncountered%% erreur%%s%%',
+				'obsolete-key': 'This should be removed'
+			}
+			fs.writeFileSync(targetFilePath, JSON.stringify(targetData, null, 2), 'utf8')
+
+			// Run the prune command
+			const result = await execa('node', [
+				path.resolve(__dirname, '../alt.mjs'),
+				'prune',
+				'-r',
+				refFilePath,
+				'-tl',
+				'fr-FR',
+				'-d'
+			], {
+				cwd: 'test'
+			})
+
+			// Check command executed successfully
+			expect(result.exitCode).to.equal(0)
+
+			// Verify the target file was pruned
+			const prunedContent = JSON.parse(fs.readFileSync(targetFilePath, 'utf8'))
+			expect(prunedContent).to.have.property('msg-test')
+			expect(prunedContent).to.have.property('error-finished')
+			expect(prunedContent).to.not.have.property('obsolete-key')
+
+			// Clean up
+			cleanupFile(targetFilePath)
+		} finally {
+			cleanupFile(refFilePath)
+		}
+	})
+
+	it('should handle multiple target languages', async function() {
+		this.timeout(10000)
+
+		const randomId = crypto.randomBytes(4).toString('hex')
+		const refFileName = `ref-${randomId}.json`
+		const refFilePath = path.join(SRC_DATA_DIR, refFileName)
+
+		try {
+			// Create reference file
+			const referenceData = {
+				'msg-test': 'Nothing to do'
+			}
+			fs.writeFileSync(refFilePath, JSON.stringify(referenceData, null, 2), 'utf8')
+
+			// Create multiple target files with obsolete keys
+			const frFilePath = path.join(SRC_DATA_DIR, 'fr-FR.json')
+			const esFilePath = path.join(SRC_DATA_DIR, 'es-ES.json')
+
+			const frData = {
+				'msg-test': 'Rien à faire',
+				'obsolete-fr': 'Obsolete French key'
+			}
+			const esData = {
+				'msg-test': 'Nada que hacer',
+				'obsolete-es': 'Obsolete Spanish key'
+			}
+
+			fs.writeFileSync(frFilePath, JSON.stringify(frData, null, 2), 'utf8')
+			fs.writeFileSync(esFilePath, JSON.stringify(esData, null, 2), 'utf8')
+
+			// Run the prune command
+			const result = await execa('node', [
+				path.resolve(__dirname, '../alt.mjs'),
+				'prune',
+				'-r',
+				refFilePath,
+				'-tl',
+				'fr-FR,es-ES'
+			], {
+				cwd: 'test'
+			})
+
+			// Check command executed successfully
+			expect(result.exitCode).to.equal(0)
+
+			// Verify both files were pruned
+			const prunedFrContent = JSON.parse(fs.readFileSync(frFilePath, 'utf8'))
+			const prunedEsContent = JSON.parse(fs.readFileSync(esFilePath, 'utf8'))
+
+			expect(prunedFrContent).to.have.property('msg-test')
+			expect(prunedFrContent).to.not.have.property('obsolete-fr')
+
+			expect(prunedEsContent).to.have.property('msg-test')
+			expect(prunedEsContent).to.not.have.property('obsolete-es')
+
+			// Clean up
+			cleanupFile(frFilePath)
+			cleanupFile(esFilePath)
+		} finally {
+			cleanupFile(refFilePath)
+		}
+	})
+
+	it('should support dry-run mode without modifying files', async function() {
+		this.timeout(10000)
+
+		const randomId = crypto.randomBytes(4).toString('hex')
+		const refFileName = `ref-${randomId}.json`
+		const refFilePath = path.join(SRC_DATA_DIR, refFileName)
+
+		try {
+			// Create reference file with 1 key
+			const referenceData = {
+				'msg-test': 'Nothing to do'
+			}
+			fs.writeFileSync(refFilePath, JSON.stringify(referenceData, null, 2), 'utf8')
+
+			// Create target file with 2 keys (one obsolete)
+			const targetFilePath = path.join(SRC_DATA_DIR, 'fr-FR.json')
+			const targetData = {
+				'msg-test': 'Rien à faire',
+				'obsolete-key': 'This should NOT be removed in dry-run'
+			}
+			fs.writeFileSync(targetFilePath, JSON.stringify(targetData, null, 2), 'utf8')
+
+			// Run the prune command with --dry-run
+			const result = await execa('node', [
+				path.resolve(__dirname, '../alt.mjs'),
+				'prune',
+				'-r',
+				refFilePath,
+				'-tl',
+				'fr-FR',
+				'--dry-run'
+			], {
+				cwd: 'test'
+			})
+
+			// Check command executed successfully
+			expect(result.exitCode).to.equal(0)
+
+			// Verify the target file was NOT modified
+			const unchangedContent = JSON.parse(fs.readFileSync(targetFilePath, 'utf8'))
+			expect(unchangedContent).to.have.property('msg-test')
+			expect(unchangedContent).to.have.property('obsolete-key', 'This should NOT be removed in dry-run')
+
+			// Clean up
+			cleanupFile(targetFilePath)
+		} finally {
+			cleanupFile(refFilePath)
+		}
+	})
+
+	it('should handle non-existent target files gracefully', async function() {
+		this.timeout(10000)
+
+		const randomId = crypto.randomBytes(4).toString('hex')
+		const refFileName = `ref-${randomId}.json`
+		const refFilePath = path.join(SRC_DATA_DIR, refFileName)
+
+		try {
+			// Create reference file
+			const referenceData = {
+				'msg-test': 'Nothing to do'
+			}
+			fs.writeFileSync(refFilePath, JSON.stringify(referenceData, null, 2), 'utf8')
+
+			// Don't create any target files
+
+			// Run the prune command
+			const result = await execa('node', [
+				path.resolve(__dirname, '../alt.mjs'),
+				'prune',
+				'-r',
+				refFilePath,
+				'-tl',
+				'fr-FR'
+			], {
+				cwd: 'test'
+			})
+
+			// Check command executed successfully
+			expect(result.exitCode).to.equal(0)
+		} finally {
+			cleanupFile(refFilePath)
+		}
+	})
+
+	it('should keep all keys when no obsolete keys exist', async function() {
+		this.timeout(10000)
+
+		const randomId = crypto.randomBytes(4).toString('hex')
+		const refFileName = `ref-${randomId}.json`
+		const refFilePath = path.join(SRC_DATA_DIR, refFileName)
+
+		try {
+			// Create reference file with 2 keys
+			const referenceData = {
+				'msg-test': 'Nothing to do',
+				'error-finished': 'Finished with %%errorsEncountered%% error%%s%%'
+			}
+			fs.writeFileSync(refFilePath, JSON.stringify(referenceData, null, 2), 'utf8')
+
+			// Create target file with same keys (no obsolete keys)
+			const targetFilePath = path.join(SRC_DATA_DIR, 'fr-FR.json')
+			const targetData = {
+				'msg-test': 'Rien à faire',
+				'error-finished': 'Terminé avec %%errorsEncountered%% erreur%%s%%'
+			}
+			fs.writeFileSync(targetFilePath, JSON.stringify(targetData, null, 2), 'utf8')
+
+			// Run the prune command
+			const result = await execa('node', [
+				path.resolve(__dirname, '../alt.mjs'),
+				'prune',
+				'-r',
+				refFilePath,
+				'-tl',
+				'fr-FR'
+			], {
+				cwd: 'test'
+			})
+
+			// Check command executed successfully
+			expect(result.exitCode).to.equal(0)
+
+			// Verify all keys are still present
+			const unchangedContent = JSON.parse(fs.readFileSync(targetFilePath, 'utf8'))
+			expect(unchangedContent).to.have.property('msg-test')
+			expect(unchangedContent).to.have.property('error-finished')
+			expect(Object.keys(unchangedContent).length).to.equal(2)
+
+			// Clean up
+			cleanupFile(targetFilePath)
+		} finally {
+			cleanupFile(refFilePath)
+		}
+	})
+
+	it('should work with .js reference files', async function() {
+		this.timeout(10000)
+
+		const randomId = crypto.randomBytes(4).toString('hex')
+		const refFileName = `ref-${randomId}.js`
+		const refFilePath = path.join(SRC_DATA_DIR, refFileName)
+
+		try {
+			// Create a .js reference file
+			const refContent = `export default {
+	'msg-test': 'Nothing to do',
+	'error-finished': 'Finished with errors'
+}`
+			fs.writeFileSync(refFilePath, refContent, 'utf8')
+
+			// Create target file with an obsolete key
+			const targetFilePath = path.join(SRC_DATA_DIR, 'fr-FR.json')
+			const targetData = {
+				'msg-test': 'Rien à faire',
+				'error-finished': 'Terminé avec erreurs',
+				'obsolete-key': 'Should be removed'
+			}
+			fs.writeFileSync(targetFilePath, JSON.stringify(targetData, null, 2), 'utf8')
+
+			// Run the prune command
+			const result = await execa('node', [
+				path.resolve(__dirname, '../alt.mjs'),
+				'prune',
+				'-r',
+				refFilePath,
+				'-tl',
+				'fr-FR',
+				'-R',
+				'default'
+			], {
+				cwd: 'test'
+			})
+
+			// Check command executed successfully
+			expect(result.exitCode).to.equal(0)
+
+			// Verify the obsolete key was removed
+			const prunedContent = JSON.parse(fs.readFileSync(targetFilePath, 'utf8'))
+			expect(prunedContent).to.have.property('msg-test')
+			expect(prunedContent).to.have.property('error-finished')
+			expect(prunedContent).to.not.have.property('obsolete-key')
+
+			// Clean up
+			cleanupFile(targetFilePath)
+		} finally {
+			cleanupFile(refFilePath)
+		}
+	})
+})