loop-task 2.1.0 → 2.1.1

package/dist/core/loop-controller.js

@@ -333,41 +333,46 @@ export class LoopController extends EventEmitter {
                 const cwd = resolveEffectiveCwd(this.options.cwd, this.projectDirectory);
                 const chainContext = {};
                 const hasChainTasks = !!(task?.onSuccessTaskId || task?.onFailureTaskId);
-                // Determine the command(s) to run
-                const taskCommands = task?.commands?.length
-                    ? task.commands
-                    : [{
-                            command: task?.command ?? this.options.command,
-                            commandArgs: task?.commandArgs ?? this.options.commandArgs,
-                            commandRaw: task?.commandRaw ?? this.options.commandRaw,
-                        }];
-                const shouldCaptureStdout = hasChainTasks || taskCommands.length > 1;
-                const results = await Promise.allSettled(taskCommands.map((cmd) => executeCommand(cmd.command, cmd.commandArgs, cwd, this.logStream, AbortSignal.any([signal, this.runAbortController.signal]), this.runCount, shouldCaptureStdout)));
+                const singleCommandFallback = {
+                    command: task?.command ?? this.options.command,
+                    commandArgs: task?.commandArgs ?? this.options.commandArgs,
+                    commandRaw: task?.commandRaw ?? this.options.commandRaw,
+                };
+                const taskSteps = task?.steps?.length
+                    ? task.steps
+                    : [{ commands: [singleCommandFallback] }];
+                const shouldCaptureStdout = hasChainTasks || taskSteps.length > 1 || taskSteps[0].commands.length > 1;
+                let exitCode = 0;
+                let totalDuration = 0;
+                let combinedStdout = "";
+                for (const step of taskSteps) {
+                    const stepResults = await Promise.allSettled(step.commands.map((cmd) => executeCommand(interpolate(cmd.command, chainContext), cmd.commandArgs.map(a => interpolate(a, chainContext)), cwd, this.logStream, AbortSignal.any([signal, this.runAbortController.signal]), this.runCount, shouldCaptureStdout)));
+                    for (const r of stepResults) {
+                        if (r.status === "fulfilled") {
+                            totalDuration += r.value.duration;
+                            if (r.value.stdout)
+                                combinedStdout += (combinedStdout ? "\n" : "") + r.value.stdout;
+                        }
+                    }
+                    const stepFailure = stepResults.some((r) => r.status === "rejected" || (r.status === "fulfilled" && r.value.exitCode !== 0));
+                    if (stepFailure) {
+                        const failed = stepResults.find((r) => r.status === "fulfilled" && r.value.exitCode !== 0);
+                        exitCode = failed ? failed.value.exitCode : 1;
+                        break;
+                    }
+                }
                 this.runAbortController = null;
-                // Find first failure (if any) — stop-immediately policy
-                const firstFailure = results.find((r) => r.status === "rejected");
-                const firstNonZero = results.find((r) => r.status === "fulfilled" && r.value.exitCode !== 0);
-                const exitCode = firstFailure ? 1 : (firstNonZero?.value.exitCode ?? 0);
-                const totalDuration = results.reduce((sum, r) => {
-                    if (r.status === "fulfilled")
-                        return sum + r.value.duration;
-                    return sum;
-                }, 0);
-                const combinedStdout = results
-                    .filter((r) => r.status === "fulfilled" && !!r.value.stdout)
-                    .map((r) => r.value.stdout)
-                    .join("\n");
+                if (shouldCaptureStdout && combinedStdout) {
+                    const parsed = parseStdout(combinedStdout);
+                    if (parsed !== null) {
+                        Object.assign(chainContext, parsed);
+                    }
+                }
                 const result = {
                     exitCode,
                     duration: totalDuration,
                     stdout: combinedStdout || undefined,
                 };
-                if (shouldCaptureStdout && result.stdout) {
-                    const parsed = parseStdout(result.stdout);
-                    if (parsed !== null) {
-                        Object.assign(chainContext, parsed);
-                    }
-                }
                 this.lastExitCode = result.exitCode;
                 this.lastDuration = result.duration;
                 const logSize = fs.existsSync(this.logPath) ? fs.statSync(this.logPath).size - this.currentRunStartOffset : 0;

package/dist/i18n/en.json

@@ -279,7 +279,7 @@
     "cmdEditor.lines": "lines",
     "cmdEditor.inlineHint": "enter: new line . ctrl+v: paste . ctrl+y: copy . tab: next field . ctrl+s: save",
     "codeEditor.title": "Command Editor",
-    "codeEditor.hint": "ctrl+s save . esc cancel . ctrl+z/ctrl+shift+z undo/redo . use && for parallel commands",
+    "codeEditor.hint": "ctrl+s save . esc cancel . ctrl+z/ctrl+shift+z undo/redo . && sequential . || parallel",
     "codeEditor.buttonCopy": "Copy",
     "codeEditor.buttonPaste": "Paste",
     "codeEditor.buttonClear": "Clear",

package/dist/tui/components/TaskForm.js

@@ -24,8 +24,8 @@ export function TaskForm(props) {
     const { mode, editTask, onCancel, onDone } = props;
     const [tasks, setTasks] = useState([]);
     const [commandValue, setCommandValue] = useState(editTask
-        ? (editTask.commands?.length
-            ? editTask.commands.map(c => c.commandRaw ?? [c.command, ...c.commandArgs].join(" ")).join("\n&&\n")
+        ? (editTask.steps?.length
+            ? editTask.steps.map(step => step.commands.map(c => c.commandRaw ?? [c.command, ...c.commandArgs].join(" ")).join("\n||\n")).join("\n&&\n")
             : (editTask.commandRaw ?? joinCommand(editTask)))
         : "");
     useEffect(() => {
@@ -102,30 +102,36 @@ export function TaskForm(props) {
             return;
         const onSuccessTaskId = resolveChainId(values.onSuccess ?? "");
         const onFailureTaskId = resolveChainId(values.onFailure ?? "");
-        // Split by && to build parallel commands. If only one command, keep
-        // backward compat (command + commandArgs, no commands[]).
         const commandSegments = commandValue
             .split(/\n&&\n|\n&&|&&\n|&&/)
             .map(s => s.trim())
             .filter(s => s.length > 0);
         let payload;
-        if (commandSegments.length > 1) {
-            const commands = commandSegments.slice(0, 4).map(seg => {
-                const joined = joinCommandLines(seg);
-                const tokens = parseCommandLine(joined);
-                return {
-                    command: tokens[0] ?? "",
-                    commandArgs: tokens.slice(1),
-                    commandRaw: seg,
-                };
+        if (commandSegments.length > 1 || commandValue.includes("||")) {
+            const steps = commandSegments.slice(0, 8).map(seg => {
+                const parallelCmds = seg
+                    .split(/\n\|\|\n|\n\|\||\|\|\n|\|\|/)
+                    .map(s => s.trim())
+                    .filter(s => s.length > 0)
+                    .slice(0, 4)
+                    .map(cmdSeg => {
+                    const joined = joinCommandLines(cmdSeg);
+                    const tokens = parseCommandLine(joined);
+                    return {
+                        command: tokens[0] ?? "",
+                        commandArgs: tokens.slice(1),
+                        commandRaw: cmdSeg,
+                    };
+                });
+                return { commands: parallelCmds };
             });
-            // First command also populates command/commandArgs for backward compat
+            const firstCmd = steps[0].commands[0];
             payload = {
                 name,
-                command: commands[0].command,
-                commandArgs: commands[0].commandArgs,
-                commandRaw: commands[0].commandRaw,
-                commands,
+                command: firstCmd.command,
+                commandArgs: firstCmd.commandArgs,
+                commandRaw: firstCmd.commandRaw,
+                steps,
                 onSuccessTaskId,
                 onFailureTaskId,
             };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "loop-task",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "description": "Loop engineering toolkit. Run any command on a cadence, in the background, managed from a terminal board. Schedule tests, builds, syncs, or agent prompts.",
   "type": "module",
   "bin": {