@zokugun/artifact 0.5.1 → 0.6.0

package/lib/types/config.d.ts

@@ -0,0 +1,58 @@
+export type Request = {
+    name: string;
+    variant?: string;
+};
+export type PackageManifest = {
+    name: string;
+    version: string;
+};
+export type PackageConfig = {
+    constants: Record<string, string>;
+    extends?: string;
+    install: Record<string, FileInstall>;
+    orphan: boolean;
+    uninstall: Record<string, FileUninstall>;
+    update: false | Record<string, FileUpdate>;
+    variables: Record<string, string>;
+    variants: Record<string, string>;
+};
+export type Artifact = {
+    version: string;
+    provides?: string[];
+    requires?: string[];
+};
+export type ArtifactResult = Artifact & {
+    name: string;
+};
+export type InstallConfig = {
+    artifacts: Record<string, Artifact>;
+    constants: Record<string, string>;
+    install: Record<string, FileInstall>;
+    update: false | Record<string, FileUpdate>;
+    variables: Record<string, string>;
+};
+export type FileAlways = {
+    ifExists: 'force-merge' | 'merge' | 'overwrite' | 'remove' | 'skip';
+    transforms: FileTransform[];
+};
+export type FileUpsert = FileAlways & {
+    filter?: string[];
+    ifMissing: 'merge' | 'skip';
+    rename?: string;
+    route?: Record<string, any>;
+};
+export type FileInstall = FileUpsert & {};
+export type FileUninstall = {
+    ifExists: 'remove' | 'skip' | 'unmerge';
+    transforms: FileTransform[];
+};
+export type FileUpdate = FileUpsert & {};
+export type FileTransform = {
+    description?: string;
+    jq: string;
+};
+export type InstallConfigStats = {
+    name: string;
+    type: string;
+    finalNewLine: boolean;
+};

package/lib/types/context.d.ts

@@ -0,0 +1,56 @@
+import { type AsyncDResult } from '@zokugun/xtry';
+import { type BinaryFile } from './binary-file.js';
+import { type Request, type InstallConfig, type PackageConfig, type ArtifactResult, type PackageManifest, type FileTransform } from './config.js';
+import { type Format } from './format.js';
+import { type TextFile } from './text-file.js';
+import { type Journey } from './travel.js';
+export type ExistingAction = 'merge' | 'overwrite' | 'skip';
+export type MissingAction = 'continue' | 'skip';
+export type RenameAction = {
+    from: string;
+    to: string;
+};
+export type Context = {
+    binaryFiles: BinaryFile[];
+    blocks: Block[];
+    commonFlow: CommonFlow;
+    config: InstallConfig;
+    filters: (file: string) => string[] | undefined;
+    formats: Format[];
+    incomingName?: string;
+    incomingVersion?: string;
+    incomingVariant?: string;
+    incomingBranch?: string;
+    incomingConfig?: PackageConfig;
+    incomingPackage?: PackageManifest;
+    incomingPath: string;
+    mergedTextFiles: TextFile[];
+    onExisting: (file: string) => ExistingAction;
+    onMissing: (file: string) => MissingAction;
+    options: Options;
+    packagePath: string;
+    removedPatterns: string[];
+    renamedPatterns: RenameAction[];
+    request: Request;
+    result?: ArtifactResult;
+    routes: (file: string) => Journey | undefined;
+    targetPath: string;
+    textFiles: TextFile[];
+    transformedFiles: TextFile[];
+    transforms: (file: string) => FileTransform[] | undefined;
+};
+export type MainFlow = (targetPath: string, incomingPath: string, request: Request, config: InstallConfig, options: Options) => AsyncDResult<Context | undefined>;
+export type CommonFlow = (name: string, version: string, variant: string | undefined, branch: string | undefined, incomingPath: string, commonContext: Context) => AsyncDResult<Context | undefined>;
+export type Options = {
+    force: boolean;
+    skip: boolean;
+    verbose: boolean;
+    dryRun: boolean;
+};
+export type Block = {
+    name: string;
+    version: string;
+    variant?: string;
+    branch?: string;
+    incomingPath: string;
+};

