@zokugun/artifact 0.5.0 → 0.5.1

package/lib/cli.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const commander_1 = require("commander");
+const commander_1 = require("@zokugun/cli-utils/commander");
 const package_json_1 = __importDefault(require("../package.json"));
 const commands_1 = require("./commands");
 const program = new commander_1.Command();

package/lib/routes/command.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.command = command;
 const command_1 = require("../utils/command");
-const list_concat_1 = require("./list-concat");
 function command({ current, incoming }) {
     if (!incoming) {
         return current ?? '';
@@ -10,35 +9,31 @@ function command({ current, incoming }) {
     if (!current) {
         return incoming;
     }
+    const trueAndMatch = /^true\s*&&\s*(.+)$/.exec(incoming);
+    const currentSegments = new Set(current.split(/;|&&|\|\|/).map((s) => s.trim()).filter(Boolean));
+    if (currentSegments.has(incoming)) {
+        return current;
+    }
+    if (trueAndMatch) {
+        const incomingCommand = trueAndMatch[1].trim();
+        return currentSegments.has(incomingCommand) ? current : `${current} && ${incomingCommand}`;
+    }
+    const mixed = (0, command_1.mergeWithSemicolonMix)(current, incoming);
+    if (mixed) {
+        return mixed;
+    }
+    const andMerged = (0, command_1.mergeAndChains)(current, incoming);
+    if (andMerged) {
+        return andMerged;
+    }
+    if (incoming.includes('||')) {
+        return (0, command_1.mergeOrSegments)(current, incoming);
+    }
+    if (incoming.includes(';')) {
+        return (0, command_1.mergeSemicolonSegments)(current, incoming);
+    }
     const currentCommand = (0, command_1.splitCommand)(current);
     const incomingCommand = (0, command_1.splitCommand)(incoming);
-    const result = {};
-    for (const [name, instances] of Object.entries(incomingCommand)) {
-        if (currentCommand[name]) {
-            result[name] = [];
-            for (const [index, instance] of instances.entries()) {
-                if (currentCommand[name][index]) {
-                    const currentInstance = currentCommand[name][index];
-                    result[name].push({
-                        args: (0, list_concat_1.listConcat)({
-                            current: currentInstance.args,
-                            incoming: instance.args,
-                        }),
-                        env: (0, list_concat_1.listConcat)({
-                            current: currentInstance.env,
-                            incoming: instance.env,
-                        }),
-                        separator: instance.separator ?? currentInstance.separator,
-                    });
-                }
-                else {
-                    result[name].push(instance);
-                }
-            }
-        }
-        else {
-            result[name] = instances;
-        }
-    }
-    return (0, command_1.joinCommand)(result);
+    const merged = (0, command_1.mergeCommandRecords)(currentCommand, incomingCommand, current);
+    return (0, command_1.joinCommand)(merged);
 }

package/lib/steps/read-files.js

@@ -17,6 +17,7 @@ async function readFiles({ incomingPath, textFiles, binaryFiles, options }) {
     });
     for (const file of files) {
         const filePath = path_1.default.join(cwd, file);
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-call
         if ((0, istextorbinary_1.isText)(file) || (0, istextorbinary_1.getEncoding)(await (0, read_buffer_1.readBuffer)(filePath, 24)) === 'utf8') {
             const data = await fs_extra_1.default.readFile(filePath, 'utf-8');
             const finalNewLine = data.endsWith('\n');

package/lib/utils/command/dedupe-strings.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dedupeStrings = dedupeStrings;
+function dedupeStrings(items) {
+    const result = [];
+    for (const item of items) {
+        if (!result.includes(item)) {
+            result.push(item);
+        }
+    }
+    return result;
+}

package/lib/utils/command/index.js

@@ -1,7 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.splitCommand = exports.joinCommand = void 0;
+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; } });

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

