yargs-file-commands 0.0.3 → 0.0.5

package/dist/lib/Command.d.ts

@@ -1,6 +1,13 @@
 import type { CommandModule } from 'yargs';
+/**
+ * Represents a command structure with its file path and module information
+ * @interface Command
+ */
 export interface Command {
+    /** Full file system path to the command file */
     fullPath: string;
+    /** Array of path segments representing the command hierarchy */
     segments: string[];
+    /** The Yargs command module implementation */
     commandModule: CommandModule;
 }

package/dist/lib/buildSegmentTree.d.ts

@@ -1,14 +1,43 @@
 import type { CommandModule } from 'yargs';
 import type { Command } from './Command';
+/**
+ * Represents a node in the command tree structure
+ * @type {CommandTreeNode}
+ */
 type CommandTreeNode = {
+    /** Name of the command segment */
     segmentName: string;
 } & ({
+    /** Internal node type with children */
     type: 'internal';
+    /** Child command nodes */
     children: CommandTreeNode[];
 } | {
+    /** Leaf node type with command implementation */
     type: 'leaf';
+    /** The command implementation */
     command: Command;
 });
+/**
+ * Builds a tree structure from command definitions
+ * @param {Command[]} commands - Array of command definitions
+ * @returns {CommandTreeNode[]} Root nodes of the command tree
+ *
+ * @description
+ * Constructs a hierarchical tree structure from flat command definitions,
+ * preserving the command hierarchy defined by the file system structure.
+ */
 export declare const buildSegmentTree: (commands: Command[]) => CommandTreeNode[];
+/**
+ * Creates a Yargs command module from a tree node
+ * @param {CommandTreeNode} treeNode - The tree node to convert
+ * @returns {CommandModule} Yargs command module
+ *
+ * @description
+ * Recursively converts a tree node into a Yargs command module.
+ * For leaf nodes, returns the actual command implementation.
+ * For internal nodes, creates a parent command that manages subcommands.
+ */
 export declare const createCommand: (treeNode: CommandTreeNode) => CommandModule;
+export declare const logCommandTree: (commands: CommandTreeNode[], level?: number) => void;
 export {};

package/dist/lib/buildSegmentTree.js

