@zokugun/artifact 0.5.2 → 0.6.1

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 {
@@ -57,7 +57,7 @@ function mergeAndChains(current, incoming) {
                 else {
                     const currentAppearsLaterInIncoming = incomingAnd
                         .slice(i + 1)
-                        .some((later) => (0, prefix_of_command_1.prefixOfCommand)(later) === cPref);
+                        .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);
@@ -80,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[];

package/lib/utils/command/merge-flag-tokens.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeFlagTokens = mergeFlagTokens;
 function mergeFlagTokens(currentFlags, incomingFlags) {
-    const mergedFlags = currentFlags.slice();
+    const mergedFlags = [...currentFlags];
     for (const flag of incomingFlags) {
         const name = flag.split(/\s+/)[0];
         const exists = mergedFlags.some((existing) => existing.split(/\s+/)[0] === name);

package/lib/utils/command/merge-flags-as-string.d.ts

@@ -0,0 +1,4 @@
+export declare function mergeFlagsAsString(current: string, incoming: {
+    prefix: string;
+    flags: string[];
+}): string;

package/lib/utils/command/merge-flags-as-string.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeFlagsAsString = mergeFlagsAsString;
-const merge_flag_tokens_1 = require("./merge-flag-tokens");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
+const merge_flag_tokens_js_1 = require("./merge-flag-tokens.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function mergeFlagsAsString(current, incoming) {
-    const currentPrefix = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(current);
-    const mergedFlags = (0, merge_flag_tokens_1.mergeFlagTokens)(currentPrefix.flags, incoming.flags);
+    const currentPrefix = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(current);
+    const mergedFlags = (0, merge_flag_tokens_js_1.mergeFlagTokens)(currentPrefix.flags, incoming.flags);
     return currentPrefix.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : '');
 }

package/lib/utils/command/merge-or-segments.d.ts

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

package/lib/utils/command/merge-or-segments.js

@@ -1,25 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeOrSegments = mergeOrSegments;
-const dedupe_strings_1 = require("./dedupe-strings");
-const merge_flags_as_string_1 = require("./merge-flags-as-string");
-const merge_semicolon_segments_1 = require("./merge-semicolon-segments");
-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_semicolon_segments_js_1 = require("./merge-semicolon-segments.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 mergeOrSegments(current, incoming) {
-    const currentSegments = (0, split_segments_1.splitSegments)(current);
-    const incomingSegments = (0, split_segments_1.splitSegments)(incoming);
-    const currentOrIdx = currentSegments.findIndex((s) => s.includes('||'));
-    const incomingOrIdx = incomingSegments.findIndex((s) => s.includes('||'));
-    if (currentOrIdx === -1 || incomingOrIdx === -1) {
-        return (0, merge_semicolon_segments_1.mergeSemicolonSegments)(current, incoming);
+    const currentSegments = (0, split_segments_js_1.splitSegments)(current);
+    const incomingSegments = (0, split_segments_js_1.splitSegments)(incoming);
+    const currentOrIndex = currentSegments.findIndex((s) => s.includes('||'));
+    const incomingOrIndex = incomingSegments.findIndex((s) => s.includes('||'));
+    if (currentOrIndex === -1 || incomingOrIndex === -1) {
+        return (0, merge_semicolon_segments_js_1.mergeSemicolonSegments)(current, incoming);
     }
-    const currentParts = (0, split_chain_1.splitChain)(currentSegments[currentOrIdx], '||');
-    const incomingParts = (0, split_chain_1.splitChain)(incomingSegments[incomingOrIdx], '||');
-    const currentTail = currentSegments.filter((_, idx) => idx !== currentOrIdx);
-    const incomingTail = incomingSegments.filter((_, idx) => idx !== incomingOrIdx);
+    const currentParts = (0, split_chain_js_1.splitChain)(currentSegments[currentOrIndex], '||');
+    const incomingParts = (0, split_chain_js_1.splitChain)(incomingSegments[incomingOrIndex], '||');
+    const currentTail = currentSegments.filter((_, index) => index !== currentOrIndex);
+    const incomingTail = incomingSegments.filter((_, index) => index !== incomingOrIndex);
     const maxLength = Math.max(currentParts.length, incomingParts.length);
     const chainResult = [];
     const movedToTail = [];
@@ -27,14 +27,14 @@ function mergeOrSegments(current, incoming) {
         const currentPart = currentParts[i];
         const incomingPart = incomingParts[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 if (incomingTail.some((t) => t === currentPart || t.startsWith(`${currentPart} `))) {
@@ -64,22 +64,22 @@ function mergeOrSegments(current, incoming) {
     }
     const chainParts = new Set(dedupedChain);
     const rawTail = [...currentTail, ...movedToTail, ...incomingTail];
-    const filteredTail = rawTail.filter((tail, idx) => {
+    const filteredTail = rawTail.filter((tail, index) => {
         if (chainParts.has(tail)) {
             return false;
         }
         // Keep only the most specific tail when two tails share a prefix.
-        return !rawTail.some((other, otherIdx) => otherIdx !== idx && other.startsWith(`${tail} `));
+        return !rawTail.some((other, otherIndex) => otherIndex !== index && other.startsWith(`${tail} `));
     });
     const mergedChain = dedupedChain.join(' || ');
-    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 mergedSegs = currentSegments
-        .map((seg, idx) => (idx === currentOrIdx ? mergedChain : seg))
-        .filter((seg, idx) => idx === currentOrIdx || !chainPrefixes.has((0, prefix_of_command_1.prefixOfCommand)(seg)));
-    for (const tail of (0, dedupe_strings_1.dedupeStrings)(filteredTail)) {
+        .map((seg, index) => (index === currentOrIndex ? mergedChain : seg))
+        .filter((seg, index) => index === currentOrIndex || !chainPrefixes.has((0, prefix_of_command_js_1.prefixOfCommand)(seg)));
+    for (const tail of (0, dedupe_strings_js_1.dedupeStrings)(filteredTail)) {
         if (!mergedSegs.includes(tail)) {
             mergedSegs.push(tail);
         }
     }
-    return (0, dedupe_strings_1.dedupeStrings)(mergedSegs).join('; ');
+    return (0, dedupe_strings_js_1.dedupeStrings)(mergedSegs).join('; ');
 }

package/lib/utils/command/merge-parts-by-prefix.d.ts

@@ -0,0 +1 @@
+export declare function mergePartsByPrefix(currentParts: string[], incomingParts: string[]): string[];

package/lib/utils/command/merge-parts-by-prefix.js

@@ -1,17 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergePartsByPrefix = mergePartsByPrefix;
-const merge_flag_tokens_1 = require("./merge-flag-tokens");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
+const merge_flag_tokens_js_1 = require("./merge-flag-tokens.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function mergePartsByPrefix(currentParts, incomingParts) {
-    const result = currentParts.slice();
+    const result = [...currentParts];
     for (const incomingPart of incomingParts) {
-        const incomingPrefix = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingPart);
+        const incomingPrefix = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingPart);
         let merged = false;
         for (let k = 0; k < result.length; k++) {
-            const currentPrefix = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(result[k]);
+            const currentPrefix = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(result[k]);
             if (currentPrefix.prefix && incomingPrefix.prefix && currentPrefix.prefix === incomingPrefix.prefix) {
-                const mergedFlags = (0, merge_flag_tokens_1.mergeFlagTokens)(currentPrefix.flags, incomingPrefix.flags);
+                const mergedFlags = (0, merge_flag_tokens_js_1.mergeFlagTokens)(currentPrefix.flags, incomingPrefix.flags);
                 result[k] = currentPrefix.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : '');
                 merged = true;
                 break;

package/lib/utils/command/merge-semicolon-segments.d.ts

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

package/lib/utils/command/merge-semicolon-segments.js

@@ -1,16 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeSemicolonSegments = mergeSemicolonSegments;
-const merge_flag_tokens_1 = require("./merge-flag-tokens");
-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 merge_flag_tokens_js_1 = require("./merge-flag-tokens.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 mergeSemicolonSegments(current, incoming) {
-    let currentSegments = (0, split_segments_1.splitSegments)(current);
-    const incomingSegments = (0, split_segments_1.splitSegments)(incoming);
+    let currentSegments = (0, split_segments_js_1.splitSegments)(current);
+    const incomingSegments = (0, split_segments_js_1.splitSegments)(incoming);
     for (const incomingSegment of incomingSegments) {
         // If the incoming segment is itself a chain (&& or ||), merge subparts accordingly
         if (incomingSegment.includes('||')) {
@@ -18,12 +18,12 @@ function mergeSemicolonSegments(current, incoming) {
             let mergedIntoCurrent = false;
             for (let j = 0; j < currentSegments.length; j++) {
                 if (currentSegments[j].includes('||')) {
-                    const currentParts = (0, split_chain_1.splitChain)(currentSegments[j], '||');
-                    const newParts = (0, merge_parts_by_prefix_1.mergePartsByPrefix)(currentParts, incomingParts);
+                    const currentParts = (0, split_chain_js_1.splitChain)(currentSegments[j], '||');
+                    const newParts = (0, merge_parts_by_prefix_js_1.mergePartsByPrefix)(currentParts, incomingParts);
                     currentSegments[j] = newParts.join(' || ');
                     // remove duplicates that were absorbed
-                    currentSegments = currentSegments.filter((s, idx) => {
-                        if (idx === j) {
+                    currentSegments = currentSegments.filter((s, index) => {
+                        if (index === j) {
                             return true;
                         }
                         for (const np of newParts) {
@@ -43,48 +43,48 @@ function mergeSemicolonSegments(current, incoming) {
             continue;
         }
         if (incomingSegment.includes('&&')) {
-            const incomingParts = (0, split_chain_1.splitChain)(incomingSegment, '&&');
+            const incomingParts = (0, split_chain_js_1.splitChain)(incomingSegment, '&&');
             let mergedIntoCurrent = false;
             for (let j = 0; j < currentSegments.length; j++) {
                 if (currentSegments[j].includes('&&')) {
-                    const currentParts = (0, split_chain_1.splitChain)(currentSegments[j], '&&');
+                    const currentParts = (0, split_chain_js_1.splitChain)(currentSegments[j], '&&');
                     // If first prefixes align, do positional merge preferring incoming flags first
                     let newParts = [];
-                    if (currentParts.length > 0 && incomingParts.length > 0 && (0, prefix_of_command_1.prefixOfCommand)(currentParts[0]) === (0, prefix_of_command_1.prefixOfCommand)(incomingParts[0])) {
+                    if (currentParts.length > 0 && incomingParts.length > 0 && (0, prefix_of_command_js_1.prefixOfCommand)(currentParts[0]) === (0, prefix_of_command_js_1.prefixOfCommand)(incomingParts[0])) {
                         const maxLength = Math.max(currentParts.length, incomingParts.length);
                         for (let i = 0; i < maxLength; i++) {
-                            const curPart = currentParts[i];
+                            const currentPart = currentParts[i];
                             const incPart = incomingParts[i];
-                            if (curPart && incPart) {
-                                const curP = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(curPart);
-                                const incP = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incPart);
-                                if (curP.prefix && incP.prefix && curP.prefix === incP.prefix) {
+                            if (currentPart && incPart) {
+                                const currentP = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentPart);
+                                const incP = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incPart);
+                                if (currentP.prefix && incP.prefix && currentP.prefix === incP.prefix) {
                                     // keep current flags first, then append incoming flags if missing
-                                    const mergedFlags = (0, merge_flag_tokens_1.mergeFlagTokens)(curP.flags, incP.flags);
-                                    newParts.push(curP.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : ''));
+                                    const mergedFlags = (0, merge_flag_tokens_js_1.mergeFlagTokens)(currentP.flags, incP.flags);
+                                    newParts.push(currentP.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : ''));
                                     continue;
                                 }
                             }
-                            if (curPart) {
-                                newParts.push(curPart);
+                            if (currentPart) {
+                                newParts.push(currentPart);
                             }
-                            if (!curPart && incPart) {
+                            if (!currentPart && incPart) {
                                 newParts.push(incPart);
                             }
                         }
                         currentSegments[j] = newParts.join(' && ');
                     }
                     else {
-                        newParts = (0, merge_parts_by_prefix_1.mergePartsByPrefix)(currentParts, incomingParts);
+                        newParts = (0, merge_parts_by_prefix_js_1.mergePartsByPrefix)(currentParts, incomingParts);
                         currentSegments[j] = newParts.join(' && ');
                     }
                     // remove duplicates that were absorbed — compare by prefix to avoid formatting mismatches
-                    const newPrefixes = new Set(newParts.map(prefix_of_command_1.prefixOfCommand).filter(Boolean));
-                    currentSegments = currentSegments.filter((s, idx) => {
-                        if (idx === j) {
+                    const newPrefixes = new Set(newParts.map(prefix_of_command_js_1.prefixOfCommand).filter(Boolean));
+                    currentSegments = currentSegments.filter((s, index) => {
+                        if (index === j) {
                             return true;
                         }
-                        const sp = (0, prefix_of_command_1.prefixOfCommand)(s);
+                        const sp = (0, prefix_of_command_js_1.prefixOfCommand)(s);
                         if (sp && newPrefixes.has(sp)) {
                             return false;
                         }
@@ -99,12 +99,12 @@ function mergeSemicolonSegments(current, incoming) {
             }
             continue;
         }
-        const incomingPartsObject = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingSegment);
+        const incomingPartsObject = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegment);
         let matched = false;
         for (let i = 0; i < currentSegments.length; i++) {
-            const currentPartsObject = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(currentSegments[i]);
+            const currentPartsObject = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(currentSegments[i]);
             if (currentPartsObject.prefix && incomingPartsObject.prefix && currentPartsObject.prefix === incomingPartsObject.prefix) {
-                currentSegments[i] = (0, merge_flags_as_string_1.mergeFlagsAsString)(currentSegments[i], incomingPartsObject);
+                currentSegments[i] = (0, merge_flags_as_string_js_1.mergeFlagsAsString)(currentSegments[i], incomingPartsObject);
                 matched = true;
                 break;
             }
@@ -117,7 +117,7 @@ function mergeSemicolonSegments(current, incoming) {
     const seen = [];
     const deduped = [];
     for (const s of currentSegments) {
-        const p = (0, prefix_of_command_1.prefixOfCommand)(s) || s;
+        const p = (0, prefix_of_command_js_1.prefixOfCommand)(s) || s;
         if (!seen.includes(p)) {
             seen.push(p);
             deduped.push(s);

package/lib/utils/command/merge-with-semicolon-mix.d.ts

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

package/lib/utils/command/merge-with-semicolon-mix.js

@@ -1,36 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeWithSemicolonMix = mergeWithSemicolonMix;
-const merge_flags_as_string_1 = require("./merge-flags-as-string");
-const split_chain_1 = require("./split-chain");
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
+const merge_flags_as_string_js_1 = require("./merge-flags-as-string.js");
+const split_chain_js_1 = require("./split-chain.js");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function mergeWithSemicolonMix(current, incoming) {
     if (!(incoming.includes('&&') && current.includes(';'))) {
         return;
     }
     const allSegments = current.split(/;|&&/).map((s) => s.trim()).filter(Boolean);
     const chainPart = current.split(';')[0] || '';
-    const chainCount = chainPart ? (0, split_chain_1.splitChain)(chainPart, '&&').length : 0;
+    const chainCount = chainPart ? (0, split_chain_js_1.splitChain)(chainPart, '&&').length : 0;
     const currentChain = allSegments.slice(0, chainCount);
     const tail = allSegments.slice(chainCount);
-    const incomingAnd = (0, split_chain_1.splitChain)(incoming, '&&');
-    const chainResult = currentChain.slice();
+    const incomingAnd = (0, split_chain_js_1.splitChain)(incoming, '&&');
+    const chainResult = [...currentChain];
     const appendedTailIdxs = [];
     for (const incomingSegment of incomingAnd) {
-        const incomingParts = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingSegment);
+        const incomingParts = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(incomingSegment);
         let matched = false;
         for (const [i, allSegment] of allSegments.entries()) {
-            const currentParts = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(allSegment);
+            const currentParts = (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(allSegment);
             if (currentParts.prefix && incomingParts.prefix && currentParts.prefix === incomingParts.prefix) {
                 if (i < chainCount) {
                     // merge into existing chain position
-                    const idx = i;
-                    chainResult[idx] = (0, merge_flags_as_string_1.mergeFlagsAsString)(chainResult[idx], incomingParts);
+                    const index = i;
+                    chainResult[index] = (0, merge_flags_as_string_js_1.mergeFlagsAsString)(chainResult[index], incomingParts);
                 }
                 else {
                     // append matching tail segment into chain if not already appended
                     if (!appendedTailIdxs.includes(i)) {
-                        chainResult.push((0, merge_flags_as_string_1.mergeFlagsAsString)(allSegment, incomingParts));
+                        chainResult.push((0, merge_flags_as_string_js_1.mergeFlagsAsString)(allSegment, incomingParts));
                         appendedTailIdxs.push(i);
                     }
                 }
@@ -43,6 +43,6 @@ function mergeWithSemicolonMix(current, incoming) {
         }
     }
     // Build remaining tail excluding appended indices
-    const remainingTail = tail.filter((_, idx) => !appendedTailIdxs.includes(chainCount + idx));
+    const remainingTail = tail.filter((_, index) => !appendedTailIdxs.includes(chainCount + index));
     return chainResult.join(' && ') + (remainingTail.length > 0 ? '; ' + remainingTail.join('; ') : '');
 }

package/lib/utils/command/prefix-of-command.d.ts

@@ -0,0 +1 @@
+export declare function prefixOfCommand(command: string): string;

package/lib/utils/command/prefix-of-command.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prefixOfCommand = prefixOfCommand;
-const split_prefix_and_flags_1 = require("./split-prefix-and-flags");
+const split_prefix_and_flags_js_1 = require("./split-prefix-and-flags.js");
 function prefixOfCommand(command) {
-    return (0, split_prefix_and_flags_1.splitPrefixAndFlags)(command).prefix;
+    return (0, split_prefix_and_flags_js_1.splitPrefixAndFlags)(command).prefix;
 }

package/lib/utils/command/split-chain.d.ts

@@ -0,0 +1 @@
+export declare function splitChain(s: string, operator: '&&' | '||'): string[];

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

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