yargs-file-commands 0.0.20 → 1.1.0

package/README.md

@@ -2,6 +2,8 @@
 
 [![NPM Package][npm]][npm-url]
 [![NPM Downloads][npm-downloads]][npmtrends-url]
+[![Tests][tests-badge]][tests-url]
+[![Coverage][coverage-badge]][coverage-url]
 
 This Yargs helper function lets you define all your commands as individual files and their file names and directory structure defines via implication your nested command structure.
 
@@ -17,20 +19,30 @@ npm install yargs-file-commands
 
 ## Example
 
+### 1. Setup
+
+First, configure your entry point to scan your commands directory:
+
 ```ts
+import path from 'path';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { fileCommands } from 'yargs-file-commands';
+
 export const main = async () => {
-  const commandsDir = path.join(distDir, 'commands');
+  const commandsDir = path.join(process.cwd(), 'dist/commands');
 
   return yargs(hideBin(process.argv))
-    .scriptName(packageInfo.name!)
-    .version(packageInfo.version!)
+    .scriptName('my-cli')
     .command(
-      await fileCommands({ commandDirs: [commandsDir], logLevel: 'debug' })
+      await fileCommands({ commandDirs: [commandsDir] })
     )
     .help().argv;
 };
 ```
 
+### 2. File Structure
+
 You can use any combination of file names and directories. We support either [NextJS](https://nextjs.org/docs/app/building-your-application/routing/dynamic-routes) or [Remix](https://remix.run/docs/en/main/file-conventions/routes) conventions for interpreting filenames and directories.
 
 ```
@@ -43,123 +55,77 @@ You can use any combination of file names and directories. We support either [Ne
 └── studio.start.ts    // the "studio start" command
 ```
 
-Inside each route handler file, you define your command configuration. The command name defaults to the filename, but you can explicitly specify it using the `command` export to support positional arguments. Here are some examples:
+The above will result in these commands being registered:
 
-```ts
-// commands/studio.start.ts - Basic command using filename as command name
+```
+db migration
+db health
+studio start
+```
 
-import type { ArgumentsCamelCase, Argv } from 'yargs';
-import type { BaseOptions } from '../options.js';
+### 3. Define Commands
 
-export interface Options extends BaseOptions {
-  port?: number;
-}
+Use the `defineCommand` helper to define your commands. This ensures full type safety for your arguments based on the options you define in the `builder`.
 
-export const command = 'start'; // this is optional, it will use the filename if this isn't specified
+**Basic Command (`commands/studio.start.ts`)**
 
-export const describe = 'Studio web interface';
+```ts
+import { defineCommand } from 'yargs-file-commands';
 
-export const builder = (args: Argv): Argv<Options> => {
-  const result = args.option('port', {
+export const command = defineCommand({
+  command: 'start', // Optional: defaults to filename if omitted
+  describe: 'Studio web interface',
+  builder: (yargs) => yargs.option('port', {
     alias: 'p',
     type: 'number',
-    describe: 'Port to listen on'
-  });
-  return result;
-};
-
-export const handler = async (args: ArgumentsCamelCase<Options>) => {
-  const config = await getConfig();
-  // Implementation
-};
+    describe: 'Port to listen on',
+    default: 3000
+  }),
+  handler: async (argv) => {
+    // argv.port is correctly typed as number
+    console.log(`Starting studio on port ${argv.port}`);
+  }
+});
 ```
 
-```ts
-// Command with positional arguments
+**Positional Arguments (`commands/create.ts`)**
 
-export const command = 'create [name]';
-export const describe = 'Create a new migration';
+```ts
+import { defineCommand } from 'yargs-file-commands';
 
-export const builder = (args: Argv): Argv<Options> => {
-  return args.positional('name', {
-    describe: 'Name of the migration',
+export const command = defineCommand({
+  command: 'create <name>', // Define positional args in the command string
+  describe: 'Create a new resource',
+  builder: (yargs) => yargs.positional('name', {
+    describe: 'Name of the resource',
     type: 'string',
     demandOption: true
-  });
-};
-
-export const handler = async (args: ArgumentsCamelCase<Options>) => {
-  // Implementation
-};
-```
-
-```ts
-// Must be named $default.ts - Default command (runs when no command is specified)
-
-export const describe = 'Default command';
-
-export const handler = async (args: ArgumentsCamelCase<Options>) => {
-  console.log('Running default command');
-};
-```
-
-The above will result in these commands being registered:
-
-```
-db migration
-db health
-studio start
+  }),
+  handler: async (argv) => {
+    // argv.name is correctly typed as string
+    console.log(`Creating resource: ${argv.name}`);
+  }
+});
 ```
 
-### Alternative Type-Safe Command Definition
+**Default Command (`commands/$default.ts`)**
 
-YOu can also use this type-safe way to define commands using the `CommandModule` type from yargs directly. This is the preferred method as it provides better TypeScript support and catches potential errors at compile time rather than runtime:
+This command runs when no other command is specified.
 
 ```ts
-import type { ArgumentsCamelCase, CommandModule } from 'yargs';
-
-type TriageArgs = {
-  owner: string;
-  repo: string;
-  issue: number;
-};
+import { defineCommand } from 'yargs-file-commands';
 
-export const command: CommandModule<object, TriageArgs> = {
-  command: 'triage <owner> <repo> <issue>',
-  describe: 'Triage a GitHub issue',
-  builder: {
-    owner: {
-      type: 'string',
-      description: 'GitHub repository owner',
-      demandOption: true
-    },
-    repo: {
-      type: 'string',
-      description: 'GitHub repository name',
-      demandOption: true
-    },
-    issue: {
-      type: 'number',
-      description: 'Issue number',
-      demandOption: true
-    }
-  },
-  handler: async (argv: ArgumentsCamelCase<TriageArgs>) => {
-    // Implementation
+export const command = defineCommand({
+  describe: 'Default command',
+  handler: async (argv) => {
+    console.log('Running default command');
   }
-};
+});
 ```
 
-This approach has several advantages:
-
-- Full TypeScript support with proper type inference
-- Compile-time checking of command structure
-- No risk of misspelling exports
-- Better IDE support with autocompletion
-
 ## Options
 
-The "fileCommands" method takes the following options:
+The `fileCommands` method takes the following options:
 
 **commandDirs**
 
@@ -187,25 +153,19 @@ If you want to contribute, just check out [this git project](https://github.com/
 
 ```sh
 # install dependencies
-npm install
+pnpm install
 
 # build everything
-npm run build
+pnpm run build
 
-# prettify
-npm run format
+# biome
+pnpm run chec
 
-# eslint
-npm run lint
-
-# build and run tests
-npm run test
+# tests
+pnpm vitest
 
 # clean everything, should be like doing a fresh git checkout of the repo.
-npm run clean
-
-# publish the npm package
-npm run publish
+pnpm clean
 
 # run example cli
 npx example-cli
@@ -217,3 +177,7 @@ Underneath the hood, we are using [NX](https://nx.dev) to manage the monorepo an
 [npm-url]: https://www.npmjs.com/package/yargs-file-commands
 [npm-downloads]: https://img.shields.io/npm/dw/yargs-file-commands
 [npmtrends-url]: https://www.npmtrends.com/yargs-file-commands
+[tests-badge]: https://github.com/bhouston/yargs-file-commands/workflows/Tests/badge.svg
+[tests-url]: https://github.com/bhouston/yargs-file-commands/actions/workflows/test.yml
+[coverage-badge]: https://codecov.io/gh/bhouston/yargs-file-commands/branch/main/graph/badge.svg
+[coverage-url]: https://codecov.io/gh/bhouston/yargs-file-commands

package/dist/index.d.ts

@@ -1 +1,2 @@
 export * from './lib/fileCommands.js';
+export * from './lib/defineCommand.js';

package/dist/index.js

@@ -1 +1,3 @@
 export * from './lib/fileCommands.js';
+export * from './lib/defineCommand.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}

package/dist/lib/Command.js

@@ -1 +1,2 @@
 export {};
+//# sourceMappingURL=Command.js.map

package/dist/lib/Command.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Command.js","sourceRoot":"","sources":["../../src/lib/Command.ts"],"names":[],"mappings":""}

package/dist/lib/buildSegmentTree.d.ts

@@ -38,6 +38,6 @@ export declare const buildSegmentTree: (commands: Command[]) => CommandTreeNode[
  * 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 createCommand: (treeNode: CommandTreeNode) => CommandModule<{}, {}>;
 export declare const logCommandTree: (commands: CommandTreeNode[], level?: number) => void;
 export {};

package/dist/lib/buildSegmentTree.js

@@ -27,6 +27,9 @@ function insertIntoTree(treeNodes, command, depth) {
         return;
     }
     const currentSegmentName = command.segments[depth];
+    if (currentSegmentName === undefined) {
+        return;
+    }
     let currentSegment = treeNodes.find((s) => s.segmentName === currentSegmentName);
     // If this is the last segment, create a leaf node
     if (depth === command.segments.length - 1) {
@@ -34,7 +37,7 @@ function insertIntoTree(treeNodes, command, depth) {
             treeNodes.push({
                 type: 'leaf',
                 segmentName: currentSegmentName,
-                command
+                command,
             });
         }
         else if (currentSegment.type === 'internal') {
@@ -47,7 +50,7 @@ function insertIntoTree(treeNodes, command, depth) {
         currentSegment = {
             type: 'internal',
             segmentName: currentSegmentName,
-            children: []
+            children: [],
         };
         treeNodes.push(currentSegment);
     }
@@ -85,7 +88,7 @@ export const createCommand = (treeNode) => {
         },
         handler: async () => {
             // Internal nodes don't need handlers as they'll demand subcommands
-        }
+        },
     };
     return command;
 };
@@ -97,3 +100,4 @@ export const logCommandTree = (commands, level = 0) => {
         }
     });
 };
+//# sourceMappingURL=buildSegmentTree.js.map

package/dist/lib/buildSegmentTree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildSegmentTree.js","sourceRoot":"","sources":["../../src/lib/buildSegmentTree.ts"],"names":[],"mappings":"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"}

package/dist/lib/buildSegmentTree.test.js

@@ -1,7 +1,6 @@
-import assert from 'node:assert/strict';
-import { describe, it } from 'node:test';
-import { buildSegmentTree } from './buildSegmentTree.js';
-describe('buildSegmentTree', async () => {
+import { describe, expect, it, vi } from 'vitest';
+import { buildSegmentTree, createCommand, logCommandTree } from './buildSegmentTree.js';
+describe('buildSegmentTree', () => {
     it('should build correct tree structure', () => {
         const commands = [
             {
@@ -12,8 +11,8 @@ describe('buildSegmentTree', async () => {
                     describe: 'Migration command',
                     handler: async () => {
                         // Test handler
-                    }
-                }
+                    },
+                },
             },
             {
                 fullPath: '/commands/db/health.js',
@@ -23,28 +22,29 @@ describe('buildSegmentTree', async () => {
                     describe: 'Health command',
                     handler: async () => {
                         // Test handler
-                    }
-                }
-            }
+                    },
+                },
+            },
         ];
         const tree = buildSegmentTree(commands);
-        assert.equal(tree.length, 1, 'Should have one root node');
+        expect(tree.length).toBe(1);
         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');
+        expect(rootNode).toBeDefined();
+        if (!rootNode) {
+            throw new Error('Root node should exist');
+        }
+        expect(rootNode.segmentName).toBe('db');
+        expect(rootNode.type).toBe('internal');
         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');
+        expect(rootNode.children.length).toBe(2);
+        const childSegments = rootNode.children.map((child) => child.segmentName).sort();
+        expect(childSegments).toEqual(['health', 'migration']);
     });
     it('should handle empty input', () => {
         const tree = buildSegmentTree([]);
-        assert.equal(tree.length, 0, 'Should return empty array for empty input');
+        expect(tree.length).toBe(0);
     });
     it('should handle single command', () => {
         const commands = [
@@ -56,15 +56,268 @@ describe('buildSegmentTree', async () => {
                     describe: 'Test command',
                     handler: async () => {
                         // Test handler
-                    }
-                }
-            }
+                    },
+                },
+            },
         ];
         const tree = buildSegmentTree(commands);
-        assert.equal(tree.length, 1, 'Should have one node');
+        expect(tree.length).toBe(1);
         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');
+        expect(node).toBeDefined();
+        if (!node) {
+            throw new Error('Node should exist');
+        }
+        expect(node.segmentName).toBe('test');
+        expect(node.type).toBe('leaf');
+    });
+    it('should throw error when directory conflicts with command name (directory first)', () => {
+        const commands = [
+            {
+                fullPath: '/commands/db/migration/command.js',
+                segments: ['db', 'migration'],
+                commandModule: {
+                    command: 'migration',
+                    describe: 'Migration command',
+                    handler: async () => { },
+                },
+            },
+            {
+                fullPath: '/commands/db.js',
+                segments: ['db'],
+                commandModule: {
+                    command: 'db',
+                    describe: 'DB command',
+                    handler: async () => { },
+                },
+            },
+        ];
+        expect(() => buildSegmentTree(commands)).toThrow(/Conflict: db is both a directory and a command/);
+    });
+    it('should throw error when directory conflicts with command name (command first)', () => {
+        const commands = [
+            {
+                fullPath: '/commands/db.js',
+                segments: ['db'],
+                commandModule: {
+                    command: 'db',
+                    describe: 'DB command',
+                    handler: async () => { },
+                },
+            },
+            {
+                fullPath: '/commands/db/migration/command.js',
+                segments: ['db', 'migration'],
+                commandModule: {
+                    command: 'migration',
+                    describe: 'Migration command',
+                    handler: async () => { },
+                },
+            },
+        ];
+        expect(() => buildSegmentTree(commands)).toThrow(/Conflict: db is both a directory and a command/);
+    });
+    it('should handle multiple root commands', () => {
+        const commands = [
+            {
+                fullPath: '/commands/hello.ts',
+                segments: ['hello'],
+                commandModule: {
+                    command: 'hello',
+                    describe: 'Hello command',
+                    handler: async () => { },
+                },
+            },
+            {
+                fullPath: '/commands/world.ts',
+                segments: ['world'],
+                commandModule: {
+                    command: 'world',
+                    describe: 'World command',
+                    handler: async () => { },
+                },
+            },
+        ];
+        const tree = buildSegmentTree(commands);
+        expect(tree.length).toBe(2);
+        expect(tree.map((n) => n.segmentName).sort()).toEqual(['hello', 'world']);
+    });
+    it('should handle nested commands at different depths', () => {
+        const commands = [
+            {
+                fullPath: '/commands/a/b/c.ts',
+                segments: ['a', 'b', 'c'],
+                commandModule: {
+                    command: 'c',
+                    describe: 'C command',
+                    handler: async () => { },
+                },
+            },
+            {
+                fullPath: '/commands/a/d.ts',
+                segments: ['a', 'd'],
+                commandModule: {
+                    command: 'd',
+                    describe: 'D command',
+                    handler: async () => { },
+                },
+            },
+        ];
+        const tree = buildSegmentTree(commands);
+        expect(tree.length).toBe(1);
+        expect(tree[0]?.segmentName).toBe('a');
+        if (tree[0]?.type === 'internal') {
+            expect(tree[0].children.length).toBe(2);
+            const childNames = tree[0].children.map((c) => c.segmentName).sort();
+            expect(childNames).toEqual(['b', 'd']);
+            const bNode = tree[0].children.find((c) => c.segmentName === 'b');
+            if (bNode?.type === 'internal') {
+                expect(bNode.children.length).toBe(1);
+                expect(bNode.children[0]?.segmentName).toBe('c');
+                expect(bNode.children[0]?.type).toBe('leaf');
+            }
+        }
+    });
+});
+describe('createCommand', () => {
+    it('should create command module from leaf node', () => {
+        const command = {
+            fullPath: '/commands/test.ts',
+            segments: ['test'],
+            commandModule: {
+                command: 'test',
+                describe: 'Test command',
+                handler: async () => {
+                    // Test handler
+                },
+            },
+        };
+        const treeNode = {
+            type: 'leaf',
+            segmentName: 'test',
+            command,
+        };
+        const commandModule = createCommand(treeNode);
+        expect(commandModule.command).toBe('test');
+        expect(commandModule.describe).toBe('Test command');
+        expect(commandModule.handler).toBe(command.commandModule.handler);
+    });
+    it('should create command module from internal node with children', () => {
+        const childCommand = {
+            fullPath: '/commands/db/health.ts',
+            segments: ['db', 'health'],
+            commandModule: {
+                command: 'health',
+                describe: 'Health check',
+                handler: async () => { },
+            },
+        };
+        const childTreeNode = {
+            type: 'leaf',
+            segmentName: 'health',
+            command: childCommand,
+        };
+        const internalTreeNode = {
+            type: 'internal',
+            segmentName: 'db',
+            children: [childTreeNode],
+        };
+        const commandModule = createCommand(internalTreeNode);
+        expect(commandModule.command).toBe('db');
+        expect(commandModule.describe).toBe('db commands');
+        expect(commandModule.builder).toBeDefined();
+        expect(commandModule.handler).toBeDefined();
+    });
+    it('should create nested command structure with builder', () => {
+        const healthCommand = {
+            fullPath: '/commands/db/health.ts',
+            segments: ['db', 'health'],
+            commandModule: {
+                command: 'health',
+                describe: 'Health check',
+                handler: async () => { },
+            },
+        };
+        const migrationCommand = {
+            fullPath: '/commands/db/migration.ts',
+            segments: ['db', 'migration'],
+            commandModule: {
+                command: 'migration',
+                describe: 'Migration',
+                handler: async () => { },
+            },
+        };
+        const tree = buildSegmentTree([healthCommand, migrationCommand]);
+        const dbNode = tree[0];
+        if (!dbNode || dbNode.type !== 'internal') {
+            throw new Error('Expected internal node');
+        }
+        const commandModule = createCommand(dbNode);
+        expect(commandModule.command).toBe('db');
+        expect(commandModule.builder).toBeDefined();
+        // Test the builder function
+        if (commandModule.builder && typeof commandModule.builder === 'function') {
+            const mockYargs = {
+                command: vi.fn().mockReturnThis(),
+                demandCommand: vi.fn().mockReturnThis(),
+            };
+            commandModule.builder(mockYargs);
+            expect(mockYargs.command).toHaveBeenCalledTimes(1);
+            expect(mockYargs.demandCommand).toHaveBeenCalledWith(1, 'You must specify a db subcommand');
+        }
+    });
+});
+describe('logCommandTree', () => {
+    it('should log command tree structure', () => {
+        const consoleSpy = vi.spyOn(console, 'debug').mockImplementation(() => { });
+        const commands = [
+            {
+                fullPath: '/commands/db/health.ts',
+                segments: ['db', 'health'],
+                commandModule: {
+                    command: 'health',
+                    describe: 'Health',
+                    handler: async () => { },
+                },
+            },
+            {
+                fullPath: '/commands/hello.ts',
+                segments: ['hello'],
+                commandModule: {
+                    command: 'hello',
+                    describe: 'Hello',
+                    handler: async () => { },
+                },
+            },
+        ];
+        const tree = buildSegmentTree(commands);
+        logCommandTree(tree);
+        expect(consoleSpy).toHaveBeenCalled();
+        const calls = consoleSpy.mock.calls.map((call) => call[0]);
+        expect(calls.some((call) => call.includes('db'))).toBe(true);
+        expect(calls.some((call) => call.includes('health'))).toBe(true);
+        expect(calls.some((call) => call.includes('hello'))).toBe(true);
+        consoleSpy.mockRestore();
+    });
+    it('should log command tree with correct indentation levels', () => {
+        const consoleSpy = vi.spyOn(console, 'debug').mockImplementation(() => { });
+        const commands = [
+            {
+                fullPath: '/commands/a/b/c.ts',
+                segments: ['a', 'b', 'c'],
+                commandModule: {
+                    command: 'c',
+                    describe: 'C',
+                    handler: async () => { },
+                },
+            },
+        ];
+        const tree = buildSegmentTree(commands);
+        logCommandTree(tree, 2);
+        expect(consoleSpy).toHaveBeenCalled();
+        const calls = consoleSpy.mock.calls.map((call) => call[0]);
+        // Check for indentation (initial level 2 = 4 spaces, then children add more)
+        expect(calls.length).toBeGreaterThan(0);
+        consoleSpy.mockRestore();
     });
 });
+//# sourceMappingURL=buildSegmentTree.test.js.map