@@ -1,3 +1,12 @@
+/**
+ * Builds a tree structure from command definitions
+ * @param {Command[]} commands - Array of command definitions
+ * @returns {CommandTreeNode[]} Root nodes of the command tree
+ *
+ * @description
+ * Constructs a hierarchical tree structure from flat command definitions,
+ * preserving the command hierarchy defined by the file system structure.
+ */
 export const buildSegmentTree = (commands) => {
     const rootTreeNodes = [];
     for (const command of commands) {
@@ -5,6 +14,13 @@ export const buildSegmentTree = (commands) => {
     }
     return rootTreeNodes;
 };
+/**
+ * Inserts a command into the tree structure at the specified depth
+ * @param {CommandTreeNode[]} treeNodes - Current level tree nodes
+ * @param {Command} command - Command to insert
+ * @param {number} depth - Current depth in the segment tree
+ * @throws {Error} When there's a conflict between directory and command names
+ */
 function insertIntoTree(treeNodes, command, depth) {
     // If we've processed all segments, we shouldn't be here
     if (depth >= command.segments.length) {
@@ -41,6 +57,16 @@ function insertIntoTree(treeNodes, command, depth) {
     // Recurse into children
     insertIntoTree(currentSegment.children, command, depth + 1);
 }
+/**
+ * Creates a Yargs command module from a tree node
+ * @param {CommandTreeNode} treeNode - The tree node to convert
+ * @returns {CommandModule} Yargs command module
+ *
+ * @description
+ * Recursively converts a tree node into a Yargs command module.
+ * For leaf nodes, returns the actual command implementation.
+ * For internal nodes, creates a parent command that manages subcommands.
+ */
 export const createCommand = (treeNode) => {
     if (treeNode.type === 'leaf') {
         return treeNode.command.commandModule;
@@ -63,3 +89,11 @@ export const createCommand = (treeNode) => {
     };
     return command;
 };
+export const logCommandTree = (commands, level = 0) => {
+    commands.forEach((command) => {
+        console.debug(`${'  '.repeat(level) + command.segmentName}`);
+        if (command.type === 'internal') {
+            logCommandTree(command.children, level + 1);
+        }
+    });
+};

package/dist/lib/fileCommands.d.ts

@@ -1,8 +1,38 @@
+/**
+ * Configuration options for file-based command generation
+ * @interface FileCommandsOptions
+ */
 export type FileCommandsOptions = {
+    /** 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>;
+/**
+ * Generates a command tree structure from files in specified directories
+ * @async
+ * @param {FileCommandsOptions} options - Configuration options for command generation
+ * @returns {Promise<Command[]>} Array of root-level commands with their nested subcommands
+ *
+ * @description
+ * This function scans the specified directories for command files and builds a hierarchical
+ * command structure based on the file system layout. It processes files in parallel for better
+ * performance and supports nested commands through directory structure.
+ *
+ * The function will:
+ * 1. Scan all specified command directories
+ * 2. Process found files to extract command information
+ * 3. Build a tree structure based on file paths
+ * 4. Convert the tree into a command hierarchy
+ */
 export declare const fileCommands: (options: FileCommandsOptions) => Promise<import("yargs").CommandModule<{}, {}>[]>;

package/dist/lib/fileCommands.js

@@ -1,17 +1,42 @@
-import { buildSegmentTree, createCommand } from './buildSegmentTree.js';
+import { buildSegmentTree, createCommand, logCommandTree } from './buildSegmentTree.js';
 import { importCommandFromFile } from './importCommand.js';
 import { scanDirectory } from './scanDirectory.js';
 import { segmentPath } from './segmentPath.js';
+/**
+ * Default configuration options for file-based commands
+ * @constant
+ * @type {Partial<FileCommandsOptions>}
+ */
 export const DefaultFileCommandsOptions = {
+    /** Default file extensions to process */
     extensions: ['.js', '.ts'],
+    /** Default patterns to ignore when scanning directories */
     ignorePatterns: [
-        /^[.|_].*/,
-        /\.(?:test|spec)\.[jt]s$/,
-        /__(?:test|spec)__/,
-        /\.d\.ts$/
+        /^[.|_].*/, // Hidden files and underscore files
+        /\.(?:test|spec)\.[jt]s$/, // Test files
+        /__(?:test|spec)__/, // Test directories
+        /\.d\.ts$/ // TypeScript declaration files
     ],
+    /** Default logging level */
     logLevel: 'info'
 };
+/**
+ * Generates a command tree structure from files in specified directories
+ * @async
+ * @param {FileCommandsOptions} options - Configuration options for command generation
+ * @returns {Promise<Command[]>} Array of root-level commands with their nested subcommands
+ *
+ * @description
+ * This function scans the specified directories for command files and builds a hierarchical
+ * command structure based on the file system layout. It processes files in parallel for better
+ * performance and supports nested commands through directory structure.
+ *
+ * The function will:
+ * 1. Scan all specified command directories
+ * 2. Process found files to extract command information
+ * 3. Build a tree structure based on file paths
+ * 4. Convert the tree into a command hierarchy
+ */
 export const fileCommands = async (options) => {
     const fullOptions = { ...DefaultFileCommandsOptions, ...options };
     const commands = [];
@@ -22,12 +47,15 @@ export const fileCommands = async (options) => {
             return {
                 fullPath: filePath,
                 segments: segmentPath(filePath, commandDir),
-                commandModule: await importCommandFromFile(filePath, segments[segments.length - 1])
+                commandModule: await importCommandFromFile(filePath, segments[segments.length - 1], fullOptions)
             };
         }));
         commands.push(...rootDirCommands);
     }));
     const commandRootNodes = buildSegmentTree(commands);
+    if (fullOptions.logLevel === 'debug') {
+        logCommandTree(commandRootNodes);
+    }
     const rootCommands = commandRootNodes.map((node) => createCommand(node));
     return rootCommands;
 };

package/dist/lib/importCommand.d.ts

@@ -1,18 +1,67 @@
 import { type ArgumentsCamelCase, type CommandBuilder, type CommandModule } from 'yargs';