package/lib/types/format.d.ts

@@ -0,0 +1,10 @@
+export declare enum IndentStyle {
+    SPACE = "space",
+    TAB = "tab"
+}
+export type Format = {
+    glob: string;
+    indentStyle: IndentStyle;
+    indentSize: number;
+    insertFinalNewline: boolean;
+};

package/lib/types/step.d.ts

@@ -0,0 +1,3 @@
+import { type AsyncDResult } from '@zokugun/xtry';
+import { type Context } from './context.js';
+export type Step = (context: Context) => AsyncDResult<boolean | void>;

package/lib/types/text-file.d.ts

@@ -0,0 +1,7 @@
+export type TextFile = {
+    data: string;
+    finalNewLine: boolean;
+    indent?: string;
+    mode?: number;
+    name: string;
+};

package/lib/types/travel.d.ts

@@ -0,0 +1,14 @@
+import { type FileTransform } from './config.js';
+export type Args<T> = {
+    current: T | undefined;
+    incoming: T | undefined;
+    filters?: string[];
+    ignores?: string[];
+    transforms?: FileTransform[];
+};
+export type Route<T> = (args: Args<T>) => Promise<T>;
+export type TravelPlan = (basename: string) => Route<string> | undefined;
+export type Journey = {
+    alias?: string;
+    travel: Route<string>;
+};

package/lib/utils/apply-transforms.d.ts

@@ -0,0 +1,2 @@
+import { type FileTransform } from '../types/config.js';
+export declare function applyTransforms(transforms: FileTransform[] | undefined): (data: Record<string, unknown>) => Promise<Record<string, unknown>>;

package/lib/utils/apply-transforms.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyTransforms = applyTransforms;
+const jq = __importStar(require("jq-wasm"));
+function applyTransforms(transforms) {
+    if (!transforms) {
+        return async (data) => data;
+    }
+    return async (data) => {
+        for (const transform of transforms) {
+            data = await jq.json(data, transform.jq);
+        }
+        return data;
+    };
+}

package/lib/utils/build-journey-plan.d.ts

@@ -0,0 +1,2 @@
+import { type Journey, type TravelPlan } from '../types/travel.js';
+export declare function buildJourneyPlan(plan: TravelPlan, alias?: string): (basename: string) => Journey | undefined;

package/lib/utils/build-route.d.ts

@@ -0,0 +1,3 @@
+import { type DResult } from '@zokugun/xtry';
+import { type Route } from '../types/travel.js';
+export declare function buildRoute(route: any): DResult<Route<any>>;

package/lib/utils/build-route.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildRoute = buildRoute;
+const is_it_type_1 = require("@zokugun/is-it-type");
+const xtry_1 = require("@zokugun/xtry");
+const fork_js_1 = require("../compositors/fork.js");
+const index_js_1 = require("../compositors/index.js");
+const index_js_2 = require("../routes/index.js");
+function buildRoute(route) {
+    if (Array.isArray(route) && route.length > 0) {
+        const buildResult = buildRoute(route[0]);
+        if (buildResult.fails) {
+            return buildResult;
+        }
+        let result = buildResult.value;
+        for (let i = 1; i < route.length; i++) {
+            if (route[i] === 'mapSort') {
+                result = (0, index_js_1.mapSort)(result);
+            }
+            else {
+                return (0, xtry_1.err)('Can\'t build route');
+            }
+        }
+        return (0, xtry_1.ok)(result);
+    }
+    else if ((0, is_it_type_1.isRecord)(route)) {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const { compose: rtCompose, fork: rtFork, mapSort: rtMapSort } = route;
+        if (rtCompose) {
+            const map = {};
+            for (const [name, route] of Object.entries(rtCompose)) {
+                const result = buildRoute(route);
+                if (result.fails) {
+                    return result;
+                }
+                map[name] = result.value;
+            }
+            return (0, xtry_1.ok)((0, index_js_1.compose)(map));
+        }
+        else if (rtFork) {
+            const map = [];
+            if (rtFork.array) {
+                const result = buildRoute(rtFork.array);
+                if (result.fails) {
+                    return result;
+                }
+                map.push([Array.isArray, result.value]);
+            }
+            if (rtFork.object) {
+                const result = buildRoute(rtFork.object);
+                if (result.fails) {
+                    return result;
+                }
+                map.push([is_it_type_1.isRecord, result.value]);
+            }
+            if (rtFork.default) {
+                const result = buildRoute(rtFork.default);
+                if (result.fails) {
+                    return result;
+                }
+                map.push(result.value);
+            }
+            return (0, xtry_1.ok)((0, fork_js_1.fork)(...map));
+        }
+        else if (rtMapSort) {
+            const result = buildRoute(rtMapSort);
+            if (result.fails) {
+                return result;
+            }
+            return (0, xtry_1.ok)((0, index_js_1.mapSort)(result.value));
+        }
+    }
+    else if (route === 'command') {
+        return (0, xtry_1.ok)(index_js_2.command);
+    }
+    else if (route === 'linesConcat') {
+        return (0, xtry_1.ok)(index_js_2.linesConcat);
+    }
+    else if (route === 'listConcat') {
+        return (0, xtry_1.ok)(index_js_2.listConcat);
+    }
+    else if (route === 'mapConcat') {
+        return (0, xtry_1.ok)(index_js_2.mapConcat);
+    }
+    else if (route === 'overwrite') {
+        return (0, xtry_1.ok)(index_js_2.overwrite);
+    }
+    else if (route === 'primitive') {
+        return (0, xtry_1.ok)(index_js_2.primitive);
+    }
+    return (0, xtry_1.err)('Can\'t build route');
+} // }}}

