@plainconceptsplatform/loop-task 2.6.0

package/dist/shared/hooks/useLoopFormValidation.js

@@ -0,0 +1,131 @@
+import fs from "node:fs";
+import { parseDuration } from "../../duration.js";
+import { parseMaxRuns } from "../../loop-config.js";
+import { t } from "../i18n/index.js";
+export const createFields = [
+    "interval",
+    "taskMode",
+    "command",
+    "cwd",
+    "taskId",
+    "description",
+    "runNow",
+    "maxRuns",
+    "project",
+];
+/**
+ * Validates a single loop form field and returns an error string, or
+ * `null` if the value is valid.
+ *
+ * Mirrors the validation logic used in the board's CreateForm submit()
+ * and the TUI's validation utility, but in a single shared hook that
+ * both surfaces can consume.
+ *
+ * @param key   - The field to validate.
+ * @param values - All form values (needed for cross-field rules like
+ *                 "command is required only when taskMode is inline").
+ */
+function validateField(key, values) {
+    const value = values[key] ?? "";
+    switch (key) {
+        // Always required; delegates to parseDuration() which throws on
+        // empty, invalid syntax, or non-positive values.
+        case "interval": {
+            if (!value.trim()) {
+                return t("errors.durationEmpty");
+            }
+            try {
+                parseDuration(value);
+                return null;
+            }
+            catch (err) {
+                return err instanceof Error ? err.message : String(err);
+            }
+        }
+        // Required only when the user chose inline mode.
+        case "command": {
+            if (values.taskMode === "existing")
+                return null;
+            if (!value.trim()) {
+                return t("errors.commandEmpty");
+            }
+            return null;
+        }
+        // Optional; if provided the directory must exist on disk.
+        case "cwd": {
+            if (!value.trim())
+                return null;
+            if (!fs.existsSync(value)) {
+                return t("board.cwdMissing", { cwd: value });
+            }
+            return null;
+        }
+        // Always required.
+        case "description": {
+            if (!value.trim()) {
+                return t("errors.descriptionEmpty");
+            }
+            return null;
+        }
+        // Optional; if provided it must be a positive integer.
+        case "maxRuns": {
+            if (!value.trim())
+                return null;
+            try {
+                parseMaxRuns(value);
+                return null;
+            }
+            catch (err) {
+                return err instanceof Error ? err.message : String(err);
+            }
+        }
+        case "taskMode":
+        case "runNow":
+        case "project":
+        case "taskId":
+            return null;
+    }
+}
+/**
+ * Validates every relevant field and returns a map of field-key → error
+ * message. Only fields that fail validation appear in the map (omitted
+ * fields are valid).
+ */
+function validateAll(values) {
+    const errors = {};
+    const fieldsToValidate = [
+        "interval",
+        "command",
+        "cwd",
+        "description",
+        "maxRuns",
+    ];
+    for (const field of fieldsToValidate) {
+        const error = validateField(field, values);
+        if (error !== null) {
+            errors[field] = error;
+        }
+    }
+    return errors;
+}
+/**
+ * Shared form-validation hook for loop creation / edit forms.
+ *
+ * Returns stable references to `validateField` and `validateAll` so it
+ * can be called from any React component without triggering re-renders.
+ *
+ * @example
+ * ```ts
+ * const { validateField, validateAll } = useLoopFormValidation();
+ *
+ * // On-blur per-field check:
+ * const err = validateField("interval", values);
+ *
+ * // On-submit full check:
+ * const errors = validateAll(values);
+ * if (Object.keys(errors).length === 0) { submit(); }
+ * ```
+ */
+export function useLoopFormValidation() {
+    return { validateField, validateAll };
+}

package/dist/shared/hooks/useLoopPolling.js

@@ -0,0 +1,30 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { useInject } from "./useInject.js";
+import { TYPES } from "../services/types.js";
+import { POLL_MS } from "../config/constants.js";
+export function useLoopPolling() {
+    const loopService = useInject(TYPES.LoopService);
+    const [loops, setLoops] = useState([]);
+    const [daemonStatus, setDaemonStatus] = useState("starting");
+    const lastSerialized = useRef("");
+    const refresh = useCallback(async () => {
+        try {
+            const next = await loopService.list();
+            const serialized = JSON.stringify(next);
+            if (serialized !== lastSerialized.current) {
+                lastSerialized.current = serialized;
+                setLoops(next);
+            }
+            setDaemonStatus("connected");
+        }
+        catch {
+            setDaemonStatus("error");
+        }
+    }, [loopService]);
+    useEffect(() => {
+        void refresh();
+        const timer = setInterval(() => void refresh(), POLL_MS);
+        return () => clearInterval(timer);
+    }, [refresh]);
+    return { loops, daemonStatus, refresh };
+}