+/**
+ * Represents command alias configuration
+ * @type {readonly string[] | string | undefined}
+ */
 export type CommandAlias = readonly string[] | string | undefined;
+/**
+ * Represents command name configuration
+ * @type {readonly string[] | string | undefined}
+ */
 export type CommandName = readonly string[] | string | undefined;
+/**
+ * Represents command deprecation configuration
+ * @type {boolean | string | undefined}
+ */
 export type CommandDeprecated = boolean | string | undefined;
+/**
+ * Represents command description configuration
+ * @type {string | false | undefined}
+ */
 export type CommandDescribe = string | false | undefined;
+/**
+ * Command handler function type
+ * @type {Function}
+ */
 export type CommandHandler = (args: ArgumentsCamelCase<any>) => void | Promise<any>;
+/**
+ * Parameters for file commands configuration
+ * @interface FileCommandsParams
+ */
 export interface FileCommandsParams {
+    /** Root directory for command files */
     rootDir: string;
 }
+/**
+ * Structure of a command module import
+ * @interface CommandImportModule
+ */
 export interface CommandImportModule {
+    /** Command aliases */
     alias?: CommandAlias;
+    /** Command builder function */
     builder?: CommandBuilder;
+    /** Command name */
     command?: CommandName;
+    /** Deprecation status */
     deprecated?: CommandDeprecated;
+    /** Command description */
     describe?: CommandDescribe;
+    /** Command handler function */
     handler?: CommandHandler;
 }
-export declare const importCommandFromFile: (filePath: string, name: string) => Promise<CommandModule<{}, {}>>;
+export interface ImportCommandOptions {
+    logLevel?: 'info' | 'debug';
+}
+/**
+ * Imports a command module from a file
+ * @async
+ * @param {string} filePath - Path to the command file
+ * @param {string} name - Command name
+ * @returns {Promise<CommandModule>} Imported command module
+ *
+ * @description
+ * Dynamically imports a command file and constructs a Yargs command module.
+ * If no handler is provided, creates a null implementation.
+ */
+export declare const importCommandFromFile: (filePath: string, name: string, options: ImportCommandOptions) => Promise<CommandModule<{}, {}>>;

package/dist/lib/importCommand.js

@@ -1,7 +1,19 @@
 import {} from 'yargs';