package/lib/utils/build-travel-plan.d.ts

@@ -0,0 +1,2 @@
+import { type Route, type TravelPlan } from '../types/travel.js';
+export declare function buildTravelPlan(...mappers: Array<[RegExp | string, Route<string>]>): TravelPlan;

package/lib/utils/build-travel.d.ts

@@ -0,0 +1,3 @@
+import { type DResult } from '@zokugun/xtry';
+import { type Route } from '../types/travel.js';
+export declare function buildTravel(route: Record<string, any>): DResult<Route<string>>;

package/lib/utils/build-travel.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTravel = buildTravel;
+const xtry_1 = require("@zokugun/xtry");
+const index_js_1 = require("../compositors/index.js");
+const build_route_js_1 = require("./build-route.js");
+function buildTravel(route) {
+    if (route.json) {
+        const result = (0, build_route_js_1.buildRoute)(route.json);
+        if (result.fails) {
+            return result;
+        }
+        return (0, xtry_1.ok)((0, index_js_1.json)(result.value));
+    }
+    else if (route.rc) {
+        const result = (0, build_route_js_1.buildRoute)(route.rc);
+        if (result.fails) {
+            return result;
+        }
+        return (0, xtry_1.ok)((0, index_js_1.rc)(result.value));
+    }
+    else if (route.yaml) {
+        const result = (0, build_route_js_1.buildRoute)(route.yaml);
+        if (result.fails) {
+            return result;
+        }
+        return (0, xtry_1.ok)((0, index_js_1.yaml)(result.value));
+    }
+    else {
+        return (0, xtry_1.err)('Can\'t build route');
+    }
+} // }}}

package/lib/utils/command/dedupe-strings.d.ts

@@ -0,0 +1 @@
+export declare function dedupeStrings(items: string[]): string[];

package/lib/utils/command/index.d.ts

@@ -0,0 +1,8 @@
+export type { Command } from '../../types/command.js';
+export { joinCommand } from './join-command.js';
+export { mergeAndChains } from './merge-and-chains.js';
+export { mergeCommandRecords } from './merge-command-records.js';
+export { mergeOrSegments } from './merge-or-segments.js';
+export { mergeSemicolonSegments } from './merge-semicolon-segments.js';
+export { mergeWithSemicolonMix } from './merge-with-semicolon-mix.js';
+export { splitCommand } from './split-command.js';

