yargs-file-commands 0.0.8 → 0.0.10

package/dist/{test → lib}/buildSegmentTree.test.js

@@ -1,8 +1,8 @@
 import assert from 'node:assert/strict';
 import { describe, it } from 'node:test';
-import { buildSegmentTree } from '../lib/buildSegmentTree.js';
+import { buildSegmentTree } from './buildSegmentTree.js';
 describe('buildSegmentTree', async () => {
-    it('should build correct tree structure', async () => {
+    it('should build correct tree structure', () => {
         const commands = [
             {
                 fullPath: '/commands/db/migration/command.js',
@@ -42,11 +42,11 @@ describe('buildSegmentTree', async () => {
             .sort();
         assert.deepEqual(childSegments, ['health', 'migration'], 'Should have "health" and "migration" sub-commands');
     });
-    it('should handle empty input', async () => {
+    it('should handle empty input', () => {
         const tree = buildSegmentTree([]);
         assert.equal(tree.length, 0, 'Should return empty array for empty input');
     });
-    it('should handle single command', async () => {
+    it('should handle single command', () => {
         const commands = [
             {
                 fullPath: '/commands/test.ts',

package/dist/lib/fileCommands.d.ts

@@ -1,23 +1,18 @@
+import { type ScanDirectoryOptions } from './scanDirectory.js';
 /**
  * Configuration options for file-based command generation
  * @interface FileCommandsOptions
  */
-export type FileCommandsOptions = {
+export type FileCommandsOptions = ScanDirectoryOptions & {
     /** Array of directory paths to scan for command files */
     commandDirs: string[];
-    /** File extensions to consider when scanning for command files */
-    extensions?: string[];
-    /** Regular expressions for patterns to ignore when scanning directories */
-    ignorePatterns?: RegExp[];
-    /** Logging verbosity level */
-    logLevel?: 'info' | 'debug';
 };
 /**
  * Default configuration options for file-based commands
  * @constant
  * @type {Partial<FileCommandsOptions>}
  */
-export declare const DefaultFileCommandsOptions: Partial<FileCommandsOptions>;
+export declare const DefaultFileCommandsOptions: Required<FileCommandsOptions>;
 /**
  * Generates a command tree structure from files in specified directories
  * @async

package/dist/lib/fileCommands.js

@@ -1,3 +1,4 @@
+import path from 'path';
 import { buildSegmentTree, createCommand, logCommandTree } from './buildSegmentTree.js';
 import { importCommandFromFile } from './importCommand.js';
 import { scanDirectory } from './scanDirectory.js';
@@ -8,6 +9,8 @@ import { segmentPath } from './segmentPath.js';
  * @type {Partial<FileCommandsOptions>}
  */
 export const DefaultFileCommandsOptions = {
+    /** Default directories to scan for command files */
+    commandDirs: [],
     /** Default file extensions to process */
     extensions: ['.js', '.ts'],
     /** Default patterns to ignore when scanning directories */
@@ -18,7 +21,9 @@ export const DefaultFileCommandsOptions = {
         /\.d\.ts$/ // TypeScript declaration files
     ],
     /** Default logging level */
-    logLevel: 'info'
+    logLevel: 'info',
+    /** Default log prefix */
+    logPrefix: '  '
 };
 /**
  * Generates a command tree structure from files in specified directories
@@ -38,23 +43,41 @@ export const DefaultFileCommandsOptions = {
  * 4. Convert the tree into a command hierarchy
  */
 export const fileCommands = async (options) => {
-    const fullOptions = { ...DefaultFileCommandsOptions, ...options };
+    const fullOptions = {
+        ...DefaultFileCommandsOptions,
+        ...options
+    };
+    // validate extensions have dots in them
+    if (fullOptions.extensions.some((ext) => !ext.startsWith('.'))) {
+        throw new Error(`Invalid extensions provided, must start with a dot: ${fullOptions.extensions.join(', ')}`);
+    }
+    // check for empty list of directories to scan
+    if (fullOptions.commandDirs.length === 0) {
+        throw new Error('No command directories provided');
+    }
     const commands = [];
-    await Promise.all(options.commandDirs.map(async (commandDir) => {
-        const filePaths = await scanDirectory(commandDir, fullOptions);
-        const rootDirCommands = await Promise.all(filePaths.map(async (filePath) => {
+    for (const commandDir of fullOptions.commandDirs) {
+        const fullPath = path.resolve(commandDir);
+        console.debug(`Scanning directory for commands: ${fullPath}`);
+        const filePaths = await scanDirectory(commandDir, commandDir, fullOptions);
+        for (const filePath of filePaths) {
             const segments = segmentPath(filePath, commandDir);
-            return {
+            segments.pop(); // remove extension.
+            commands.push({
                 fullPath: filePath,
-                segments: segmentPath(filePath, commandDir),
+                segments,
                 commandModule: await importCommandFromFile(filePath, segments[segments.length - 1], fullOptions)
-            };
-        }));
-        commands.push(...rootDirCommands);
-    }));
+            });
+        }
+    }
+    // check if no commands were found
+    if (commands.length === 0) {
+        throw new Error(`No commands found in specified directories: ${fullOptions.commandDirs.join(', ')}`);
+    }
     const commandRootNodes = buildSegmentTree(commands);
     if (fullOptions.logLevel === 'debug') {
-        logCommandTree(commandRootNodes);
+        console.debug('Command tree structure:');
+        logCommandTree(commandRootNodes, 1);
     }
     const rootCommands = commandRootNodes.map((node) => createCommand(node));
     return rootCommands;

package/dist/{test → lib}/fileCommands.test.js

@@ -7,7 +7,7 @@ import { hideBin } from 'yargs/helpers';
 import { fileCommands } from '../lib/fileCommands.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 describe('fileCommands', async () => {
-    it('should load commands from directory structure', async () => {
+    await it('should load commands from directory structure', async () => {
         const commandsDir = path.join(__dirname, 'fixtures', 'commands');
         const commands = await fileCommands({
             commandDirs: [commandsDir],
@@ -27,7 +27,7 @@ describe('fileCommands', async () => {
         const description = rootCommand.describe;
         assert(typeof description === 'string' && description.includes('db'), 'Command should have correct description');
     });
-    it('should respect ignore patterns', async () => {
+    await it('should respect ignore patterns', async () => {
         const commandsDir = path.join(__dirname, 'fixtures', 'commands');
         const commands = await fileCommands({
             commandDirs: [commandsDir],

package/dist/{test → lib}/importCommand.test.js

@@ -5,14 +5,14 @@ import { fileURLToPath } from 'node:url';
 import { importCommandFromFile } from '../lib/importCommand.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 describe('importCommandFromFile', async () => {
-    it('should import command module correctly', async () => {
+    await it('should import command module correctly', async () => {
         const commandPath = path.join(__dirname, 'fixtures', 'commands', 'db', 'health.js');
         const command = await importCommandFromFile(commandPath, 'health', {});
         assert(command.describe, 'Should have describe property');
         assert(typeof command.builder === 'function', 'Should have builder function');
         assert(typeof command.handler === 'function', 'Should have handler function');
     });
-    it('should handle non-existent files', async () => {
+    await it('should handle non-existent files', async () => {
         const nonExistentPath = path.join(__dirname, 'fixtures', 'commands', 'non-existent.ts');
         await assert.rejects(async () => {
             await importCommandFromFile(nonExistentPath, 'non-existent', {});

package/dist/lib/scanDirectory.d.ts

@@ -3,11 +3,14 @@
  * @interface ScanDirectoryOptions
  */
 export interface ScanDirectoryOptions {
-    /** Regular expressions for patterns to ignore */
-    ignorePatterns?: RegExp[];
-    /** File extensions to include in the scan */
+    /** File extensions to consider when scanning for command files */
     extensions?: string[];
+    /** Regular expressions for patterns to ignore when scanning directories */
+    ignorePatterns?: RegExp[];
+    /** Logging verbosity level */
     logLevel?: 'info' | 'debug';
+    /** Prefix for log messages */
+    logPrefix?: string;
 }
 /**
  * Recursively scans a directory for command files
@@ -22,4 +25,4 @@ export interface ScanDirectoryOptions {
  * - File extensions (only includes matching files)
  * The scan is performed in parallel for better performance.
  */
-export declare const scanDirectory: (dirPath: string, options?: ScanDirectoryOptions) => Promise<string[]>;
+export declare const scanDirectory: (dirPath: string, commandDir: string, options?: ScanDirectoryOptions) => Promise<string[]>;

package/dist/lib/scanDirectory.js

@@ -13,56 +13,50 @@ import path, { join } from 'path';
  * - File extensions (only includes matching files)
  * The scan is performed in parallel for better performance.
  */
-export const scanDirectory = async (dirPath, options = {}) => {
-    const { ignorePatterns = [], extensions = [], logLevel = 'info' } = options;
-    const rootedDirPath = path.resolve(dirPath);
-    if (logLevel === 'debug') {
-        console.debug(`Inspecting directory for possible commands: ${rootedDirPath}`);
-    }
-    // Check if path should be ignored
-    const shouldIgnore = ignorePatterns.some((pattern) => pattern.test(dirPath));
-    if (shouldIgnore) {
-        if (logLevel === 'debug') {
-            console.debug(`Ignoring directory because of ignorePatterns match: ${rootedDirPath}, ${ignorePatterns
-                .filter((pattern) => pattern.test(dirPath))
-                .join(', ')}`);
-        }
-        return [];
-    }
+export const scanDirectory = async (dirPath, commandDir, options = {}) => {
+    const { ignorePatterns = [], extensions = ['.js', '.ts'], logLevel = 'info', logPrefix = '' } = options;
     try {
         const entries = await readdir(dirPath);
-        if (logLevel === 'debug') {
-            console.log(`Found ${entries.length} items in current directory`);
-        }
-        const nestedFilesPromises = entries.map(async (entry) => {
+        const commandPaths = [];
+        for (const entry of entries) {
             const fullPath = join(dirPath, entry);
+            const localPath = fullPath.replace(commandDir, '');
             // apply ignore pattern and early return if matched
-            const shouldIgnore = ignorePatterns.some((pattern) => pattern.test(entry));
+            const shouldIgnore = ignorePatterns.some((pattern) => pattern.test(localPath));
             if (shouldIgnore) {
                 if (logLevel === 'debug') {
-                    console.debug(`Ignoring file because of ignorePatterns match: ${path.resolve(fullPath)}, ${ignorePatterns
-                        .filter((pattern) => pattern.test(entry))
+                    console.debug(`${logPrefix}${localPath} - ignoring because it matches ignorePattern: ${ignorePatterns
+                        .filter((pattern) => pattern.test(localPath))
                         .join(', ')}`);
                 }
-                return [];
+                continue;
             }
             const stats = await stat(fullPath);
             if (stats.isDirectory()) {
-                return scanDirectory(fullPath, options);
+                if (logLevel === 'debug') {
+                    console.debug(`${logPrefix}${localPath} - directory, scanning for commands:`);
+                }
+                commandPaths.push(...(await scanDirectory(fullPath, commandDir, {
+                    ...options,
+                    logPrefix: `${logPrefix}  `
+                })));
+                continue;
             }
             const extension = path.extname(fullPath);
             if (!extensions.includes(extension)) {
-                return [];
+                if (logLevel === 'debug') {
+                    console.debug(`${logPrefix}${localPath} - ignoring as its extension, ${extension}, doesn't match required extension: ${extensions.join(', ')}`);
+                }
+                continue;
             }
             if (logLevel === 'debug') {
-                console.debug(`Inspecting file as possible command: ${fullPath}`);
+                console.debug(`${logPrefix}${localPath} - possible command file`);
             }
-            return [fullPath];
-        });
-        const nestedFiles = await Promise.all(nestedFilesPromises);
-        return nestedFiles.flat();
+            commandPaths.push(fullPath);
+        }
+        return commandPaths;
     }
     catch (error) {
-        throw new Error(`Failed to scan directory ${dirPath}: ${error}`);
+        throw new Error(`${logPrefix}Failed to scan directory ${dirPath}: ${error}`);
     }
 };

package/dist/lib/scanDirectory.test.js

@@ -0,0 +1,46 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { scanDirectory } from '../lib/scanDirectory.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+describe('scanDirectory', async () => {
+    await it('should find all command files in directory', async () => {
+        const commandsDir = path.join(__dirname, 'fixtures', 'commands');
+        console.log('Scan Directory: ', commandsDir);
+        const files = await scanDirectory(commandsDir, commandsDir, {
+            extensions: ['.js'],
+            logLevel: 'debug'
+        });
+        assert.equal(files.length, 2, `Should find two command files, instead found: ${files.join(', ')}`);
+        assert(files.some((f) => f.includes('health.js')), `Should find health.js, instead found: ${files.join(', ')}`);
+        assert(files.some((f) => f.includes('command.js')), `Should find command.js, instead found: ${files.join(', ')}`);
+    });
+    await it('should respect ignore patterns', async () => {
+        const commandsDir = path.join(__dirname, 'fixtures', 'commands');
+        console.log('Scan Directory: ', commandsDir);
+        const files = await scanDirectory(commandsDir, commandsDir, {
+            extensions: ['.js'],
+            ignorePatterns: [/health/],
+            logLevel: 'debug'
+        });
+        assert.equal(files.length, 1, `Should find one command file, instead found: ${files.join(', ')}`);
+        assert(files.some((f) => f.includes('command.js')), `Should find command.js, instead found: ${files.join(', ')}`);
+        assert(!files.some((f) => f.includes('health.js')), `Should not find health.js, instead found: ${files.join(', ')}`);
+    });
+    await it('should handle non-existent directories', async () => {
+        const nonExistentDir = path.join(__dirname, 'fixtures', 'non-existent');
+        try {
+            console.log('Scan Directory: ', nonExistentDir);
+            await scanDirectory(nonExistentDir, nonExistentDir, {
+                extensions: ['.js'],
+                logLevel: 'debug'
+            });
+            assert.fail('Should have thrown an error');
+        }
+        catch (error) {
+            assert(error instanceof Error);
+            assert(error.message.includes('ENOENT'), 'Error should indicate directory not found');
+        }
+    });
+});

package/dist/lib/segmentPath.test.js

@@ -1,8 +1,8 @@
-import { test } from 'node:test';
+import { describe, it } from 'node:test';
 import assert from 'assert';
 import { segmentPath } from './segmentPath.js';
-await test('segmentPath', async () => {
-    await test('should segment a path correctly', () => {
+describe('segmentPath', () => {
+    it('should segment a path correctly', () => {
         const fullPath = '/Users/username/Coding/Personal/yargs-file-commands/packages/yargs-file-commands/src/lib/segmentPath.ts';
         const baseDir = '/Users/username/Coding/Personal/yargs-file-commands/';
         const expected = [
@@ -16,7 +16,7 @@ await test('segmentPath', async () => {
         const result = segmentPath(fullPath, baseDir);
         assert.deepStrictEqual(result, expected);
     });
-    await test('should handle paths with periods correctly', () => {
+    it('should handle paths with periods correctly', () => {
         const fullPath = '/Users/username/Coding/Personal/yargs-file-commands/packages/yargs-file-commands/src/lib/segmentPath.test.ts';
         const baseDir = '/Users/username/Coding/Personal/yargs-file-commands/';
         const expected = [
@@ -31,7 +31,7 @@ await test('segmentPath', async () => {
         const result = segmentPath(fullPath, baseDir);
         assert.deepStrictEqual(result, expected);
     });
-    await test('should filter out "command" segments', () => {
+    it('should filter out "command" segments', () => {
         const fullPath = '/Users/username/Coding/Personal/yargs-file-commands/packages/yargs-file-commands/src/lib/commandPath.ts';
         const baseDir = '/Users/username/Coding/Personal/yargs-file-commands/';
         const expected = [
@@ -45,7 +45,7 @@ await test('segmentPath', async () => {
         const result = segmentPath(fullPath, baseDir);
         assert.deepStrictEqual(result, expected);
     });
-    test('should handle empty segments correctly', () => {
+    it('should handle empty segments correctly', () => {
         const fullPath = '/Users/username/Coding/Personal/yargs-file-commands/packages/yargs-file-commands/src/lib/.hiddenFile';
         const baseDir = '/Users/username/Coding/Personal/yargs-file-commands/';
         const expected = [

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "yargs-file-commands",
   "description": "A yargs helper function that lets you define your commands structure via directory and file naming conventions.",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,13 +19,6 @@
     "nodejs",
     "typescript"
   ],
-  "scripts": {
-    "build": "tsc",
-    "typecheck": "tsc --noEmit",
-    "test": "tsc && node --test dist/**/*.test.js",
-    "lint": "eslint --fix \"src/**/*.{ts,tsx}\"",
-    "format": "prettier \"src/**/*.{js,jsx,css,md,html,ts,tsx,json,yaml}\" --check"
-  },
   "homepage": "https://github.com/bhouston/yargs-file-commands#readme",
   "repository": {
     "type": "git",
@@ -54,5 +47,12 @@
   },
   "engines": {
     "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "test": "tsc && node --test dist/**/*.test.js --test-concurrency=1",
+    "lint": "eslint --fix \"src/**/*.{ts,tsx}\"",
+    "format": "prettier \"src/**/*.{js,jsx,css,md,html,ts,tsx,json,yaml}\" --check"
   }
-}
+}

package/dist/test/scanDirectory.test.js

@@ -1,41 +0,0 @@
-import assert from 'node:assert/strict';
-import path from 'node:path';
-import { describe, it } from 'node:test';
-import { fileURLToPath } from 'node:url';
-import { scanDirectory } from '../lib/scanDirectory.js';
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-describe('scanDirectory', async () => {
-    it('should find all command files in directory', async () => {
-        const commandsDir = path.join(__dirname, 'fixtures', 'commands');
-        const files = await scanDirectory(commandsDir, {
-            extensions: ['.js'],
-            ignorePatterns: []
-        });
-        assert.equal(files.length, 2, 'Should find two command files');
-        assert(files.some((f) => f.includes('health.js')), 'Should find health.js');
-        assert(files.some((f) => f.includes('command.js')), 'Should find command.js');
-    });
-    it('should respect ignore patterns', async () => {
-        const commandsDir = path.join(__dirname, 'fixtures', 'commands');
-        const files = await scanDirectory(commandsDir, {
-            extensions: ['.js'],
-            ignorePatterns: [/health/]
-        });
-        assert.equal(files.length, 1, 'Should find one command file');
-        assert(files.some((f) => f.includes('command.js')), 'Should find command.js');
-        assert(!files.some((f) => f.includes('health.js')), 'Should not find health.js');
-    });
-    it('should handle non-existent directories', async () => {
-        const nonExistentDir = path.join(__dirname, 'fixtures', 'non-existent');
-        try {
-            await scanDirectory(nonExistentDir, {
-                extensions: ['.js']
-            });
-            assert.fail('Should have thrown an error');
-        }
-        catch (error) {
-            assert(error instanceof Error);
-            assert(error.message.includes('ENOENT'), 'Error should indicate directory not found');
-        }
-    });
-});