@@ -0,0 +1,91 @@
+"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");
+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, '&&');
+    // 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);
+    if (!positionalMatch) {
+        // Merge by matching prefixes across current segments, append unmatched incoming segments.
+        const merged = (0, merge_parts_by_prefix_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 maxLength = Math.max(currentAnd.length, incomingAnd.length);
+    const chainResult = [];
+    const tailResult = [];
+    for (let i = 0; i < maxLength; i++) {
+        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);
+            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)));
+                }
+                else {
+                    chainResult.push((0, merge_flags_as_string_1.mergeFlagsAsString)(currentPart, (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingPart)));
+                }
+            }
+            else {
+                // prefixes differ
+                if (incomingTail.some((t) => t === currentPart || t.startsWith(`${currentPart} `))) {
+                    // incoming already includes current as a semicolon tail -> prefer incoming in chain
+                    chainResult.push(incomingPart);
+                    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);
+                    }
+                }
+            }
+        }
+        else if (currentPart) {
+            chainResult.push(currentPart);
+        }
+        else if (incomingPart) {
+            chainResult.push(incomingPart);
+        }
+    }
+    const dedupedChain = (0, dedupe_strings_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 combined = [...tailResult, ...currentTail, ...incomingTail].filter((t) => {
+        const tp = (0, prefix_of_command_1.prefixOfCommand)(t) || t;
+        return !chainPrefixes.has(tp);
+    });
+    const seen = new Set();
+    const remainingTail = [];
+    for (const t of combined) {
+        if (!seen.has(t)) {
+            seen.add(t);
+            remainingTail.push(t);
+        }
+    }
+    return dedupedChain.join(' && ') + (remainingTail.length > 0 ? '; ' + remainingTail.join('; ') : '');
+}

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

@@ -0,0 +1,82 @@
+"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 result = {};
+    // Start with current commands to preserve ordering
+    for (const [name, instances] of Object.entries(currentCommand)) {
+        result[name] = instances.slice();
+    }
+    // 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];
+                    const hasFlags = (array) => array.some((a) => a.startsWith('-') || a.includes('='));
+                    const getPrefix = (array) => {
+                        const ii = array.findIndex((a) => a.startsWith('-'));
+                        if (ii === -1) {
+                            return array.join(' ').trim();
+                        }
+                        return array.slice(0, ii).join(' ').trim();
+                    };
+                    const currentPrefix = getPrefix(currentInstance.args);
+                    const incomingPrefix = getPrefix(instance.args);
+                    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 }),
+                            separator: instance.separator ?? currentInstance.separator,
+                        };
+                    }
+                    else {
+                        // 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;
+                        }
+                        else if ((0, lodash_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;
+                        }
+                        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));
+                            if (duplicateExists) {
+                                // nothing to do, keep current ordering
+                                result[name][idx] = currentInstance;
+                            }
+                            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);
+                            }
+                        }
+                    }
+                }
+                else {
+                    result[name].push(instance);
+                }
+            }
+        }
+        else {
+            // incoming-only: append
+            result[name] = instances.slice();
+        }
+    }
+    // Include current-only entries that weren't present in incoming
+    for (const [name, instances] of Object.entries(currentCommand)) {
+        if (!result[name]) {
+            result[name] = instances;
+        }
+    }
+    return result;
+}

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

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

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

@@ -0,0 +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");
+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);
+    return currentPrefix.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : '');
+}

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