package/lib/utils/command/index.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.splitCommand = exports.mergeWithSemicolonMix = exports.mergeSemicolonSegments = exports.mergeOrSegments = exports.mergeCommandRecords = exports.mergeAndChains = exports.joinCommand = void 0;
-var join_command_1 = require("./join-command");
-Object.defineProperty(exports, "joinCommand", { enumerable: true, get: function () { return join_command_1.joinCommand; } });
-var merge_and_chains_1 = require("./merge-and-chains");
-Object.defineProperty(exports, "mergeAndChains", { enumerable: true, get: function () { return merge_and_chains_1.mergeAndChains; } });
-var merge_command_records_1 = require("./merge-command-records");
-Object.defineProperty(exports, "mergeCommandRecords", { enumerable: true, get: function () { return merge_command_records_1.mergeCommandRecords; } });
-var merge_or_segments_1 = require("./merge-or-segments");
-Object.defineProperty(exports, "mergeOrSegments", { enumerable: true, get: function () { return merge_or_segments_1.mergeOrSegments; } });
-var merge_semicolon_segments_1 = require("./merge-semicolon-segments");
-Object.defineProperty(exports, "mergeSemicolonSegments", { enumerable: true, get: function () { return merge_semicolon_segments_1.mergeSemicolonSegments; } });
-var merge_with_semicolon_mix_1 = require("./merge-with-semicolon-mix");
-Object.defineProperty(exports, "mergeWithSemicolonMix", { enumerable: true, get: function () { return merge_with_semicolon_mix_1.mergeWithSemicolonMix; } });
-var split_command_1 = require("./split-command");
-Object.defineProperty(exports, "splitCommand", { enumerable: true, get: function () { return split_command_1.splitCommand; } });
+var join_command_js_1 = require("./join-command.js");
+Object.defineProperty(exports, "joinCommand", { enumerable: true, get: function () { return join_command_js_1.joinCommand; } });
+var merge_and_chains_js_1 = require("./merge-and-chains.js");
+Object.defineProperty(exports, "mergeAndChains", { enumerable: true, get: function () { return merge_and_chains_js_1.mergeAndChains; } });
+var merge_command_records_js_1 = require("./merge-command-records.js");
+Object.defineProperty(exports, "mergeCommandRecords", { enumerable: true, get: function () { return merge_command_records_js_1.mergeCommandRecords; } });
+var merge_or_segments_js_1 = require("./merge-or-segments.js");
+Object.defineProperty(exports, "mergeOrSegments", { enumerable: true, get: function () { return merge_or_segments_js_1.mergeOrSegments; } });
+var merge_semicolon_segments_js_1 = require("./merge-semicolon-segments.js");
+Object.defineProperty(exports, "mergeSemicolonSegments", { enumerable: true, get: function () { return merge_semicolon_segments_js_1.mergeSemicolonSegments; } });
+var merge_with_semicolon_mix_js_1 = require("./merge-with-semicolon-mix.js");
+Object.defineProperty(exports, "mergeWithSemicolonMix", { enumerable: true, get: function () { return merge_with_semicolon_mix_js_1.mergeWithSemicolonMix; } });
+var split_command_js_1 = require("./split-command.js");
+Object.defineProperty(exports, "splitCommand", { enumerable: true, get: function () { return split_command_js_1.splitCommand; } });

package/lib/utils/command/join-command.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from '../../types/command.js';
+export declare function joinCommand(commands: Record<string, Command[]>): string;

package/lib/utils/command/merge-and-chains.d.ts

@@ -0,0 +1 @@
+export declare function mergeAndChains(current: string, incoming: string): string | undefined;

package/lib/utils/command/merge-and-chains.js

