@plainconceptsplatform/loop-task 2.6.0

package/dist/widgets/task-form/TaskForm.js

@@ -0,0 +1,272 @@
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo, useCallback, useState, useRef } from "react";
+import { DEFAULT_TASK_MAX_RUNS } from "../../types.js";
+import { WizardForm } from "../loop-form/WizardForm.js";
+import { SelectModal, SelectValueField } from "../../shared/ui/SelectModal.js";
+import { CodeEditorPreview } from "../../features/code-editor/CodeEditorPreview.js";
+import { CodeEditorModal } from "../../features/code-editor/CodeEditorModal.js";
+import { useInject } from "../../shared/hooks/useInject.js";
+import { TYPES } from "../../shared/services/types.js";
+import { validateContext } from "../../core/context/validate-context.js";
+import crypto from "node:crypto";
+import { t } from "../../shared/i18n/index.js";
+import { joinCommandLines, parseCommandLine, parseMaxRuns } from "../../loop-config.js";
+function parseArgs(cmd) {
+    const tokens = [];
+    const regex = /"([^"]*)"|'([^']*)'|(\S+)/g;
+    let match;
+    while ((match = regex.exec(cmd)) !== null) {
+        tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+    }
+    return tokens.slice(1);
+}
+function joinCommand(task) {
+    return [task.command, ...task.commandArgs].join(" ");
+}
+export function TaskForm(props) {
+    const { mode, editTask, onCancel, onDone } = props;
+    const taskService = useInject(TYPES.TaskService);
+    const [tasks, setTasks] = useState([]);
+    const [commandValue, setCommandValue] = useState(editTask
+        ? (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(() => {
+        taskService.list().then(setTasks).catch(() => setTasks([]));
+    }, []);
+    const chainOptions = useMemo(() => [t("wizard.chainNone"), ...tasks.map((task) => task.name)], [tasks]);
+    const chainSelectOptions = useMemo(() => chainOptions.map((v) => ({ value: v, label: v })), [chainOptions]);
+    const [commandEditorOpen, setCommandEditorOpen] = useState(false);
+    const [contextEditorOpen, setContextEditorOpen] = useState(false);
+    const [contextValue, setContextValue] = useState(editTask?.context ? JSON.stringify(editTask.context) : "");
+    const [silentChainValue, setSilentChainValue] = useState(editTask?.silentChain ? t("board.silentChainYes") : "");
+    const [openChainField, setOpenChainField] = useState(null);
+    const [openSilentChain, setOpenSilentChain] = useState(false);
+    const chainFieldsRef = useRef({});
+    const resolveChainId = useCallback((val) => {
+        if (!val || val === t("wizard.chainNone"))
+            return null;
+        const found = tasks.find((task) => task.name === val || task.id === val);
+        return found?.id ?? val;
+    }, [tasks]);
+    const resolveChainName = useCallback((id) => {
+        if (!id)
+            return t("wizard.chainNone");
+        const found = tasks.find((task) => task.id === id);
+        return found?.name ?? id;
+    }, [tasks]);
+    const steps = useMemo(() => {
+        const list = [
+            {
+                key: "name",
+                prompt: t("wizard.taskNamePrompt"),
+                hint: t("wizard.taskNameHint"),
+                required: true,
+                inputType: "text",
+                defaultValue: editTask?.name ?? undefined,
+            },
+            {
+                key: "command",
+                prompt: t("wizard.taskCommandPrompt"),
+                hint: t("wizard.commandHint"),
+                required: true,
+                inputType: "text",
+                defaultValue: commandValue || undefined,
+                onActivate: () => setCommandEditorOpen(true),
+                renderCustom: ({ isActive }) => (_jsx(CodeEditorPreview, { value: commandValue, hint: t("wizard.commandHint"), isActive: isActive, onActivate: () => setCommandEditorOpen(true) })),
+            },
+            {
+                key: "onSuccess",
+                prompt: t("wizard.onSuccessPrompt"),
+                hint: t("board.taskHintOnSuccess"),
+                required: false,
+                defaultValue: editTask ? resolveChainName(editTask.onSuccessTaskId) : undefined,
+                onActivate: () => setOpenChainField("onSuccess"),
+                renderCustom: ({ value, isActive, onChange, onAdvance }) => {
+                    chainFieldsRef.current.onSuccess = { value, onChange, onAdvance };
+                    return (_jsx(SelectValueField, { label: value || null, placeholder: t("wizard.onSuccessPrompt"), isActive: isActive }));
+                },
+            },
+            {
+                key: "onFailure",
+                prompt: t("wizard.onFailurePrompt"),
+                hint: t("board.taskHintOnFailure"),
+                required: false,
+                defaultValue: editTask ? resolveChainName(editTask.onFailureTaskId) : undefined,
+                onActivate: () => setOpenChainField("onFailure"),
+                renderCustom: ({ value, isActive, onChange, onAdvance }) => {
+                    chainFieldsRef.current.onFailure = { value, onChange, onAdvance };
+                    return (_jsx(SelectValueField, { label: value || null, placeholder: t("wizard.onFailurePrompt"), isActive: isActive }));
+                },
+            },
+            {
+                key: "silentChain",
+                prompt: t("wizard.silentChainPrompt"),
+                hint: t("wizard.silentChainHint"),
+                required: false,
+                defaultValue: silentChainValue || undefined,
+                onActivate: () => setOpenSilentChain(true),
+                renderCustom: ({ value, isActive }) => (_jsx(SelectValueField, { label: value || null, placeholder: t("wizard.silentChainPrompt"), isActive: isActive })),
+            },
+            {
+                key: "maxRuns",
+                prompt: t("wizard.taskMaxRunsPrompt"),
+                hint: t("wizard.taskMaxRunsHint"),
+                required: false,
+                inputType: "text",
+                defaultValue: editTask ? String(editTask.maxRuns) : String(DEFAULT_TASK_MAX_RUNS),
+                validate: (value) => {
+                    if (!value?.trim())
+                        return true;
+                    try {
+                        parseMaxRuns(value);
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                validationError: t("errors.maxRunsInvalid"),
+            },
+            {
+                key: "context",
+                prompt: t("wizard.contextPrompt"),
+                hint: t("wizard.contextHint"),
+                required: false,
+                inputType: "text",
+                defaultValue: contextValue || undefined,
+                onActivate: () => setContextEditorOpen(true),
+                validate: (value) => {
+                    if (!value?.trim())
+                        return true;
+                    try {
+                        const parsed = JSON.parse(value);
+                        const result = validateContext(parsed);
+                        return result.valid;
+                    }
+                    catch {
+                        return false;
+                    }
+                },
+                validationError: t("wizard.contextInvalid"),
+                renderCustom: ({ isActive }) => (_jsx(CodeEditorPreview, { value: contextValue, hint: t("wizard.contextHint"), isActive: isActive, onActivate: () => setContextEditorOpen(true) })),
+            },
+        ];
+        return list;
+    }, [commandValue, chainOptions, editTask, resolveChainName, contextValue, silentChainValue]);
+    const handleComplete = useCallback((values) => {
+        const name = values.name?.trim() ?? "";
+        const rawCommand = joinCommandLines(commandValue);
+        if (!name || !rawCommand)
+            return;
+        const onSuccessTaskId = resolveChainId(values.onSuccess ?? "");
+        const onFailureTaskId = resolveChainId(values.onFailure ?? "");
+        const silentChain = values.silentChain === t("board.silentChainYes");
+        const maxRunsRaw = values.maxRuns?.trim();
+        let maxRuns = DEFAULT_TASK_MAX_RUNS;
+        if (maxRunsRaw) {
+            try {
+                maxRuns = parseMaxRuns(maxRunsRaw) ?? DEFAULT_TASK_MAX_RUNS;
+            }
+            catch {
+                maxRuns = DEFAULT_TASK_MAX_RUNS;
+            }
+        }
+        let context;
+        const contextStr = contextValue?.trim();
+        if (contextStr) {
+            try {
+                const parsed = JSON.parse(contextStr);
+                const result = validateContext(parsed);
+                if (result.valid) {
+                    context = result.context;
+                }
+            }
+            catch {
+                // invalid context, skip
+            }
+        }
+        const commandSegments = commandValue
+            .split(/\n&&\n|\n&&|&&\n|&&/)
+            .map(s => s.trim())
+            .filter(s => s.length > 0);
+        let payload;
+        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 };
+            });
+            const firstCmd = steps[0].commands[0];
+            payload = {
+                name,
+                command: firstCmd.command,
+                commandArgs: firstCmd.commandArgs,
+                commandRaw: firstCmd.commandRaw,
+                steps,
+                onSuccessTaskId,
+                onFailureTaskId,
+                silentChain: silentChain || undefined,
+                maxRuns,
+                context,
+            };
+        }
+        else {
+            payload = {
+                name,
+                command: rawCommand.split(" ")[0] ?? "",
+                commandArgs: parseArgs(rawCommand),
+                commandRaw: commandValue,
+                onSuccessTaskId,
+                onFailureTaskId,
+                silentChain: silentChain || undefined,
+                maxRuns,
+                context,
+            };
+        }
+        if (mode === "edit" && editTask) {
+            taskService.update(editTask.id, payload)
+                .then(() => onDone(true, editTask.id))
+                .catch(() => { });
+        }
+        else {
+            const id = crypto.randomUUID().slice(0, 8);
+            taskService.create({ id, ...payload })
+                .then((result) => onDone(false, result.id))
+                .catch(() => { });
+        }
+    }, [commandValue, resolveChainId, mode, editTask, onDone, contextValue, silentChainValue]);
+    const title = mode === "edit"
+        ? t("board.taskEditTitle")
+        : t("board.taskCreateTitle");
+    return (_jsxs(_Fragment, { children: [_jsx(WizardForm, { title: title, steps: steps, onComplete: handleComplete, onCancel: onCancel, disabled: openChainField !== null || commandEditorOpen || contextEditorOpen || openSilentChain }), openChainField ? (_jsx(SelectModal, { title: openChainField === "onSuccess" ? t("wizard.onSuccessPrompt") : t("wizard.onFailurePrompt"), options: chainSelectOptions, initialValue: chainFieldsRef.current[openChainField]?.value, onSelect: (option) => {
+                    chainFieldsRef.current[openChainField]?.onChange(option.value);
+                    chainFieldsRef.current[openChainField]?.onAdvance();
+                    setOpenChainField(null);
+                }, onClose: () => setOpenChainField(null) })) : null, commandEditorOpen ? (_jsx(CodeEditorModal, { initialValue: commandValue, onSave: (v) => {
+                    setCommandValue(v);
+                    setCommandEditorOpen(false);
+                }, onCancel: () => setCommandEditorOpen(false) })) : null, contextEditorOpen ? (_jsx(CodeEditorModal, { initialValue: contextValue, onSave: (v) => {
+                    setContextValue(v);
+                    setContextEditorOpen(false);
+                }, onCancel: () => setContextEditorOpen(false) })) : null, openSilentChain ? (_jsx(SelectModal, { title: t("wizard.silentChainPrompt"), options: [
+                    { value: t("board.silentChainNo"), label: t("board.silentChainNo") },
+                    { value: t("board.silentChainYes"), label: t("board.silentChainYes") },
+                ], initialValue: silentChainValue || t("board.silentChainNo"), onSelect: (option) => {
+                    setSilentChainValue(option.value === t("board.silentChainNo") ? "" : option.value);
+                    setOpenSilentChain(false);
+                }, onClose: () => setOpenSilentChain(false) })) : null] }));
+}

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@plainconceptsplatform/loop-task",
+  "version": "2.6.0",
+  "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": {
+    "loop-task": "dist/entry.js"
+  },
+  "main": "dist/entry.js",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json && node -e \"require('fs').copyFileSync('src/entry.js','dist/entry.js'); require('fs').copyFileSync('src/esm-loader.js','dist/esm-loader.js')\"",
+    "prepublishOnly": "npm run build",
+    "start": "node dist/entry.js",
+    "dev": "tsx src/cli.ts",
+    "dev:watch": "tsx --watch src/cli.ts",
+    "board": "node dist/entry.js",
+    "test": "vitest run --exclude '**/background-cli.test.ts'",
+    "test:all": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage --exclude '**/background-cli.test.ts'",
+    "lint": "eslint src/ tests/",
+    "typecheck": "tsc --noEmit",
+    "release:dry": "npm publish --dry-run",
+    "release": "npm publish",
+    "visual-evidence": "tsx src/visual-evidence/cli.ts",
+    "visual-evidence:publish": "tsx src/visual-evidence/publish.ts",
+    "skills:mark-internal": "node scripts/mark-agent-skills-internal.mjs",
+    "prepare": "husky"
+  },
+  "keywords": [
+    "cli",
+    "loop",
+    "loop-engineering",
+    "repeat",
+    "interval",
+    "schedule",
+    "timer",
+    "cron",
+    "automation",
+    "automations",
+    "devops",
+    "agent",
+    "ai-agent",
+    "coding-agent",
+    "agent-automation",
+    "claude-code",
+    "codex",
+    "opencode",
+    "background-tasks",
+    "scheduler"
+  ],
+  "author": "Quique Fdez Guerra",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/plainconceptsplatform/loop-task.git"
+  },
+  "homepage": "https://github.com/plainconceptsplatform/loop-task",
+  "bugs": {
+    "url": "https://github.com/plainconceptsplatform/loop-task/issues"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@opentelemetry/api": "^1.9.1",
+    "@opentelemetry/exporter-metrics-otlp-grpc": "^0.221.0",
+    "@opentelemetry/exporter-metrics-otlp-http": "^0.221.0",
+    "@opentelemetry/exporter-trace-otlp-grpc": "^0.221.0",
+    "@opentelemetry/exporter-trace-otlp-http": "^0.221.0",
+    "@opentelemetry/resources": "^2.10.0",
+    "@opentelemetry/sdk-metrics": "^2.10.0",
+    "@opentelemetry/sdk-node": "^0.221.0",
+    "@opentelemetry/sdk-trace-base": "^2.10.0",
+    "@opentelemetry/sdk-trace-node": "^2.10.0",
+    "@opentelemetry/semantic-conventions": "^1.43.0",
+    "commander": "^13.1.0",
+    "execa": "^9.6.0",
+    "ink": "^7.1.0",
+    "ink-combobox": "^0.2.0",
+    "ink-scroll-list": "^0.4.1",
+    "ink-select-input": "^6.2.0",
+    "ink-spinner": "^5.0.0",
+    "ink-text-input": "^6.0.0",
+    "inversify": "^8.1.1",
+    "inversify-hooks": "^4.0.0",
+    "js-yaml": "^5.2.2",
+    "ms": "^2.1.3",
+    "react": "^19.2.7",
+    "yaml": "^2.9.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
+    "@types/ms": "^2.1.0",
+    "@types/node": "^22.15.0",
+    "@types/react": "^19.2.17",
+    "@vitest/coverage-v8": "^3.1.0",
+    "eslint": "^9.25.0",
+    "husky": "^9.1.7",
+    "ink-testing-library": "^4.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.8.0",
+    "typescript-eslint": "^8.30.0",
+    "vitest": "^3.1.0"
+  },
+  "packageManager": "pnpm@10.30.3",
+  "pnpm": {
+    "overrides": {
+      "picocolors": "1.1.0"
+    }
+  }
+}