cli-forge 1.1.0 → 1.2.0

package/src/lib/composable-builder.spec.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect } from 'vitest';
+import { makeComposableBuilder } from './composable-builder';
+import cli from './public-api';
+import { chain } from '@cli-forge/parser';
+
+describe('makeComposableBuilder', () => {
+  describe('capture-and-replay', () => {
+    it('should produce stable middleware references across applications', () => {
+      const builder = makeComposableBuilder((cmd) =>
+        cmd
+          .option('verbose', { type: 'boolean' })
+          .middleware((args: any) => args)
+      );
+
+      const cli1 = builder(cli('test1'));
+      const cli2 = builder(cli('test2'));
+
+      const mw1 = [...(cli1 as any).registeredMiddleware];
+      const mw2 = [...(cli2 as any).registeredMiddleware];
+      expect(mw1.length).toBe(1);
+      expect(mw2.length).toBe(1);
+      expect(mw1[0]).toBe(mw2[0]);
+    });
+
+    it('should correctly replay option registrations', async () => {
+      const builder = makeComposableBuilder((cmd) =>
+        cmd.option('verbose', { type: 'boolean' })
+      );
+
+      let handlerArgs: any;
+      await chain(cli('test'), builder)
+        .command('$0', {
+          handler: (args) => {
+            handlerArgs = args;
+          },
+        })
+        .forge(['--verbose']);
+      expect(handlerArgs.verbose).toBe(true);
+    });
+
+    it('should deduplicate middleware when builder applied to parent and child', async () => {
+      let mwCallCount = 0;
+      const builder = makeComposableBuilder((cmd) =>
+        cmd.option('verbose', { type: 'boolean' }).middleware((args: any) => {
+          mwCallCount++;
+          return args;
+        })
+      );
+
+      await chain(cli('parent'), builder)
+        .command('child', {
+          builder: (cmd) =>
+            chain(cmd, builder).option('format', { type: 'string' }),
+          handler: () => { /* noop */ },
+        })
+        .forge(['child']);
+      expect(mwCallCount).toBe(1);
+    });
+
+    it('should replay commands registered by the builder', () => {
+      const builder = makeComposableBuilder((cmd) =>
+        cmd.command('sub', {
+          builder: (c) => c.option('flag', { type: 'boolean' }),
+          handler: () => { /* noop */ },
+        })
+      );
+
+      const myCli = builder(cli('test'));
+      const children = myCli.getChildren();
+      expect(children).toHaveProperty('sub');
+    });
+  });
+});

package/src/lib/composable-builder.ts

@@ -1,4 +1,4 @@
-import { ParsedArgs } from '@cli-forge/parser';
+import type { ParsedArgs } from '@cli-forge/parser';
 import { CLI } from './public-api';
 
 /**
@@ -30,6 +30,10 @@ export type ComposableBuilder<
  * Can be used to add options, commands, or any other CLI modifications.
  * Children added by the builder function are properly tracked in the type.
  *
+ * The builder function runs once at creation time against a recording Proxy.
+ * Subsequent applications replay the captured operations, ensuring inline
+ * middleware closures have stable references for Set-based deduplication.
+ *
  * @typeParam TArgs2 - The args type after the builder runs
  * @typeParam TChildren2 - The children type added by the builder
  */
@@ -43,15 +47,32 @@ export function makeComposableBuilder<
     init: CLI<ParsedArgs, any, {}, any>
   ) => CLI<TArgs2, any, TChildren2, any>
 ) {
+  // Run builder once against a recording proxy to capture operations.
+  // Replaying these ensures inline closures (e.g. middleware) keep stable
+  // references across applications, enabling Set-based deduplication.
+  const operations: { method: string; args: any[] }[] = [];
+  const proxy = new Proxy({} as CLI, {
+    get(_target, prop) {
+      return (...args: any[]) => {
+        operations.push({ method: prop as string, args });
+        return proxy;
+      };
+    },
+  });
+  fn(proxy);
+
   return <TInit extends ParsedArgs, THandlerReturn, TChildren, TParent>(
     init: CLI<TInit, THandlerReturn, TChildren, TParent>
-  ) =>
-    // eslint-disable-next-line @typescript-eslint/ban-types
-    fn(init as unknown as CLI<ParsedArgs, any, {}, any>) as unknown as CLI<
+  ) => {
+    let current: any = init;
+    for (const op of operations) {
+      current = current[op.method](...op.args);
+    }
+    return current as unknown as CLI<
       TInit & TArgs2,
       THandlerReturn,
       TChildren & TChildren2,
       TParent
     >;
+  };
 }
-

package/src/lib/interactive-shell.ts

@@ -58,6 +58,8 @@ export class InteractiveShell {
         process.emit('SIGINT');
       });
 
+    // Show the cursor (in case it was hidden)
+    process.stdout.write('\x1b[?25h');
     this.rl.prompt();
 
     this.registerLineListener(async (line) => {