@@ -1,35 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeAndChains = mergeAndChains;
-const dedupe_strings_1 = require("./dedupe-strings");
-const merge_flags_as_string_1 = require("./merge-flags-as-string");
-const merge_parts_by_prefix_1 = require("./merge-parts-by-prefix");
-const prefix_of_command_1 = require("./prefix-of-command");
-const split_chain_1 = require("./split-chain");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
-const split_segments_1 = require("./split-segments");
+const dedupe_strings_js_1 = require("./dedupe-strings.js");
+const merge_flags_as_string_js_1 = require("./merge-flags-as-string.js");
+const merge_parts_by_prefix_js_1 = require("./merge-parts-by-prefix.js");
+const prefix_of_command_js_1 = require("./prefix-of-command.js");
+const split_chain_js_1 = require("./split-chain.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
+const split_segments_js_1 = require("./split-segments.js");
 function mergeAndChains(current, incoming) {
     if (!(incoming.includes('&&') && current.includes('&&'))) {
         return;
     }
     const currentMain = (current.split(';')[0] || '').trim();
     const incomingMain = (incoming.split(';')[0] || '').trim();
-    const currentAnd = (0, split_chain_1.splitChain)(currentMain, '&&');
-    const incomingAnd = (0, split_chain_1.splitChain)(incomingMain, '&&');
+    const currentAnd = (0, split_chain_js_1.splitChain)(currentMain, '&&');
+    const incomingAnd = (0, split_chain_js_1.splitChain)(incomingMain, '&&');
     // Consider positional match primarily by the first segment's prefix
     const firstCurrent = currentAnd[0] || '';
     const firstIncoming = incomingAnd[0] || '';
-    const positionalMatch = (0, prefix_of_command_1.prefixOfCommand)(firstCurrent) === (0, prefix_of_command_1.prefixOfCommand)(firstIncoming);
+    const positionalMatch = (0, prefix_of_command_js_1.prefixOfCommand)(firstCurrent) === (0, prefix_of_command_js_1.prefixOfCommand)(firstIncoming);
     if (!positionalMatch) {
         // Merge by matching prefixes across current segments, append unmatched incoming segments.
-        const merged = (0, merge_parts_by_prefix_1.mergePartsByPrefix)(currentAnd, incomingAnd);
+        const merged = (0, merge_parts_by_prefix_js_1.mergePartsByPrefix)(currentAnd, incomingAnd);
         return merged.join('; ');
     }
     // Positional merge: iterate positions, merge flags when prefixes equal, otherwise
     // decide ordering: if incoming's semicolon tail contains current segment, prefer incoming in chain and move current to tail;
     // else keep current in chain then append incoming segment after it.
-    const incomingTail = (0, split_segments_1.splitSegments)(incoming).slice(1);
-    const currentTail = (0, split_segments_1.splitSegments)(current).slice(1);
+    const incomingTail = (0, split_segments_js_1.splitSegments)(incoming).slice(1);
+    const currentTail = (0, split_segments_js_1.splitSegments)(current).slice(1);
     const maxLength = Math.max(currentAnd.length, incomingAnd.length);
     const chainResult = [];
     const tailResult = [];
@@ -37,14 +37,14 @@ function mergeAndChains(current, incoming) {
         const currentPart = currentAnd[i];
         const incomingPart = incomingAnd[i];
         if (currentPart && incomingPart) {
-            const cPref = (0, prefix_of_command_1.prefixOfCommand)(currentPart);
-            const nPref = (0, prefix_of_command_1.prefixOfCommand)(incomingPart);
+            const cPref = (0, prefix_of_command_js_1.prefixOfCommand)(currentPart);
+            const nPref = (0, prefix_of_command_js_1.prefixOfCommand)(incomingPart);
             if (cPref && nPref && cPref === nPref) {
                 if (incomingTail.length > 0) {
-                    chainResult.push((0, merge_flags_as_string_1.mergeFlagsAsString)(incomingPart, (0, split_prefix_and_flags_1.splitPrefixAndFlags)(currentPart)));
+                    chainResult.push((0, merge_flags_as_string_js_1.mergeFlagsAsString)(incomingPart, (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentPart)));
                 }
                 else {
-                    chainResult.push((0, merge_flags_as_string_1.mergeFlagsAsString)(currentPart, (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingPart)));
+                    chainResult.push((0, merge_flags_as_string_js_1.mergeFlagsAsString)(currentPart, (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingPart)));
                 }
             }
             else {
@@ -55,11 +55,20 @@ function mergeAndChains(current, incoming) {
                     tailResult.push(currentPart);
                 }
                 else {
-                    // keep current in chain, then include incoming after
-                    chainResult.push(currentPart);
-                    const coveredByCurrentTail = currentTail.some((t) => t.startsWith(`${incomingPart} `));
-                    if (!coveredByCurrentTail) {
-                        chainResult.push(incomingPart);
+                    const currentAppearsLaterInIncoming = incomingAnd
+                        .slice(i + 1)
+                        .some((later) => (0, prefix_of_command_js_1.prefixOfCommand)(later) === cPref);
+                    if (currentAppearsLaterInIncoming) {
+                        // Incoming inserted a step before current and shifted current to the right.
+                        chainResult.push(incomingPart, currentPart);
+                    }
+                    else {
+                        // keep current in chain, then include incoming after
+                        chainResult.push(currentPart);
+                        const coveredByCurrentTail = currentTail.some((t) => t.startsWith(`${incomingPart} `));
+                        if (!coveredByCurrentTail) {
+                            chainResult.push(incomingPart);
+                        }
                     }
                 }
             }
@@ -71,12 +80,12 @@ function mergeAndChains(current, incoming) {
             chainResult.push(incomingPart);
         }
     }
-    const dedupedChain = (0, dedupe_strings_1.dedupeStrings)(chainResult);
+    const dedupedChain = (0, dedupe_strings_js_1.dedupeStrings)(chainResult);
     // Append any remaining semicolon tails from current and incoming (preserve incoming tail order)
     // remove any tail entries that are already present in the chainResult (by prefix)
-    const chainPrefixes = new Set(dedupedChain.map(prefix_of_command_1.prefixOfCommand).filter(Boolean));
+    const chainPrefixes = new Set(dedupedChain.map(prefix_of_command_js_1.prefixOfCommand).filter(Boolean));
     const combined = [...tailResult, ...currentTail, ...incomingTail].filter((t) => {
-        const tp = (0, prefix_of_command_1.prefixOfCommand)(t) || t;
+        const tp = (0, prefix_of_command_js_1.prefixOfCommand)(t) || t;
         return !chainPrefixes.has(tp);
     });
     const seen = new Set();

package/lib/utils/command/merge-command-records.d.ts

@@ -0,0 +1,2 @@
+import { type Command } from '../../types/command.js';
+export declare function mergeCommandRecords(currentCommand: Record<string, Command[]>, incomingCommand: Record<string, Command[]>, currentString: string): Promise<Record<string, Command[]>>;

package/lib/utils/command/merge-command-records.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeCommandRecords = mergeCommandRecords;
-const lodash_1 = require("lodash");
-const list_concat_1 = require("../../routes/list-concat");
-function mergeCommandRecords(currentCommand, incomingCommand, currentString) {
+const lodash_es_1 = require("lodash-es");
+const list_concat_js_1 = require("../../routes/list-concat.js");
+async function mergeCommandRecords(currentCommand, incomingCommand, currentString) {
     const result = {};
     // Start with current commands to preserve ordering
     for (const [name, instances] of Object.entries(currentCommand)) {
-        result[name] = instances.slice();
+        result[name] = [...instances];
     }
     // Merge incoming into existing result, preserving order
     for (const [name, instances] of Object.entries(incomingCommand)) {
         if (result[name]) {
-            for (const [idx, instance] of instances.entries()) {
-                if (result[name][idx]) {
-                    const currentInstance = result[name][idx];
+            for (const [index, instance] of instances.entries()) {
+                if (result[name][index]) {
+                    const currentInstance = result[name][index];
                     const hasFlags = (array) => array.some((a) => a.startsWith('-') || a.includes('='));
                     const getPrefix = (array) => {
                         const ii = array.findIndex((a) => a.startsWith('-'));
@@ -28,9 +28,9 @@ function mergeCommandRecords(currentCommand, incomingCommand, currentString) {
                     const shouldMerge = currentPrefix && incomingPrefix && currentPrefix === incomingPrefix && (hasFlags(currentInstance.args) || hasFlags(instance.args) || (currentInstance.env.length > 0) || (instance.env.length > 0));
                     if (shouldMerge) {
                         // replace with merged instance
-                        result[name][idx] = {
-                            args: (0, list_concat_1.listConcat)({ current: currentInstance.args, incoming: instance.args }),
-                            env: (0, list_concat_1.listConcat)({ current: currentInstance.env, incoming: instance.env }),
+                        result[name][index] = {
+                            args: await (0, list_concat_js_1.listConcat)({ current: currentInstance.args, incoming: instance.args }),
+                            env: await (0, list_concat_js_1.listConcat)({ current: currentInstance.env, incoming: instance.env }),
                             separator: instance.separator ?? currentInstance.separator,
                         };
                     }
@@ -38,26 +38,39 @@ function mergeCommandRecords(currentCommand, incomingCommand, currentString) {
                         // If incoming instance is empty (no args/env), skip it to avoid duplicates
                         if ((instance.args.length === 0) && (instance.env.length === 0)) {
                             // keep current as-is
-                            result[name][idx] = currentInstance;
+                            result[name][index] = currentInstance;
                         }
-                        else if ((0, lodash_1.isEqual)(currentInstance.env, instance.env)
+                        else if ((0, lodash_es_1.isEqual)(currentInstance.env, instance.env)
                             && instance.args.length > 0
                             && instance.args.every((arg) => currentInstance.args.includes(arg))) {
                             // Incoming is a strict subset of current args for the same command/env.
-                            result[name][idx] = currentInstance;
+                            result[name][index] = currentInstance;
                         }
                         else {
                             // avoid inserting exact duplicate instances
-                            const duplicateExists = result[name].some((r) => (0, lodash_1.isEqual)(r.args, instance.args) && (0, lodash_1.isEqual)(r.env, instance.env));
+                            const duplicateExists = result[name].some((r) => (0, lodash_es_1.isEqual)(r.args, instance.args) && (0, lodash_es_1.isEqual)(r.env, instance.env));
                             if (duplicateExists) {
                                 // nothing to do, keep current ordering
-                                result[name][idx] = currentInstance;
+                                result[name][index] = currentInstance;
+                            }
+                            else if (!hasFlags(currentInstance.args)
+                                && !hasFlags(instance.args)
+                                && currentInstance.env.length === 0
+                                && instance.env.length === 0
+                                && currentPrefix !== incomingPrefix) {
+                                // Different singleton-like invocations of the same command should not be interleaved.
+                                const lastIndex = result[name].length - 1;
+                                const last = result[name][lastIndex];
+                                if (last && !last.separator) {
+                                    last.separator = currentString.includes('&&') ? '&&' : ';';
+                                }
+                                result[name].push(instance);
                             }
                             else {
                                 // insert incoming as separate after current
-                                const currentWithSep = { ...currentInstance, separator: currentInstance.separator ?? (currentString.includes('&&') ? '&&' : ';') };
-                                result[name][idx] = currentWithSep;
-                                result[name].splice(idx + 1, 0, instance);
+                                const currentWithSeparator = { ...currentInstance, separator: currentInstance.separator ?? (currentString.includes('&&') ? '&&' : ';') };
+                                result[name][index] = currentWithSeparator;
+                                result[name].splice(index + 1, 0, instance);
                             }
                         }
                     }
@@ -69,14 +82,22 @@ function mergeCommandRecords(currentCommand, incomingCommand, currentString) {
         }
         else {
             // incoming-only: append
-            result[name] = instances.slice();
+            const previousNames = Object.keys(result);
+            const previousName = previousNames.at(-1);
+            const isPlainSequence = !currentString.includes('&&') && !currentString.includes('||') && !currentString.includes(';');
+            if (isPlainSequence && previousName) {
+                const previousInstances = result[previousName];
+                const lastPrevious = previousInstances.at(-1);
+                if (lastPrevious && !lastPrevious.separator) {
+                    lastPrevious.separator = ';';
+                }
+            }
+            result[name] = [...instances];
         }
     }
     // Include current-only entries that weren't present in incoming
     for (const [name, instances] of Object.entries(currentCommand)) {
-        if (!result[name]) {
-            result[name] = instances;
-        }
+        result[name] ||= instances;
     }
     return result;
 }

package/lib/utils/command/merge-flag-tokens.d.ts

@@ -0,0 +1 @@
+export declare function mergeFlagTokens(currentFlags: string[], incomingFlags: string[]): string[];