-export const importCommandFromFile = async (filePath, name) => {
+/**
+ * Imports a command module from a file
+ * @async
+ * @param {string} filePath - Path to the command file
+ * @param {string} name - Command name
+ * @returns {Promise<CommandModule>} Imported command module
+ *
+ * @description
+ * Dynamically imports a command file and constructs a Yargs command module.
+ * If no handler is provided, creates a null implementation.
+ */
+export const importCommandFromFile = async (filePath, name, options) => {
     const handlerModule = (await import(filePath));
-    return {
+    const { logLevel = 'info' } = options;
+    const command = {
         command: name,
         describe: handlerModule.describe,
         alias: handlerModule.alias,
@@ -12,4 +24,8 @@ export const importCommandFromFile = async (filePath, name) => {
                 // null implementation
             })
     };
+    if (logLevel === 'debug') {
+        console.debug('Importing command from', filePath, 'as', name, 'with description', command.describe);
+    }
+    return command;
 };

package/dist/lib/scanDirectory.d.ts

@@ -1,5 +1,25 @@
+/**
+ * Options for directory scanning
+ * @interface ScanDirectoryOptions
+ */
 export interface ScanDirectoryOptions {
+    /** Regular expressions for patterns to ignore */
     ignorePatterns?: RegExp[];
+    /** File extensions to include in the scan */
     extensions?: string[];
+    logLevel?: 'info' | 'debug';
 }
+/**
+ * Recursively scans a directory for command files
+ * @async
+ * @param {string} dirPath - The directory path to scan
+ * @param {ScanDirectoryOptions} options - Scanning configuration options
+ * @returns {Promise<string[]>} Array of full paths to command files
+ *
+ * @description
+ * Performs a recursive directory scan, filtering files based on:
+ * - Ignore patterns (skips matching files/directories)
+ * - 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[]>;

package/dist/lib/scanDirectory.js

@@ -1,7 +1,23 @@
 import { readdir, stat } from 'fs/promises';
 import path, { join } from 'path';
+/**
+ * Recursively scans a directory for command files
+ * @async
+ * @param {string} dirPath - The directory path to scan
+ * @param {ScanDirectoryOptions} options - Scanning configuration options
+ * @returns {Promise<string[]>} Array of full paths to command files
+ *
+ * @description
+ * Performs a recursive directory scan, filtering files based on:
+ * - Ignore patterns (skips matching files/directories)
+ * - File extensions (only includes matching files)
+ * The scan is performed in parallel for better performance.
+ */
 export const scanDirectory = async (dirPath, options = {}) => {
-    const { ignorePatterns = [], extensions = [] } = options;
+    const { ignorePatterns = [], extensions = [], logLevel = 'info' } = options;
+    if (logLevel === 'debug') {
+        console.debug(`Inspecting directory for possible commands: ${dirPath}`);
+    }
     // Check if path should be ignored
     const shouldIgnore = ignorePatterns.some((pattern) => pattern.test(dirPath));
     if (shouldIgnore) {
@@ -10,12 +26,15 @@ export const scanDirectory = async (dirPath, options = {}) => {
     try {
         const entries = await readdir(dirPath);
         const nestedFilesPromises = entries.map(async (entry) => {
+            const fullPath = join(dirPath, entry);
             // apply ignore pattern and early return if matched
             const shouldIgnore = ignorePatterns.some((pattern) => pattern.test(entry));
             if (shouldIgnore) {
+                if (logLevel === 'debug') {
+                    console.debug(`Ignoring file because of ignorePatterns match: ${fullPath}`);
+                }
                 return [];
             }
-            const fullPath = join(dirPath, entry);
             const stats = await stat(fullPath);
             if (stats.isDirectory()) {
                 return scanDirectory(fullPath, options);
@@ -24,6 +43,9 @@ export const scanDirectory = async (dirPath, options = {}) => {
             if (!extensions.includes(extension)) {
                 return [];
             }
+            if (logLevel === 'debug') {
+                console.debug(`Inspecting file as possible command: ${fullPath}`);
+            }
             return [fullPath];
         });
         const nestedFiles = await Promise.all(nestedFilesPromises);

package/dist/lib/segmentPath.d.ts

@@ -1 +1,19 @@
+/**
+ * Converts a file path into an array of command segments
+ * @param {string} fullPath - The complete file system path to the command file
+ * @param {string} baseDir - The base directory to make the path relative to
+ * @returns {string[]} Array of segments representing the command hierarchy
+ *
+ * @description
+ * This function processes a file path into command segments by:
+ * 1. Making the path relative to the base directory
+ * 2. Splitting on directory separators
+ * 3. Removing file extensions
+ * 4. Splitting on dots for nested commands
+ * 5. Filtering out empty segments and 'command' keyword
+ *
+ * @example
+ * segmentPath('/base/dir/hello/world.command.ts', '/base/dir')
+ * // Returns: ['hello', 'world']
+ */
 export declare const segmentPath: (fullPath: string, baseDir: string) => string[];

package/dist/lib/segmentPath.js

@@ -1,12 +1,30 @@
+/**
+ * Converts a file path into an array of command segments
+ * @param {string} fullPath - The complete file system path to the command file
+ * @param {string} baseDir - The base directory to make the path relative to
+ * @returns {string[]} Array of segments representing the command hierarchy
+ *
+ * @description
+ * This function processes a file path into command segments by:
+ * 1. Making the path relative to the base directory
+ * 2. Splitting on directory separators
+ * 3. Removing file extensions
+ * 4. Splitting on dots for nested commands
+ * 5. Filtering out empty segments and 'command' keyword
+ *
+ * @example
+ * segmentPath('/base/dir/hello/world.command.ts', '/base/dir')
+ * // Returns: ['hello', 'world']
+ */
 export const segmentPath = (fullPath, baseDir) => {
     // Remove base directory and normalize slashes
-    const relativePath = fullPath.replace(baseDir, '').replace(/^[/\\]+/, '');
+    const relativePath = fullPath.replace(baseDir, '').replace(/^[/\\\\]+/, '');
     // Split into path segments and filename
-    const allSegments = relativePath.split(/[/\\]/);
+    const allSegments = relativePath.split(/[/\\\\]/);
     // Process all segments including filename (without extension)
     const processedSegments = allSegments
         // Remove extension from the last segment (filename)
-        .map((segment, index, array) => index === array.length - 1 ? segment.replace(/\.[^/.]+$/, '') : segment)
+        .map((segment, index, array) => index === array.length - 1 ? segment.replace(/\\.[^/.]+$/, '') : segment)
         // Split segments containing periods
         .flatMap((segment) => segment.split('.'))
         // Filter out empty segments and 'command'

package/dist/lib/segmentPath.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/segmentPath.test.js

@@ -0,0 +1,61 @@
+import { test } from 'node:test';
+import assert from 'assert';
+import { segmentPath } from './segmentPath.js';
+await test('segmentPath', async () => {
+    await test('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 = [
+            'packages',
+            'yargs-file-commands',
+            'src',
+            'lib',
+            'segmentPath',
+            'ts'
+        ];
+        const result = segmentPath(fullPath, baseDir);
+        assert.deepStrictEqual(result, expected);
+    });
+    await test('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 = [
+            'packages',
+            'yargs-file-commands',
+            'src',
+            'lib',
+            'segmentPath',
+            'test',
+            'ts'
+        ];
+        const result = segmentPath(fullPath, baseDir);
+        assert.deepStrictEqual(result, expected);
+    });
+    await test('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 = [
+            'packages',
+            'yargs-file-commands',
+            'src',
+            'lib',
+            'commandPath',
+            'ts'
+        ];
+        const result = segmentPath(fullPath, baseDir);
+        assert.deepStrictEqual(result, expected);
+    });
+    test('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 = [
+            'packages',
+            'yargs-file-commands',
+            'src',
+            'lib',
+            'hiddenFile'
+        ];
+        const result = segmentPath(fullPath, baseDir);
+        assert.deepStrictEqual(result, expected);
+    });
+});