package/dist/shared/hooks/useMouseScroll.js

@@ -0,0 +1,56 @@
+import { useInput } from "ink";
+import { useRef } from "react";
+/**
+ * Parse SGR (1006) mouse scroll sequences from an input string that Ink
+ * has already passed through (ESC byte stripped).
+ *
+ * Ink strips the leading \x1b, so the input arrives as:
+ *   [<button;col;rowM  (press)   or  [<button;col;rowm  (release)
+ *
+ * Scroll wheel: button 64 = scroll up, button 65 = scroll down.
+ *
+ * A single useInput call may contain multiple concatenated mouse events
+ * (fast scrolling). Returns the net scroll direction:
+ * positive = scrolled down, negative = up, zero = no scroll.
+ */
+export function parseMouseScroll(input) {
+    let delta = 0;
+    // Match stripped SGR sequences: [<button;col;rowM or m
+    // (Ink strips the ESC byte, so we match without \x1b)
+    const sgrRe = /\[<(\d+);\d+;\d+[Mm]/g;
+    let match;
+    while ((match = sgrRe.exec(input)) !== null) {
+        const button = Number(match[1]);
+        if (button === 64)
+            delta -= 1; // scroll up
+        else if (button === 65)
+            delta += 1; // scroll down
+    }
+    return delta;
+}
+/**
+ * Hook that listens for mouse scroll events via Ink's useInput and fires
+ * callbacks.
+ *
+ * Must be used inside an Ink app that has enabled SGR mouse tracking
+ * (DECSET 1000 + 1006) at startup. The hook does not enable/disable
+ * tracking itself.
+ */
+export function useMouseScroll(options) {
+    const { onScrollUp, onScrollDown, isActive = true } = options;
+    const callbacksRef = useRef({ onScrollUp, onScrollDown });
+    callbacksRef.current = { onScrollUp, onScrollDown };
+    useInput((input) => {
+        const delta = parseMouseScroll(input);
+        if (delta < 0) {
+            for (let i = 0; i < Math.abs(delta); i++) {
+                callbacksRef.current.onScrollUp();
+            }
+        }
+        else if (delta > 0) {
+            for (let i = 0; i < delta; i++) {
+                callbacksRef.current.onScrollDown();
+            }
+        }
+    }, { isActive });
+}

package/dist/shared/hooks/useUndoRedo.js

@@ -0,0 +1,77 @@
+import { useState, useRef, useCallback } from "react";
+/**
+ * Pure undo/redo stack logic  exported for direct unit testing
+ * without needing React DOM or renderHook.
+ */
+export class UndoRedoStack {
+    constructor(value, limit = 50) {
+        this.value = value;
+        this.limit = limit;
+        this.history = [];
+        this.future = [];
+    }
+    get canUndo() {
+        return this.history.length > 0;
+    }
+    get canRedo() {
+        return this.future.length > 0;
+    }
+    setValue(next) {
+        if (next === this.value)
+            return false;
+        this.history.push(this.value);
+        if (this.history.length > this.limit) {
+            this.history.shift();
+        }
+        this.future = [];
+        this.value = next;
+        return true;
+    }
+    undo() {
+        if (this.history.length === 0)
+            return false;
+        this.future.push(this.value);
+        this.value = this.history.pop();
+        return true;
+    }
+    redo() {
+        if (this.future.length === 0)
+            return false;
+        this.history.push(this.value);
+        this.value = this.future.pop();
+        return true;
+    }
+}
+export function useUndoRedo(initial, limit = 50) {
+    const [value, setValueState] = useState(initial);
+    const stackRef = useRef(new UndoRedoStack(initial, limit));
+    const setValue = useCallback((next) => {
+        setValueState((prev) => {
+            if (stackRef.current.setValue(next))
+                return next;
+            return prev;
+        });
+    }, [limit]);
+    const undo = useCallback(() => {
+        setValueState((prev) => {
+            if (stackRef.current.undo())
+                return stackRef.current.value;
+            return prev;
+        });
+    }, []);
+    const redo = useCallback(() => {
+        setValueState((prev) => {
+            if (stackRef.current.redo())
+                return stackRef.current.value;
+            return prev;
+        });
+    }, []);
+    return {
+        value,
+        setValue,
+        undo,
+        redo,
+        canUndo: stackRef.current.canUndo,
+        canRedo: stackRef.current.canRedo,
+    };
+}