yargs-file-commands 0.0.4 → 0.0.6

package/dist/lib/buildSegmentTree.d.ts

@@ -39,4 +39,5 @@ export declare const buildSegmentTree: (commands: Command[]) => CommandTreeNode[
  * 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

@@ -89,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.js

@@ -1,4 +1,4 @@
-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';
@@ -47,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

@@ -50,6 +50,9 @@ export interface CommandImportModule {
     /** Command handler function */
     handler?: CommandHandler;
 }
+export interface ImportCommandOptions {
+    logLevel?: 'info' | 'debug';
+}
 /**
  * Imports a command module from a file
  * @async
@@ -61,4 +64,4 @@ export interface CommandImportModule {
  * 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) => Promise<CommandModule<{}, {}>>;
+export declare const importCommandFromFile: (filePath: string, name: string, options: ImportCommandOptions) => Promise<CommandModule<{}, {}>>;

package/dist/lib/importCommand.js

@@ -10,9 +10,10 @@ import {} from 'yargs';
  * 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) => {
+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,
@@ -23,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

@@ -7,6 +7,7 @@ export interface ScanDirectoryOptions {
     ignorePatterns?: RegExp[];
     /** File extensions to include in the scan */
     extensions?: string[];
+    logLevel?: 'info' | 'debug';
 }
 /**
  * Recursively scans a directory for command files

package/dist/lib/scanDirectory.js

@@ -14,7 +14,11 @@ import path, { join } from 'path';
  * 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;
+    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) {
@@ -23,12 +27,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: ${path.resolve(fullPath)}`);
+                }
                 return [];
             }
-            const fullPath = join(dirPath, entry);
             const stats = await stat(fullPath);
             if (stats.isDirectory()) {
                 return scanDirectory(fullPath, options);
@@ -37,6 +44,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/test/importCommand.test.js

@@ -7,7 +7,7 @@ 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');
+        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');
@@ -15,7 +15,7 @@ describe('importCommandFromFile', async () => {
     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');
+            await importCommandFromFile(nonExistentPath, 'non-existent', {});
         }, Error, 'Should throw error for non-existent file');
     });
 });

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.4",
+  "version": "0.0.6",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",