@@ -0,0 +1,85 @@
+"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");
+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 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 maxLength = Math.max(currentParts.length, incomingParts.length);
+    const chainResult = [];
+    const movedToTail = [];
+    for (let i = 0; i < maxLength; i++) {
+        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);
+            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)));
+                }
+                else {
+                    chainResult.push((0, merge_flags_as_string_1.mergeFlagsAsString)(currentPart, (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingPart)));
+                }
+            }
+            else if (incomingTail.some((t) => t === currentPart || t.startsWith(`${currentPart} `))) {
+                chainResult.push(incomingPart);
+                movedToTail.push(currentPart);
+            }
+            else {
+                chainResult.push(currentPart);
+                const coveredByCurrentTail = currentTail.some((t) => t.startsWith(`${incomingPart} `));
+                if (!coveredByCurrentTail) {
+                    chainResult.push(incomingPart);
+                }
+            }
+        }
+        else if (currentPart) {
+            chainResult.push(currentPart);
+        }
+        else if (incomingPart) {
+            chainResult.push(incomingPart);
+        }
+    }
+    const dedupedChain = [];
+    for (const part of chainResult) {
+        if (!dedupedChain.includes(part)) {
+            dedupedChain.push(part);
+        }
+    }
+    const chainParts = new Set(dedupedChain);
+    const rawTail = [...currentTail, ...movedToTail, ...incomingTail];
+    const filteredTail = rawTail.filter((tail, idx) => {
+        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} `));
+    });
+    const mergedChain = dedupedChain.join(' || ');
+    const chainPrefixes = new Set(dedupedChain.map(prefix_of_command_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)) {
+        if (!mergedSegs.includes(tail)) {
+            mergedSegs.push(tail);
+        }
+    }
+    return (0, dedupe_strings_1.dedupeStrings)(mergedSegs).join('; ');
+}

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

@@ -0,0 +1,25 @@
+"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");
+function mergePartsByPrefix(currentParts, incomingParts) {
+    const result = currentParts.slice();
+    for (const incomingPart of incomingParts) {
+        const incomingPrefix = (0, split_prefix_and_flags_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]);
+            if (currentPrefix.prefix && incomingPrefix.prefix && currentPrefix.prefix === incomingPrefix.prefix) {
+                const mergedFlags = (0, merge_flag_tokens_1.mergeFlagTokens)(currentPrefix.flags, incomingPrefix.flags);
+                result[k] = currentPrefix.prefix + (mergedFlags.length > 0 ? ' ' + mergedFlags.join(' ') : '');
+                merged = true;
+                break;
+            }
+        }
+        if (!merged) {
+            result.push(incomingPart);
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,127 @@
+"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");
+function mergeSemicolonSegments(current, incoming) {
+    let currentSegments = (0, split_segments_1.splitSegments)(current);
+    const incomingSegments = (0, split_segments_1.splitSegments)(incoming);
+    for (const incomingSegment of incomingSegments) {
+        // If the incoming segment is itself a chain (&& or ||), merge subparts accordingly
+        if (incomingSegment.includes('||')) {
+            const incomingParts = incomingSegment.split('||').map((s) => s.trim()).filter(Boolean);
+            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);
+                    currentSegments[j] = newParts.join(' || ');
+                    // remove duplicates that were absorbed
+                    currentSegments = currentSegments.filter((s, idx) => {
+                        if (idx === j) {
+                            return true;
+                        }
+                        for (const np of newParts) {
+                            if (s === np) {
+                                return false;
+                            }
+                        }
+                        return true;
+                    });
+                    mergedIntoCurrent = true;
+                    break;
+                }
+            }
+            if (!mergedIntoCurrent) {
+                currentSegments.push(incomingSegment);
+            }
+            continue;
+        }
+        if (incomingSegment.includes('&&')) {
+            const incomingParts = (0, split_chain_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], '&&');
+                    // 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])) {
+                        const maxLength = Math.max(currentParts.length, incomingParts.length);
+                        for (let i = 0; i < maxLength; i++) {
+                            const curPart = 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) {
+                                    // 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(' ') : ''));
+                                    continue;
+                                }
+                            }
+                            if (curPart) {
+                                newParts.push(curPart);
+                            }
+                            if (!curPart && incPart) {
+                                newParts.push(incPart);
+                            }
+                        }
+                        currentSegments[j] = newParts.join(' && ');
+                    }
+                    else {
+                        newParts = (0, merge_parts_by_prefix_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) {
+                            return true;
+                        }
+                        const sp = (0, prefix_of_command_1.prefixOfCommand)(s);
+                        if (sp && newPrefixes.has(sp)) {
+                            return false;
+                        }
+                        return true;
+                    });
+                    mergedIntoCurrent = true;
+                    break;
+                }
+            }
+            if (!mergedIntoCurrent) {
+                currentSegments.push(incomingSegment);
+            }
+            continue;
+        }
+        const incomingPartsObject = (0, split_prefix_and_flags_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]);
+            if (currentPartsObject.prefix && incomingPartsObject.prefix && currentPartsObject.prefix === incomingPartsObject.prefix) {
+                currentSegments[i] = (0, merge_flags_as_string_1.mergeFlagsAsString)(currentSegments[i], incomingPartsObject);
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            currentSegments.push(incomingSegment);
+        }
+    }
+    // Deduplicate top-level semicolon segments by prefix, preserving first occurrence
+    const seen = [];
+    const deduped = [];
+    for (const s of currentSegments) {
+        const p = (0, prefix_of_command_1.prefixOfCommand)(s) || s;
+        if (!seen.includes(p)) {
+            seen.push(p);
+            deduped.push(s);
+        }
+    }
+    return deduped.join('; ');
+}

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

@@ -0,0 +1,48 @@
+"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");
+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 currentChain = allSegments.slice(0, chainCount);
+    const tail = allSegments.slice(chainCount);
+    const incomingAnd = (0, split_chain_1.splitChain)(incoming, '&&');
+    const chainResult = currentChain.slice();
+    const appendedTailIdxs = [];
+    for (const incomingSegment of incomingAnd) {
+        const incomingParts = (0, split_prefix_and_flags_1.splitPrefixAndFlags)(incomingSegment);
+        let matched = false;
+        for (const [i, allSegment] of allSegments.entries()) {
+            const currentParts = (0, split_prefix_and_flags_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);
+                }
+                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));
+                        appendedTailIdxs.push(i);
+                    }
+                }
+                matched = true;
+                break;
+            }
+        }
+        if (!matched) {
+            chainResult.push(incomingSegment);
+        }
+    }
+    // Build remaining tail excluding appended indices
+    const remainingTail = tail.filter((_, idx) => !appendedTailIdxs.includes(chainCount + idx));
+    return chainResult.join(' && ') + (remainingTail.length > 0 ? '; ' + remainingTail.join('; ') : '');
+}

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

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

package/lib/utils/command/split-chain.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitChain = splitChain;
+function splitChain(s, operator) {
+    return s.split(operator).map((part) => part.trim()).filter(Boolean);
+}

package/lib/utils/command/split-prefix-and-flags.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitPrefixAndFlags = splitPrefixAndFlags;
+function splitPrefixAndFlags(command) {
+    const tokens = command.split(/\s+/).filter(Boolean);
+    let idx = tokens.findIndex((t) => t.startsWith('-'));
+    if (idx === -1) {
+        idx = tokens.length;
+    }
+    const prefix = tokens.slice(0, idx).join(' ');
+    const rest = tokens.slice(idx);
+    const flags = [];
+    for (let i = 0; i < rest.length; i++) {
+        const t = rest[i];
+        if (t.startsWith('-')) {
+            if (i + 1 < rest.length && !rest[i + 1].startsWith('-')) {
+                flags.push(`${t} ${rest[i + 1]}`);
+                i++;
+            }
+            else {
+                flags.push(t);
+            }
+        }
+        else {
+            flags.push(t);
+        }
+    }
+    return { prefix, flags };
+}

package/lib/utils/command/split-segments.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitSegments = splitSegments;
+function splitSegments(s) {
+    return s.split(';').map((seg) => seg.trim()).filter(Boolean);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@zokugun/artifact",
 	"description": "Boilerplate your project & keep your configurations up to date",
-	"version": "0.5.0",
+	"version": "0.5.1",
 	"author": {
 		"name": "Baptiste Augrain",
 		"email": "daiyam@zokugun.org"
@@ -32,9 +32,9 @@
 		"watch:test": "tsc-watch -p test"
 	},
 	"dependencies": {
+		"@zokugun/cli-utils": "^0.2.0",
 		"@zokugun/configdotts-merge": "^0.2.0",
 		"ansi-colors": "^4.1.1",
-		"commander": "^9.0.0",
 		"dayjs": "^1.11.13",
 		"detect-indent": "^6.1.0",
 		"editorconfig": "^0.15.3",