wp-advads 1.0.34 → 1.0.36

package/README.md

@@ -1,139 +1,158 @@
-# wp-advads Scaffolding Tool
-
-
-
+# wp-advads
 
 [![npm version](https://img.shields.io/npm/v/wp-advads.svg)](https://www.npmjs.com/package/wp-advads)
 [![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](LICENSE)
 
-<p align="center">
-	<img src="https://img.icons8.com/nolan/256/wordpress.png"/>
-</p>
+CLI scaffolding for an **existing** Advanced Ads WordPress plugin. It writes `wp.advads` and file stubs (`class`, `view`, `updates`, `js`, `css`). It does not generate a plugin from scratch.
 
-## 📃 Introduction
+Requires **Node.js 18+**. Created by [Shakeeb Ahmed](https://github.com/meshakeeb).
 
-CLI tools to streamline development tasks for the Advanced Ads WordPress plugin.
-Created by [Shakeeb Ahmed](https://github.com/meshakeeb)
+## Installation
 
-## 📦 Installation
-Use via npx:
 ```bash
 npx wp-advads
 ```
 
-## 🚀  Usage
-Run the CLI using:
 ```bash
 npx wp-advads <command> [options]
 ```
 
-## 🔧 Commands
+## Config
+
+Commands (except `init`) need a `wp.advads` file. The CLI uses the nearest ancestor that already has one. `init` writes `wp.advads` in the current directory.
+
+If the file is missing, the CLI exits and tells you to run `wp-advads init`. It does not prompt.
+
+## Commands
 
 #### `init`
-Initializes a new project configuration file.
+
+Creates `wp.advads` in the current directory.
+
 ```bash
 npx wp-advads init
 ```
 
-`wp.advads` lives in the nearest ancestor directory that already has that file. `init` creates it in the current directory.
+#### `build`
+
+Installs PHP dependencies into `packages/` (`COMPOSER_VENDOR_DIR=packages`), dumps the autoloader, runs `npm run build` when `package.json` has a `scripts.build`, then generates a `.pot`.
+
+```bash
+npx wp-advads build
+```
+
+Standalone `build` does not touch release git messages. During `release`, commit bullets are passed in explicitly.
 
 #### `release`
-Creates a new release for the plugin.
+
+Bumps the version, changelog, translations, build, and git (explicit file list, hooks run). Stops on the first failed step.
+
 ```bash
 npx wp-advads release
 ```
 
-
 #### `class <classname> [options]`
-Creates a new PHP class file with optional templates.
+
+Writes a PHP class under `paths.php`. Combine `--heading` with a template flag (`-i` / `-g` / `-r` / `-s`).
+
 ```bash
 npx wp-advads class MyClass --heading "Class Heading" --description "Description" -s
 ```
 
-##### Required Argument:
-- `<classname>` – The name of the class.
-
-##### Optional Argument:
+- `<classname>` – Class name (namespaces with `\`, e.g. `Foo\Bar`)
 - `--heading <heading>` – File heading
 - `--description <description>` – File description
-- `-i` – Initializer interface
-- `-g` – Integration interface
-- `-r` – REST interface
-- `-s` – Singleton class
-
+- `-i` – Initializer
+- `-g` – Integration
+- `-r` – REST
+- `-s` – Singleton (`__construct` is private)
+- `--force` – Overwrite if the file exists
 
 #### `view <viewname> [heading]`
-Creates a new view file (e.g. template partial).
+
+Writes a PHP view under `paths.views`. Nested names accept `/` or `\`.
+
 ```bash
 npx wp-advads view sidebar "Sidebar View"
+npx wp-advads view admin/settings
 ```
 
-##### Required Argument:
-- `<viewname>` – Name of the view file.
+- `<viewname>` – View file name
+- `[heading]` – Heading comment
+- `--force` – Overwrite if the file exists
 
-##### Optional Argument:
-- `[heading]` – A heading comment added to the view file.
+#### `updates <version>`
 
+Writes an upgrade file under `paths.updates`. `misc.prefix` from `wp.advads` is required (empty prefix is an error).
 
-#### `updates <version>`
-Creates update logic for the given plugin version.
 ```bash
 npx wp-advads updates 1.2.3
 ```
 
-##### Required Argument:
-- `<version>` – Target version number (e.g. `1.2.0`)
+- `<version>` – Target version (e.g. `1.2.3`)
+- `--force` – Overwrite if the file exists
 
 #### `js <filename> [options]`
-Creates a new JavaScript file.
+
+Writes a JavaScript file under `paths.javascript`. Nested names accept `/` or `\`.
+
 ```bash
 npx wp-advads js script -h "Main JS" -d "Handles the frontend logic"
 ```
 
-##### Required Argument:
-- `<filename>` – Name of the JavaScript file (without extension).
+- `<filename>` – Name without extension
+- `-h <heading>` – Heading comment
+- `-d <description>` – Description comment
+- `--force` – Overwrite if the file exists
 
-##### Optional Argument:
-- `-h <heading>` – Heading comment for the file.
-- `-d <description>` – Description comment for the file.
+#### `css <filename> [options]`
 
+Writes a CSS file under `paths.css`. Nested names accept `/` or `\`.
 
-#### `css <filename> [options]`
-Creates a new CSS file.
 ```bash
 npx wp-advads css styles -h "Main CSS" -d "Plugin styles"
 ```
 
-##### Required Argument:
-- `<filename>` – Name of the CSS file (without extension).
-
-##### Optional Argument:
-- `-h <heading>` – Heading comment for the file.
-- `-d <description>` – Description comment for the file.
+- `<filename>` – Name without extension
+- `-h <heading>` – Heading comment
+- `-d <description>` – Description comment
+- `--force` – Overwrite if the file exists
 
 #### `pot`
-Generates a `.pot` translation template.
+
+Creates a `.pot` translation template (`wp i18n make-pot`).
+
 ```bash
 npx wp-advads pot
 ```
 
+POT headers (`Last-Translator`, `Language-Team`) use `author.name` and `author.email` from `wp.advads`.
+
 #### `translations`
-Downloads translation files from GlotPress.
+
+Downloads `.po` / `.mo` files from GlotPress into `glotpress.destination` (default `./languages/`). Locale ids must be `[a-zA-Z0-9_]+`; non-OK HTTP responses are skipped.
+
 ```bash
 npx wp-advads translations
 ```
 
-### ⚠️ Notes
-A config file is required for all commands **except** init.
+## Notes
+
+`class`, `view`, `updates`, `js`, and `css` will not overwrite an existing file unless you pass `--force`. Writes cannot escape the project root.
+
+## Tests
+
+```bash
+npm test
+```
 
-If one is missing, you'll be prompted to create it with `wp-advads init`.
+That runs `node --experimental-test-module-mocks --test`. Node 18+ is required (`engines.node`).
 
-`class`, `view`, `updates`, `js`, and `css` will not overwrite an existing file unless you pass `--force`.
+## Author
 
-### 👤 Author
-Shakeeb Ahmed
-GitHub: [@meshakeeb](http://github.com/meshakeeb)
+Shakeeb Ahmed  
+GitHub: [@meshakeeb](https://github.com/meshakeeb)
 
-### 📖 Changelog
+## Changelog
 
-[See the changelog file](./CHANGELOG.md)
+[CHANGELOG.md](./CHANGELOG.md)

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "wp-advads",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "description": "Create an Advanced Ads WordPress plugin ecosystem.",
   "author": {
     "name": "Shakeeb Ahmed",

package/src/app.js

@@ -5,7 +5,7 @@
  */
 import chalk from 'chalk'
 import { program } from 'commander'
-import { readFileSync } from 'node:fs'
+import { existsSync, readFileSync } from 'node:fs'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
@@ -15,9 +15,11 @@ import { fileURLToPath } from 'node:url'
 import * as commands from './commands/index.js'
 import { configFileExists, onNewLine } from './utilities/index.js'
 
+const pkgRoot = join( dirname( fileURLToPath( import.meta.url ) ), '..' )
 const { version } = JSON.parse(
-	readFileSync( join( dirname( fileURLToPath( import.meta.url ) ), '../package.json' ), 'utf8' )
+	readFileSync( join( pkgRoot, 'package.json' ), 'utf8' )
 )
+const fromLocal = existsSync( join( pkgRoot, '.git' ) )
 
 /**
  * App
@@ -27,8 +29,9 @@ const app = async () => {
         [
             chalk.hex('#FADC00').inverse.bold('Advanced Ads WordPress Plugin Toolkit'),
             chalk.white( 'v' + version ),
-            chalk.dim( 'by Shakeeb Ahmed' )
-        ].join(" ")
+            chalk.dim( 'by Shakeeb Ahmed' ),
+            fromLocal ? chalk.cyan( 'from local' ) : '',
+        ].filter( Boolean ).join(" ")
     );
 
 	program.configureHelp({

package/src/commands/build.js

@@ -27,8 +27,11 @@ export default function wpBuild(nextProcess = null, commitMessages = null) {
 		.catch( ( err ) => {
 			console.log('');
 			console.log( `${logSymbols.error} ${chalk.bold.red(`We failed somewhere! Work hard mate...`)}` )
+			if ( err && err !== true ) {
+				console.log( err instanceof Error ? ( err.stack || err.message ) : String( err ) )
+			}
 			if (typeof nextProcess === 'function') {
-				nextProcess(true);
+				nextProcess(err || true);
 			}
 		} )
 }
@@ -52,11 +55,13 @@ function run( commitMessages ) {
 
 		await runExec( 'composer install -o -a -n --no-dev --no-scripts', composerEnv )
 		onSameLine(`${logSymbols.success} Installed PHP dependencies`);
-		process.stderr.write('Composer dumping....')
+		process.stdout.write('Composer dumping...')
 
 		await runExec( 'composer dump', composerEnv )
 		onSameLine(`${logSymbols.success} Composer updated`)
-		commitMessages?.push( 'update 3rd party dependencies' )
+		if ( Array.isArray( commitMessages ) ) {
+			commitMessages.push( 'update 3rd party dependencies' )
+		}
 
 		process.stdout.write('Building plugin resources...')
 		let buildScript
@@ -71,7 +76,9 @@ function run( commitMessages ) {
 		} else {
 			await runExec( 'npm run build' )
 			onSameLine(`${logSymbols.success} Built plugin resources`);
-			commitMessages?.push( 'Build plugin resources' )
+			if ( Array.isArray( commitMessages ) ) {
+				commitMessages.push( 'Build plugin resources' )
+			}
 		}
 
 		console.log('')
@@ -85,7 +92,9 @@ function runExec( cmd, options ) {
 	return new Promise( ( resolve, reject ) => {
 		execCommand( cmd, ( stdout, error, stderr ) => {
 			if ( error ) {
-				onSameLine(`${logSymbols.error} ${stderr || error.message}`)
+				const detail = [ stderr && stderr.trim(), error.message ].filter( Boolean ).join( '\n' )
+				onSameLine(`${logSymbols.error} ${detail}`)
+				error.message = detail
 				reject( error )
 				return
 			}

package/src/commands/release/changelog.js

@@ -22,34 +22,46 @@ const LOCALES_CHANGELOG = {
  *
  * @param {Array} list List of languages downloaded
  *
- * @returns {Array}
+ * @returns {string}
  */
 function naturalLanguageJoin(list) {
-    const last = list.pop()
+    if ( list.length === 0 ) {
+        return ''
+    }
 
-    if ( list.length > 0 ) {
-        return `${list.join(', ')} and ${last}`
+    if ( list.length === 1 ) {
+        return list[0]
     }
 
-    return last
+    return `${list.slice( 0, -1 ).join(', ')} and ${list[ list.length - 1 ]}`
+}
+
+function normalizeGitPath( file ) {
+    return String( file || '' )
+        .replace( /\\/g, '/' )
+        .replace( /^\.\//, '' )
+        .replace( /\/+/g, '/' )
 }
 
 /**
  * Loop through downloaded locales and categorize them as added or updated
  *
- * @param {Array} locales Locales downloaded from GlotPress
+ * @param {Object} locales Locales downloaded from GlotPress
  * @param {Array} files   Files currently in branch
  *
- * @returns {Array}
+ * @returns {Object}
  */
 function loopLocales( locales, files ) {
     const changes = { updated: [], added: [] }
-    const localeFiles = Object.keys(locales)
+    const tracked = new Set( files.map( normalizeGitPath ).filter( Boolean ) )
 
-    localeFiles.map( (locale) => {
-        const action = files.includes(locale) ? 'updated' : 'added'
-        changes[ action ].push(locales[ locale ])
-    })
+    for ( const [ file, name ] of Object.entries( locales || {} ) ) {
+        const action = tracked.has( normalizeGitPath( file ) ) ? 'updated' : 'added'
+        const label = name || file.split( '/' ).pop()
+        if ( label ) {
+            changes[ action ].push( label )
+        }
+    }
 
     changes.added = [... new Set(changes.added)].sort()
     changes.updated = [... new Set(changes.updated)].sort()
@@ -70,7 +82,12 @@ function writeLocalesChangelog(type, changes) {
         return
     }
 
-    const message = LOCALES_CHANGELOG[type].message.replace('%s', naturalLanguageJoin(changes))
+    const message = naturalLanguageJoin(changes)
+    if ( ! message ) {
+        return
+    }
+
+    const line = LOCALES_CHANGELOG[type].message.replace('%s', message)
 
     if (!fs.existsSync('./.changelog')) {
         fs.mkdirSync('./.changelog');
@@ -78,7 +95,7 @@ function writeLocalesChangelog(type, changes) {
 
     fs.writeFileSync(
         `./.changelog/${LOCALES_CHANGELOG[type].file}`,
-        message
+        line
     )
 }
 
@@ -91,7 +108,7 @@ function updateLocalesChangelog(next) {
     write('Generating translations changelog...')
 
     execCommand( [ 'git', 'ls-files', '--', destination ], function(result) {
-        const files = result.split('\n').slice(0,-1)
+        const files = String( result || '' ).split('\n').map( ( line ) => line.trim() ).filter( Boolean )
         const changes = loopLocales(pluginData.locales, files)
 
         writeLocalesChangelog('added', changes.added)

package/src/commands/wp-glotpress.js

@@ -3,7 +3,7 @@
  */
 import fs from 'fs';
 import chalk from 'chalk';
-import { resolve } from 'path';
+import { join, relative, resolve } from 'path';
 import { heading, msgError, getSetting, write, msgSuccessOnSameLine, onSameLine, msgErrorOnSameLine } from "../utilities/index.js";
 
 const BASE_URL = 'https://translate.wpadvancedads.com/api/projects';
@@ -75,15 +75,15 @@ async function downloadAll( ctx ) {
         console.log( '' );
         console.log(
             chalk.yellow.bold( 'Updating Language:' ) +
-                ` ${chalk.italic( set.name )}`
+                ` ${chalk.italic( set.name || locale )}`
         );
 
         for ( const format of [ 'mo', 'po' ] ) {
             const target = await downloadFile( ctx, locale, set, format );
             if ( target ) {
-                const file = target.replace( /^\.\//, '' );
+                const file = relative( process.cwd(), resolve( target ) ).replace( /\\/g, '/' );
                 files.push( file );
-                names[ file ] = set.name;
+                names[ file ] = set.name || locale;
             }
         }
     }
@@ -142,7 +142,7 @@ async function downloadFile(ctx, locale, data, format) {
         chalk.bold(`Downloading: ${ctx.potPrefix}-${locale}.${format}`)
     );
 
-    const target = `${ctx.destination}/${ctx.potPrefix}-${locale}.${format}`;
+    const target = join( ctx.destination, `${ctx.potPrefix}-${locale}.${format}` );
     const endpoint = `${BASE_URL}/${ctx.project}/${data.locale}/${data.slug}/export-translations?format=${format}`;
 
     const response = await fetch(endpoint, {

package/src/commands/wp-pot.js

@@ -1,10 +1,10 @@
 /**
  * Internal Dependencies
  */
-import { heading, msgSuccess, runCommand, getSetting } from "../utilities/index.js"
+import { write, msgSuccessOnSameLine, msgErrorOnSameLine, runCommand, getSetting } from "../utilities/index.js"
 
 export default (next = null) => {
-    heading('Generating POT file...')
+    write('Generating POT file...')
 
     const settings = getSetting()
 
@@ -38,15 +38,35 @@ export default (next = null) => {
         `--domain=${domain}`,
         `--exclude=${exclude.join(',')}`,
         `--headers=${JSON.stringify(headers)}`,
-    ], ( error ) => {
+    ], ( error, stdout, stderr ) => {
         if ( error ) {
+            msgErrorOnSameLine(error.message)
             if ( next ) {
                 next( error )
             }
             return
         }
 
-        msgSuccess('POT file generated successfully');
+        msgSuccessOnSameLine('POT file generated successfully');
+        printPotWarnings( stderr, stdout )
         if (next) next();
     } );
 }
+
+function printPotWarnings( stderr, stdout ) {
+    const warnings = [ stderr, stdout ]
+        .filter( Boolean )
+        .join( '\n' )
+        .split( /\r?\n/ )
+        .map( ( line ) => line.trim() )
+        .filter( ( line ) => /warning:/i.test( line ) )
+
+    if ( ! warnings.length ) {
+        return
+    }
+
+    console.log( '' )
+    for ( const line of warnings ) {
+        console.log( line )
+    }
+}

package/src/utilities/shell.js

@@ -3,11 +3,6 @@
  */
 import { spawn } from 'node:child_process'
 
-/**
- * Internal Dependencies
- */
-import { onSameLine } from './formatting.js'
-
 /**
  * Run a command in the terminal.
  *
@@ -18,39 +13,12 @@ import { onSameLine } from './formatting.js'
  * @returns {void}
  */
 export function runCommand( command, args, callback ) {
-    const commandSpawn = spawn( command, args, {
-        shell: false,
-        stdio: [ 'inherit', 'pipe', 'pipe' ]
-    } )
-
-    let finished = false
-    const done = ( err ) => {
-        if ( finished ) {
-            return
-        }
-
-        finished = true
-        callback( err )
-    }
-
-    commandSpawn.stdout.on( 'data', (data) => {
-        onSameLine(data.toString())
-    })
-
-    commandSpawn.stderr.on( 'data', (data) => {
-        onSameLine(data.toString().replace('\n','').replace('\r','').trim())
-    })
-
-    commandSpawn.on( 'error', done )
-
-    commandSpawn.on( 'close', (code) => {
-        if ( code !== 0 ) {
-            done( new Error( `Command failed with exit code ${code}` ) )
-            return
-        }
-
-        done()
-    })
+	execCommand( [ command, ...args ], ( stdout, error, stderr ) => {
+		if ( error ) {
+			error.message = [ stderr && stderr.trim(), error.message ].filter( Boolean ).join( '\n' )
+		}
+		callback( error, stdout, stderr )
+	} )
 }
 
 /**
@@ -86,15 +54,11 @@ export function execCommand( command, callback, options = {} ) {
 	}
 
 	child.stdout.on( 'data', ( data ) => {
-		const text = data.toString()
-		stdout += text
-		onSameLine( text )
+		stdout += data.toString()
 	} )
 
 	child.stderr.on( 'data', ( data ) => {
-		const text = data.toString()
-		stderr += text
-		onSameLine( text.replace( '\n', '' ).replace( '\r', '' ).trim() )
+		stderr += data.toString()
 	} )
 
 	child.on( 'error', done )

package/test/build.test.js

@@ -13,6 +13,7 @@ import fs from 'node:fs'
 const execCalls = []
 let execImpl = ( cmd, cb ) => cb( '', null, '' )
 let potCalled = false
+let potImpl = ( next ) => next()
 
 mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
 	exports: {
@@ -28,7 +29,7 @@ mock.module( import.meta.resolve( '../src/commands/wp-pot.js' ), {
 	exports: {
 		default( next ) {
 			potCalled = true
-			next()
+			potImpl( next )
 		},
 	},
 } )
@@ -63,6 +64,7 @@ beforeEach( () => {
 	execCalls.length = 0
 	potCalled = false
 	execImpl = ( cmd, cb ) => cb( '', null, '' )
+	potImpl = ( next ) => next()
 	fs.rmSync.mock.mockImplementation( () => {} )
 	pluginData.commitMessages = []
 } )
@@ -166,3 +168,24 @@ test( 'build appends messages to an optional sink', async () => {
 	} )
 	assert.ok( sink.includes( 'update 3rd party dependencies' ) )
 } )
+
+test( 'build ignores a non-array commitMessages sink', async () => {
+	await new Promise( ( resolve, reject ) => {
+		wpBuild( ( err ) => err ? reject( err ) : resolve(), { name: () => 'build' } )
+	} )
+} )
+
+test( 'build failure prints the rejected error', async () => {
+	const lines = []
+	mock.method( console, 'log', ( ...args ) => {
+		lines.push( args.map( String ).join( ' ' ) )
+	} )
+	potImpl = ( next ) => next( new Error( 'make-pot failed: wp: command not found' ) )
+
+	await runBuild()
+
+	assert.ok(
+		lines.some( ( line ) => line.includes( 'make-pot failed: wp: command not found' ) ),
+		`expected the pot error in logs, got:\n${lines.join( '\n' )}`
+	)
+} )

package/test/changelog-locales.test.js

@@ -3,6 +3,7 @@
  * Run with --test-isolation=none --experimental-test-module-mocks
  */
 import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
 import { mkdir } from 'node:fs/promises'
 import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
@@ -10,12 +11,13 @@ import { join } from 'node:path'
 import { mock, test } from 'node:test'
 
 const execCalls = []
+let gitFiles = 'languages/myplugin-de_DE.po\n'
 
 mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
 	exports: {
 		execCommand( cmd, cb ) {
 			execCalls.push( cmd )
-			cb( 'languages/myplugin-de_DE.po\n', null, '' )
+			cb( gitFiles, null, '' )
 		},
 		runCommand() {},
 	},
@@ -24,26 +26,68 @@ mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
 const { pluginData } = await import( '../src/commands/release.js' )
 const { default: updateChangelog } = await import( '../src/commands/release/changelog.js' )
 
-test( 'updateLocalesChangelog uses glotpress.destination instead of unset pluginData.glotpress', async () => {
+async function withChangelog( run ) {
 	const dir = await mkdtemp( join( tmpdir(), 'wp-advads-changelog-' ) )
 	const cwd = process.cwd()
 	process.chdir( dir )
 	await mkdir( join( dir, '.changelog' ) )
-
 	pluginData.semver = { preRelease: true, getNextVersionString: () => '1.2.3' }
-	pluginData.locales = { 'languages/myplugin-de_DE.po': 'German' }
 	delete pluginData.glotpress
 	execCalls.length = 0
 
 	try {
+		return await run( dir )
+	} finally {
+		process.chdir( cwd )
+		await rm( dir, { recursive: true, force: true } )
+	}
+}
+
+function changelog( dir, file ) {
+	return readFileSync( join( dir, '.changelog', file ), 'utf8' )
+}
+
+test( 'updateLocalesChangelog lists updated languages from glotpress.destination', async () => {
+	gitFiles = [
+		'languages/myplugin-de_DE.po',
+		'languages/myplugin-de_DE.mo',
+		'languages/myplugin-fr_FR.po',
+	].join( '\n' ) + '\n'
+	pluginData.locales = {
+		'languages/myplugin-de_DE.po': 'German',
+		'languages/myplugin-de_DE.mo': 'German',
+		'languages/myplugin-fr_FR.po': 'French (France)',
+		'languages/myplugin-it_IT.po': 'Italian',
+	}
+
+	await withChangelog( async ( dir ) => {
 		const err = await new Promise( ( resolve ) => {
 			updateChangelog( ( error ) => resolve( error ) )
 		} )
 
 		assert.equal( err, undefined )
 		assert.deepEqual( execCalls[ 0 ], [ 'git', 'ls-files', '--', './languages/' ] )
-	} finally {
-		process.chdir( cwd )
-		await rm( dir, { recursive: true, force: true } )
-	}
+		assert.match( changelog( dir, 'improvement-102' ), /German/ )
+		assert.match( changelog( dir, 'improvement-102' ), /French \(France\)/ )
+		assert.doesNotMatch( changelog( dir, 'improvement-102' ), /undefined/ )
+		assert.match( changelog( dir, 'improvement-101' ), /Italian/ )
+		assert.doesNotMatch( changelog( dir, 'improvement-101' ), /undefined/ )
+	} )
+
+	gitFiles = 'languages/myplugin-de_DE.po\n'
+	pluginData.locales = { 'languages//myplugin-de_DE.po': 'German' }
+
+	await withChangelog( async ( dir ) => {
+		await new Promise( ( resolve ) => updateChangelog( resolve ) )
+		assert.match( changelog( dir, 'improvement-102' ), /update German translations/ )
+	} )
+
+	pluginData.locales = { 'languages/myplugin-de_DE.po': undefined }
+
+	await withChangelog( async ( dir ) => {
+		await new Promise( ( resolve ) => updateChangelog( resolve ) )
+		const updated = changelog( dir, 'improvement-102' )
+		assert.doesNotMatch( updated, /undefined/ )
+		assert.match( updated, /myplugin-de_DE\.po/ )
+	} )
 } )

package/test/pot-headers.test.js

@@ -9,13 +9,14 @@ import { join } from 'node:path'
 import { mock, test } from 'node:test'
 
 const potArgs = []
+let potStderr = ''
 
 mock.module( import.meta.resolve( '../src/utilities/shell.js' ), {
 	exports: {
 		execCommand() {},
 		runCommand( cmd, args, cb ) {
 			potArgs.push( { cmd, args } )
-			cb()
+			cb( null, '', potStderr )
 		},
 	},
 } )
@@ -42,6 +43,24 @@ test( 'pot Last-Translator and Language-Team use author from config', async () =
 		assert.equal( headers['Last-Translator'], 'Jane Doe <jane@example.com>' )
 		assert.equal( headers['Language-Team'], 'Jane Doe <jane@example.com>' )
 		assert.doesNotMatch( headersArg, /Shakeeb Ahmed/ )
+
+		potStderr = 'Warning: The string "Hello" is missing a translator comment.'
+		const lines = []
+		const originalLog = console.log
+		console.log = ( msg ) => {
+			lines.push( String( msg ) )
+		}
+		try {
+			await new Promise( ( resolve ) => wpPot( resolve ) )
+		} finally {
+			console.log = originalLog
+			potStderr = ''
+		}
+
+		assert.ok(
+			lines.some( ( line ) => line.includes( 'Warning: The string "Hello" is missing a translator comment.' ) ),
+			`expected make-pot warnings in logs, got:\n${lines.join( '\n' )}`
+		)
 	} finally {
 		process.chdir( cwd )
 		await rm( dir, { recursive: true, force: true } )

package/test/shell.test.js

@@ -30,7 +30,7 @@ test( 'runCommand calls back with an error on non-zero exit', async () => {
 	assert.ok( error, 'expected an error on exit 1' )
 } )
 
-test( 'execCommand prints stderr when the command fails', async () => {
+test( 'runCommand does not print stdout or stderr when the command succeeds', async () => {
 	const lines = []
 	const originalLog = console.log
 	console.log = ( msg ) => {
@@ -38,14 +38,46 @@ test( 'execCommand prints stderr when the command fails', async () => {
 	}
 
 	try {
-		await execOnce( 'node -e "process.stderr.write(\'boom-fail\'); process.exit(1)"' )
+		const error = await runOnce( 'node', [
+			'-e',
+			'process.stdout.write("make-pot progress"); process.stderr.write("scanning files")',
+		] )
+		assert.ok( ! error )
+	} finally {
+		console.log = originalLog
+	}
+
+	assert.equal(
+		lines.some( ( line ) => line.includes( 'make-pot progress' ) || line.includes( 'scanning files' ) ),
+		false
+	)
+} )
+
+test( 'execCommand returns stderr when the command fails', async () => {
+	const { error, stderr } = await execOnce( 'node -e "process.stderr.write(\'boom-fail\'); process.exit(1)"' )
+	assert.ok( error )
+	assert.match( stderr, /boom-fail/ )
+} )
+
+test( 'execCommand does not print stdout or stderr when the command succeeds', async () => {
+	const lines = []
+	const originalLog = console.log
+	console.log = ( msg ) => {
+		lines.push( String( msg ) )
+	}
+
+	try {
+		const { error } = await execOnce(
+			'node -e "process.stdout.write(\'Installing dependencies from lock file\'); process.stderr.write(\'Extracting archive\')"'
+		)
+		assert.equal( error, null )
 	} finally {
 		console.log = originalLog
 	}
 
-	assert.ok(
-		lines.some( ( line ) => line.includes( 'boom-fail' ) ),
-		'expected stderr to be printed on failure'
+	assert.equal(
+		lines.some( ( line ) => line.includes( 'Installing dependencies from lock file' ) || line.includes( 'Extracting archive' ) ),
+		false
 	)
 } )
 

package/test/version.test.js

@@ -20,3 +20,11 @@ test( 'wp-advads --version matches package.json and is not hardcoded 2.0.0', asy
 	assert.match( stdout, new RegExp( `\\b${version}\\b` ) )
 	assert.doesNotMatch( stdout, /v2\.0\.0/ )
 } )
+
+test( 'banner says from local when the CLI is a git checkout', async () => {
+	const { stdout } = await execFileAsync( process.execPath, [ 'src/app.js', '--version' ], {
+		cwd: root,
+	} )
+
+	assert.match( stdout, /from local/ )
+} )