package/dist/test/buildSegmentTree.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/buildSegmentTree.test.js

@@ -0,0 +1,70 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { buildSegmentTree } from '../lib/buildSegmentTree.js';
+describe('buildSegmentTree', async () => {
+    it('should build correct tree structure', async () => {
+        const commands = [
+            {
+                fullPath: '/commands/db/migration/command.js',
+                segments: ['db', 'migration'],
+                commandModule: {
+                    command: 'migration',
+                    describe: 'Migration command',
+                    handler: async () => {
+                        // Test handler
+                    }
+                }
+            },
+            {
+                fullPath: '/commands/db/health.js',
+                segments: ['db', 'health'],
+                commandModule: {
+                    command: 'health',
+                    describe: 'Health command',
+                    handler: async () => {
+                        // Test handler
+                    }
+                }
+            }
+        ];
+        const tree = buildSegmentTree(commands);
+        assert.equal(tree.length, 1, 'Should have one root node');
+        const rootNode = tree[0];
+        assert(rootNode, 'Root node should exist');
+        assert.equal(rootNode.segmentName, 'db', 'Root node should be "db"');
+        assert.equal(rootNode.type, 'internal', 'Root node should be internal type');
+        if (rootNode.type !== 'internal') {
+            throw new Error('Expected internal node');
+        }
+        assert.equal(rootNode.children.length, 2, 'Should have two child nodes');
+        const childSegments = rootNode.children
+            .map((child) => child.segmentName)
+            .sort();
+        assert.deepEqual(childSegments, ['health', 'migration'], 'Should have "health" and "migration" sub-commands');
+    });
+    it('should handle empty input', async () => {
+        const tree = buildSegmentTree([]);
+        assert.equal(tree.length, 0, 'Should return empty array for empty input');
+    });
+    it('should handle single command', async () => {
+        const commands = [
+            {
+                fullPath: '/commands/test.ts',
+                segments: ['test'],
+                commandModule: {
+                    command: 'test',
+                    describe: 'Test command',
+                    handler: async () => {
+                        // Test handler
+                    }
+                }
+            }
+        ];
+        const tree = buildSegmentTree(commands);
+        assert.equal(tree.length, 1, 'Should have one node');
+        const node = tree[0];
+        assert(node, 'Node should exist');
+        assert.equal(node.segmentName, 'test', 'Should have correct segment');
+        assert.equal(node.type, 'leaf', 'Should be a leaf node');
+    });
+});

