fix: typecheck errors, CLI precedence over GCL_ env vars, completion support

- Fix TS2559 by widening injectGclVariableEnvVars parameter type
- Fix TS2551 by using type assertion for yargs internal getOptions()
- Use yargs parsed.defaulted to correctly detect CLI-explicit values,
  ensuring CLI always takes precedence over GCL_ env vars even when
  the CLI value matches the option default
- Inject GCL env vars in completion callback so GCL_CWD etc. work
  during tab completion
- Add 12 unit tests for injectGclEnvVars

Author: firecow

src/argv.ts

@@ -22,7 +22,7 @@ async function gitRootPath () {
     return stdout;
 }
 
-export function injectGclVariableEnvVars (argv: {variable?: string[]}, env: Record<string, string | undefined>): void {
+export function injectGclVariableEnvVars (argv: {variable?: string[]; [key: string]: any}, env: Record<string, string | undefined>): void {
     const prefix = "GCL_VARIABLE_";
     for (const [envKey, envValue] of Object.entries(env)) {
         if (!envKey.startsWith(prefix) || envValue == null) continue;
@@ -47,6 +47,7 @@ export function injectGclEnvVars (
     argv: Record<string, any>,
     yargsOptions: YargsOptionsMeta,
     env: Record<string, string | undefined>,
+    defaulted: Record<string, boolean> = {},
 ): void {
     const arrays = new Set(yargsOptions.array.map(String));
     const booleans = new Set(yargsOptions.boolean.map(String));
@@ -65,7 +66,7 @@ export function injectGclEnvVars (
             continue;
         }
 
-        if (argv[key] !== undefined && argv[key] !== yargsOptions.default[key]) continue;
+        if (argv[key] !== undefined && !defaulted[key]) continue;
 
         if (booleans.has(key)) argv[key] = envValue === "true" || envValue === "1";
         else if (numbers.has(key)) argv[key] = Number(envValue);

src/index.ts

@@ -41,8 +41,9 @@ process.on("SIGUSR2", async () => {
         .command({
             handler: async (argv) => {
                 try {
+                    const defaulted: Record<string, boolean> = (yparser as any).parsed?.defaulted ?? {};
                     injectGclVariableEnvVars(argv, process.env);
-                    injectGclEnvVars(argv, yparser.getOptions(), process.env);
+                    injectGclEnvVars(argv, (yparser as any).getOptions(), process.env, defaulted);
                     await handler(argv, new WriteStreamsProcess(), jobs);
                     const failedJobs = Executor.getFailed(jobs);
                     process.exit(failedJobs.length > 0 ? 1 : 0);
@@ -365,6 +366,9 @@ process.on("SIGUSR2", async () => {
                 if (current.startsWith("-")) {
                     completionFilter();
                 } else {
+                    const completionDefaulted: Record<string, boolean> = (yparser as any).parsed?.defaulted ?? {};
+                    injectGclVariableEnvVars(yargsArgv, process.env);
+                    injectGclEnvVars(yargsArgv, (yparser as any).getOptions(), process.env, completionDefaulted);
                     Argv.build({...yargsArgv, autoCompleting: true})
                         .then(argv => state.getPipelineIid(argv.cwd, argv.stateDir).then(pipelineIid => ({argv, pipelineIid})))
                         .then(({argv, pipelineIid}) => Parser.create(argv, new WriteStreamsMock(), pipelineIid, []))

tests/test-cases/gcl-variable-env/integration.test.ts

@@ -1,4 +1,4 @@
-import {injectGclVariableEnvVars} from "../../../src/argv.js";
+import {injectGclVariableEnvVars, injectGclEnvVars} from "../../../src/argv.js";
 import {execFile} from "child_process";
 import {promisify} from "util";
 
@@ -75,6 +75,89 @@ describe("injectGclVariableEnvVars unit tests", () => {
     });
 });
 
+describe("injectGclEnvVars unit tests", () => {
+    const baseOptions = {
+        array: ["volume"],
+        boolean: ["quiet"],
+        number: ["concurrency"],
+        default: {quiet: false, concurrency: 0, cwd: "."},
+        key: {quiet: true, concurrency: true, cwd: true, volume: true, _: true, $0: true, "some-kebab": true},
+    };
+
+    test("injects string env var", () => {
+        const argv: Record<string, any> = {cwd: ".", quiet: false};
+        injectGclEnvVars(argv, baseOptions, {"GCL_CWD": "/tmp/test"}, {cwd: true, quiet: true});
+        expect(argv.cwd).toBe("/tmp/test");
+    });
+
+    test("injects boolean env var", () => {
+        const argv: Record<string, any> = {quiet: false};
+        injectGclEnvVars(argv, baseOptions, {"GCL_QUIET": "true"}, {quiet: true});
+        expect(argv.quiet).toBe(true);
+    });
+
+    test("injects boolean env var from '1'", () => {
+        const argv: Record<string, any> = {quiet: false};
+        injectGclEnvVars(argv, baseOptions, {"GCL_QUIET": "1"}, {quiet: true});
+        expect(argv.quiet).toBe(true);
+    });
+
+    test("injects number env var", () => {
+        const argv: Record<string, any> = {concurrency: 0};
+        injectGclEnvVars(argv, baseOptions, {"GCL_CONCURRENCY": "4"}, {concurrency: true});
+        expect(argv.concurrency).toBe(4);
+    });
+
+    test("splits array env var on semicolons", () => {
+        const argv: Record<string, any> = {volume: []};
+        injectGclEnvVars(argv, baseOptions, {"GCL_VOLUME": "/a:/b;/c:/d"}, {volume: true});
+        expect(argv.volume).toEqual(["/a:/b", "/c:/d"]);
+    });
+
+    test("merges array env var with CLI values", () => {
+        const argv: Record<string, any> = {volume: ["/cli:/path"]};
+        injectGclEnvVars(argv, baseOptions, {"GCL_VOLUME": "/env:/path"}, {});
+        expect(argv.volume).toEqual(["/env:/path", "/cli:/path"]);
+    });
+
+    test("CLI explicit value takes precedence over env", () => {
+        const argv: Record<string, any> = {concurrency: 8};
+        injectGclEnvVars(argv, baseOptions, {"GCL_CONCURRENCY": "4"}, {});
+        expect(argv.concurrency).toBe(8);
+    });
+
+    test("CLI explicit value takes precedence even when matching default", () => {
+        const argv: Record<string, any> = {concurrency: 0};
+        injectGclEnvVars(argv, baseOptions, {"GCL_CONCURRENCY": "4"}, {});
+        expect(argv.concurrency).toBe(0);
+    });
+
+    test("env overrides when value was defaulted", () => {
+        const argv: Record<string, any> = {concurrency: 0};
+        injectGclEnvVars(argv, baseOptions, {"GCL_CONCURRENCY": "4"}, {concurrency: true});
+        expect(argv.concurrency).toBe(4);
+    });
+
+    test("skips keys with hyphens", () => {
+        const argv: Record<string, any> = {};
+        injectGclEnvVars(argv, baseOptions, {"GCL_SOME_KEBAB": "val"}, {});
+        expect(argv["some-kebab"]).toBeUndefined();
+    });
+
+    test("skips _ and $0 keys", () => {
+        const argv: Record<string, any> = {_: [], $0: "bin"};
+        injectGclEnvVars(argv, baseOptions, {"GCL__": "x", "GCL_$0": "y"}, {});
+        expect(argv._).toEqual([]);
+        expect(argv.$0).toBe("bin");
+    });
+
+    test("skips undefined env values", () => {
+        const argv: Record<string, any> = {quiet: false};
+        injectGclEnvVars(argv, baseOptions, {"GCL_QUIET": undefined}, {quiet: true});
+        expect(argv.quiet).toBe(false);
+    });
+});
+
 test("GCL_VARIABLE_* env vars are injected into job output via CLI", async () => {
     const {stdout} = await execFileAsync("bun", ["src/index.ts", "test-job", "--cwd", "tests/test-cases/gcl-variable-env"], {
         env: {