fix: separate global/component input namespaces, extract shared isStructured helper

Addresses review feedback:
- Separate global and component CLI inputs into _global/_components
  namespaces in argv.input to prevent key collisions (#2)
- Extract isStructuredInputsFile() and getGlobalFileInputs() to Utils
  to deduplicate detection logic in parser.ts and parser-includes.ts (#3)
- Add test for namespace collision scenario

Author: Gyan Ranjan A

src/argv.ts

@@ -223,9 +223,10 @@ export class Argv {
         return variables;
     }
 
-    get input (): {[key: string]: any} {
+    get input (): {_global: {[key: string]: any}; _components: {[key: string]: {[key: string]: any}}} {
         const val = this.map.get("input");
-        const inputs: {[key: string]: any} = {};
+        const _global: {[key: string]: any} = {};
+        const _components: {[key: string]: {[key: string]: any}} = {};
         const pairs = typeof val == "string" ? val.split(" ") : val;
         const dangerousKeys = new Set(["__proto__", "constructor", "prototype"]);
         (pairs ?? []).forEach((inputPair: string) => {
@@ -249,16 +250,14 @@ export class Argv {
                 }
 
                 if (component) {
-                    // Component-specific input: store under component namespace
-                    if (!inputs[component]) inputs[component] = {};
-                    inputs[component][key] = parsedValue;
+                    if (!_components[component]) _components[component] = {};
+                    _components[component][key] = parsedValue;
                 } else {
-                    // Global input
-                    inputs[key] = parsedValue;
+                    _global[key] = parsedValue;
                 }
             }
         });
-        return inputs;
+        return {_global, _components};
     }
 
     get unsetVariables (): string[] {

src/parser-includes.ts

@@ -57,24 +57,11 @@ export class ParserIncludes {
     static async init (gitlabData: any, opts: ParserIncludesInitOptions): Promise<any[]> {
         const {argv, inputs: inputsConfig} = opts;
         const fileInputs = inputsConfig._file ?? {};
-        const cliInputs = inputsConfig._cli ?? {};
-
-        // Extract global CLI inputs (non-component-specific)
-        const cliGlobalInputs: {[key: string]: any} = {};
-        const cliComponentInputs: {[key: string]: any} = {};
-        for (const [key, value] of Object.entries(cliInputs)) {
-            if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-                // This is a component-specific input (e.g., {deploy: {replicas: 5}})
-                cliComponentInputs[key] = value;
-            } else {
-                // This is a global input
-                cliGlobalInputs[key] = value;
-            }
-        }
+        const cliGlobalInputs = inputsConfig._cliGlobal ?? {};
+        const cliComponentInputs = inputsConfig._cliComponents ?? {};
 
-        // If file has _global key, use structured format; otherwise treat entire file as global
-        const isStructured = fileInputs._global !== undefined || Object.keys(fileInputs).some(k => !k.startsWith("_") && typeof fileInputs[k] === "object" && fileInputs[k] !== null && !Array.isArray(fileInputs[k]));
-        const globalInputs = isStructured ? {...(fileInputs._global ?? {}), ...cliGlobalInputs} : {...fileInputs, ...cliGlobalInputs};
+        const isStructured = Utils.isStructuredInputsFile(fileInputs);
+        const globalInputs = {...Utils.getGlobalFileInputs(fileInputs), ...cliGlobalInputs};
         this.count++;
         assert(
             this.count <= opts.maximumIncludes + 1, // 1st init call is not counted

src/parser.ts

@@ -108,17 +108,8 @@ export class Parser {
         const inputs = await this.loadInputs(cwd, argv);
 
         // Build root-level inputs from global CLI + global file inputs
-        const cliInputs = inputs._cli ?? {};
         const fileInputs = inputs._file ?? {};
-        const globalCliInputs: {[key: string]: any} = {};
-        for (const [k, v] of Object.entries(cliInputs)) {
-            if (typeof v !== "object" || v === null || Array.isArray(v)) {
-                globalCliInputs[k] = v;
-            }
-        }
-        const isStructuredFile = fileInputs._global !== undefined || Object.keys(fileInputs).some(k => !k.startsWith("_") && typeof fileInputs[k] === "object" && fileInputs[k] !== null && !Array.isArray(fileInputs[k]));
-        const fileGlobalInputs = isStructuredFile ? (fileInputs._global ?? {}) : fileInputs;
-        const rootInputs = {...fileGlobalInputs, ...globalCliInputs};
+        const rootInputs = {...Utils.getGlobalFileInputs(fileInputs), ...inputs._cliGlobal};
 
         let yamlDataList: any[] = [{stages: [".pre", "build", "test", "deploy", ".post"]}];
         const gitlabCiData = await Parser.loadYaml(`${cwd}/${file}`, {inputs: rootInputs}, this.expandVariables, writeStreams);
@@ -258,8 +249,8 @@ export class Parser {
             }
         }
 
-        // Return both file inputs and CLI inputs separately for component-specific merging
-        return {_file: fileInputs, _cli: argv.input};
+        const cliInput = argv.input;
+        return {_file: fileInputs, _cliGlobal: cliInput._global, _cliComponents: cliInput._components};
     }
 
     static async loadYaml (filePath: string, ctx: any = {}, expandVariables: boolean = true, writeStreams?: WriteStreams): Promise<any> {

src/utils.ts

@@ -550,4 +550,12 @@ export class Utils {
         // Return the first alias in the set
         return aliases.values().next().value!;
     }
+
+    static isStructuredInputsFile (fileInputs: {[key: string]: any}): boolean {
+        return fileInputs._global !== undefined || Object.keys(fileInputs).some(k => !k.startsWith("_") && typeof fileInputs[k] === "object" && fileInputs[k] !== null && !Array.isArray(fileInputs[k]));
+    }
+
+    static getGlobalFileInputs (fileInputs: {[key: string]: any}): {[key: string]: any} {
+        return Utils.isStructuredInputsFile(fileInputs) ? (fileInputs._global ?? {}) : {...fileInputs};
+    }
 }

tests/argv-input.test.ts

@@ -11,31 +11,38 @@ beforeEach(() => {
 test("input parses component names with slashes", async () => {
     const argv = await Argv.build({input: ["templates/deploy:replicas=5"]}, writeStreams);
     const result = argv.input;
-    expect(result["templates/deploy"]).toEqual({replicas: 5});
+    expect(result._components["templates/deploy"]).toEqual({replicas: 5});
 });
 
 test("input keeps global and component keys separate", async () => {
     const argv = await Argv.build({input: ["deploy:replicas=5", "environment=prod"]}, writeStreams);
     const result = argv.input;
-    expect(result["deploy"]).toEqual({replicas: 5});
-    expect(result["environment"]).toEqual("prod");
+    expect(result._components["deploy"]).toEqual({replicas: 5});
+    expect(result._global["environment"]).toEqual("prod");
 });
 
 test("input ignores __proto__ component to prevent prototype pollution", async () => {
     const argv = await Argv.build({input: ["__proto__:polluted=true"]}, writeStreams);
     const result = argv.input;
-    expect(Object.hasOwn(result, "__proto__")).toBe(false);
+    expect(Object.hasOwn(result._components, "__proto__")).toBe(false);
     expect(({} as any).polluted).toBeUndefined();
 });
 
 test("input ignores __proto__ key to prevent prototype pollution", async () => {
     const argv = await Argv.build({input: ["__proto__=true"]}, writeStreams);
     const result = argv.input;
-    expect(Object.keys(result)).not.toContain("__proto__");
+    expect(Object.keys(result._global)).not.toContain("__proto__");
 });
 
 test("input ignores constructor key to prevent prototype pollution", async () => {
     const argv = await Argv.build({input: ["constructor:toString=bad"]}, writeStreams);
     const result = argv.input;
-    expect(Object.hasOwn(result, "constructor")).toBe(false);
+    expect(Object.hasOwn(result._components, "constructor")).toBe(false);
+});
+
+test("input namespace collision: same key as global and component name", async () => {
+    const argv = await Argv.build({input: ["deploy=prod", "deploy:replicas=5"]}, writeStreams);
+    const result = argv.input;
+    expect(result._global["deploy"]).toEqual("prod");
+    expect(result._components["deploy"]).toEqual({replicas: 5});
 });