package/dist/test/fileCommands.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/fileCommands.test.js

@@ -0,0 +1,43 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import yargs from 'yargs';
+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 () => {
+        const commandsDir = path.join(__dirname, 'fixtures', 'commands');
+        const commands = await fileCommands({
+            commandDirs: [commandsDir],
+            extensions: ['.js'],
+            logLevel: 'debug'
+        });
+        assert.equal(commands.length, 1, 'Should have one root command');
+        const rootCommand = commands[0];
+        assert(rootCommand, 'Root command should exist');
+        assert.equal(rootCommand.command, 'db', 'Root command should be "db"');
+        // Create a new yargs instance
+        const yargsInstance = yargs(hideBin(process.argv));
+        if (typeof rootCommand.builder === 'function') {
+            rootCommand.builder(yargsInstance);
+        }
+        // Check that the command has subcommands by checking its description
+        const description = rootCommand.describe;
+        assert(typeof description === 'string' && description.includes('db'), 'Command should have correct description');
+    });
+    it('should respect ignore patterns', async () => {
+        const commandsDir = path.join(__dirname, 'fixtures', 'commands');
+        const commands = await fileCommands({
+            commandDirs: [commandsDir],
+            extensions: ['.js'],
+            ignorePatterns: [/health/],
+            logLevel: 'debug'
+        });
+        assert.equal(commands.length, 1, 'Should have one root command');
+        const rootCommand = commands[0];
+        assert(rootCommand, 'Root command should exist');
+        assert.equal(rootCommand.command, 'db', 'Root command should be "db"');
+    });
+});

package/dist/test/fixtures/commands/db/health.d.ts

@@ -0,0 +1,3 @@
+export declare const describe = "Database health check";
+export declare const builder: (yargs: any) => any;
+export declare const handler: () => Promise<void>;

package/dist/test/fixtures/commands/db/health.js

@@ -0,0 +1,7 @@
+export const describe = 'Database health check';
+export const builder = (yargs) => {
+    return yargs;
+};
+export const handler = async () => {
+    console.log('Health check handler called');
+};

package/dist/test/fixtures/commands/db/migration/command.d.ts

@@ -0,0 +1,3 @@
+export declare const describe = "Database migration command";
+export declare const builder: (yargs: any) => any;
+export declare const handler: (argv: any) => Promise<void>;

package/dist/test/fixtures/commands/db/migration/command.js

@@ -0,0 +1,10 @@
+export const describe = 'Database migration command';
+export const builder = (yargs) => {
+    return yargs.option('force', {
+        type: 'boolean',
+        describe: 'Force migration'
+    });
+};
+export const handler = async (argv) => {
+    console.log('Migration handler called');
+};

package/dist/test/importCommand.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/importCommand.test.js

@@ -0,0 +1,21 @@
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+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 () => {
+        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 () => {
+        const nonExistentPath = path.join(__dirname, 'fixtures', 'commands', 'non-existent.ts');
+        await assert.rejects(async () => {
+            await importCommandFromFile(nonExistentPath, 'non-existent', {});
+        }, Error, 'Should throw error for non-existent file');
+    });
+});

package/dist/test/scanDirectory.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/scanDirectory.test.js

@@ -0,0 +1,41 @@
+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');
+        }
+    });
+});

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.3",
+  "version": "0.0.5",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,6 +19,13 @@
     "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",
@@ -38,7 +45,8 @@
   },
   "devDependencies": {
     "@types/node": "^22.10.0",
-    "@types/yargs": "^17.0.33"
+    "@types/yargs": "^17.0.33",
+    "yargs": "^17.0.0"
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",