@plainconceptsplatform/loop-task 2.6.0

package/dist/shared/ui/Toast.js

@@ -0,0 +1,37 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { useState, useCallback } from "react";
+import { Box, Text } from "ink";
+import { darkTheme as theme } from "./theme.js";
+const TOAST_TIMEOUT_MS = 3500;
+const TOAST_MAX = 4;
+function toastColor(kind) {
+    switch (kind) {
+        case "success": return theme.semantic.success;
+        case "error": return theme.semantic.danger;
+        case "info": return theme.accent.loop;
+    }
+}
+function toastIcon(kind) {
+    switch (kind) {
+        case "success": return "\u2713";
+        case "error": return "\u2717";
+        case "info": return "\u2139";
+    }
+}
+export function useToasts() {
+    const [toasts, setToasts] = useState([]);
+    const nextId = useState(() => ({ value: 0 }))[0];
+    const push = useCallback((kind, message) => {
+        const id = ++nextId.value;
+        setToasts((prev) => [...prev, { id, kind, message }].slice(-TOAST_MAX));
+        setTimeout(() => {
+            setToasts((prev) => prev.filter((t) => t.id !== id));
+        }, TOAST_TIMEOUT_MS);
+    }, [nextId]);
+    return { toasts, push };
+}
+export function ToastStack(props) {
+    if (props.toasts.length === 0)
+        return null;
+    return (_jsx(Box, { position: "absolute", bottom: 0, right: 0, flexDirection: "column", alignItems: "flex-end", children: props.toasts.map((toast) => (_jsxs(Box, { backgroundColor: theme.bg.elevated, paddingLeft: 1, paddingRight: 1, children: [_jsxs(Text, { color: toastColor(toast.kind), bold: true, children: [toastIcon(toast.kind), " "] }), _jsx(Text, { color: theme.text.primary, children: toast.message })] }, toast.id))) }));
+}

package/dist/shared/ui/format.js

@@ -0,0 +1,117 @@
+import { t } from "../i18n/index.js";
+export function unescapeCommand(str) {
+    if (typeof str !== "string")
+        return String(str ?? "");
+    return str
+        .replace(/\\\\/g, "\x00")
+        .replace(/\\"/g, '"')
+        .replace(/\x00/g, "\\");
+}
+export function quoteArg(arg) {
+    const s = typeof arg === "string" ? arg : String(arg ?? "");
+    return /[\s"]/.test(s) ? `"${s.replace(/"/g, '\\"')}"` : s;
+}
+export function commandLine(command, args) {
+    const safeArgs = Array.isArray(args) ? args : [];
+    return [unescapeCommand(command), ...safeArgs.map((a) => quoteArg(unescapeCommand(a)))].join(" ").trim();
+}
+export function formatCmd(command, args, max = 24) {
+    const full = commandLine(command, args);
+    return full.length > max ? full.slice(0, max - 3) + "..." : full;
+}
+export function describeLoop(loop) {
+    return loop.description?.trim() || commandLine(loop.command, loop.commandArgs);
+}
+export function truncate(text, max) {
+    return text.length > max ? text.slice(0, max - 3) + "..." : text;
+}
+export function timeAgo(iso) {
+    if (!iso)
+        return t("format.dash");
+    const diff = Date.now() - new Date(iso).getTime();
+    const secs = Math.floor(diff / 1000);
+    if (secs < 5)
+        return t("format.justNow");
+    if (secs < 60)
+        return t("format.secsAgo", { secs });
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return t("format.minsAgo", { mins });
+    const hrs = Math.floor(mins / 60);
+    if (hrs < 24)
+        return t("format.hrsAgo", { hrs });
+    return t("format.daysAgo", { days: Math.floor(hrs / 24) });
+}
+export function timeUntil(iso) {
+    if (!iso)
+        return t("format.dash");
+    const diff = Math.max(0, new Date(iso).getTime() - Date.now());
+    const secs = Math.floor(diff / 1000);
+    if (secs < 5)
+        return t("format.justNow");
+    if (secs < 60)
+        return t("format.secsAhead", { secs });
+    const mins = Math.floor(secs / 60);
+    if (mins < 60)
+        return t("format.minsAhead", { mins });
+    const hrs = Math.floor(mins / 60);
+    if (hrs < 24)
+        return t("format.hrsAhead", { hrs });
+    return t("format.daysAhead", { days: Math.floor(hrs / 24) });
+}
+const STATUS_COLORS = {
+    running: "#4ade80",
+    waiting: "#6b7280",
+    paused: "#facc15",
+    idle: "#fb923c",
+    stopped: "#f87171",
+};
+export function statusColor(status) {
+    return STATUS_COLORS[status] ?? "#ffffff";
+}
+export function timingLabel(loop) {
+    if (loop.interval === 0)
+        return t("format.durationManual");
+    if (loop.status === "paused")
+        return t("format.timingPaused");
+    if (loop.status === "idle")
+        return t("format.timingIdle");
+    if (loop.nextRunAt)
+        return t("format.timingNext", { timeAgo: timeUntil(loop.nextRunAt) });
+    if (loop.lastRunAt)
+        return t("format.timingLast", { timeAgo: timeAgo(loop.lastRunAt) });
+    return t("format.timingNew");
+}
+export function statusLabel(status) {
+    return status === "waiting" ? "waiting" : status;
+}
+export function formatFileSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1024 * 1024)
+        return `${Math.round(bytes / 1024)} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+export function formatRunDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    return `${Math.floor(ms / 60000)}m${Math.floor((ms % 60000) / 1000)}s`;
+}
+export function formatRunTime(iso) {
+    const d = new Date(iso);
+    return d.toLocaleTimeString([], { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false });
+}
+export function formatDate(iso) {
+    const d = new Date(iso);
+    const date = d.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+    const time = d.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit", second: "2-digit", hour12: false });
+    return `${date} ${time}`;
+}
+export function sinceLabel(loop) {
+    const ts = loop.sessionStartedAt ?? loop.createdAt;
+    if (!ts)
+        return t("format.dash");
+    return formatDate(ts);
+}

package/dist/shared/ui/hooks/useHoverState.js

@@ -0,0 +1,11 @@
+import { useState } from "react";
+export function useHoverState() {
+    const [isHovered, setIsHovered] = useState(false);
+    return {
+        isHovered,
+        hoverProps: {
+            onMouseOver: () => setIsHovered(true),
+            onMouseOut: () => setIsHovered(false),
+        },
+    };
+}

package/dist/shared/ui/state.js

@@ -0,0 +1,9 @@
+export { defaultFilters, applyLoopFilters, cycleSortMode, cycleStatusFilter } from "../../entities/loops/filters.js";
+export { defaultProjectFilters, applyProjectFilters, cycleProjectSortMode, cycleProjectHasLoopsFilter, cycleProjectIsSystemFilter } from "../../entities/projects/filters.js";
+export function resolveInputOwner(state) {
+    if (state.modalOpen)
+        return "modal";
+    if (state.commandBarHasText || state.commandBarDropdownOpen)
+        return "commandBar";
+    return "panel";
+}

package/dist/shared/ui/theme.js

@@ -0,0 +1,96 @@
+export const darkTheme = {
+    bg: {
+        base: "#0a0e14",
+        surface: "#111827",
+        elevated: "#1e293b",
+        hover: "#1e3a5f",
+        active: "#1e3a8a", // loop selection (blue)
+        activeTask: "#3b1f6e", // task selection (purple)
+        activeProject: "#0f3d2e", // project selection (green)
+        input: "#0f172a",
+    },
+    text: {
+        primary: "#e5e7eb",
+        secondary: "#9ca3af",
+        muted: "#6b7280",
+        inverse: "#ffffff",
+    },
+    accent: {
+        brand: "#fbbf24",
+        loop: "#38bdf8",
+        task: "#a78bfa",
+        project: "#34d399",
+    },
+    semantic: {
+        success: "#4ade80",
+        warning: "#facc15",
+        danger: "#f87171",
+        idle: "#fb923c",
+    },
+    border: {
+        default: "#1e293b",
+        dim: "#374151",
+    },
+};
+export const lightTheme = {
+    bg: {
+        base: "#f8fafc",
+        surface: "#f1f5f9",
+        elevated: "#e2e8f0",
+        hover: "#cbd5e1",
+        active: "#93c5fd",
+        input: "#f1f5f9",
+    },
+    text: {
+        primary: "#1e293b",
+        secondary: "#475569",
+        muted: "#94a3b8",
+        inverse: "#0f172a",
+    },
+    accent: {
+        brand: "#d97706",
+        loop: "#0284c7",
+        task: "#7c3aed",
+        project: "#059669",
+    },
+    semantic: {
+        success: "#16a34a",
+        warning: "#ca8a04",
+        danger: "#dc2626",
+        idle: "#ea580c",
+    },
+    border: {
+        default: "#cbd5e1",
+        dim: "#94a3b8",
+    },
+};
+export const space = {
+    0: 0,
+    1: 1,
+    2: 2,
+    3: 3,
+    4: 4,
+};
+export const ENTITY_COLORS = {
+    loop: "#38bdf8",
+    task: "#a78bfa",
+    project: "#34d399",
+};
+export const STATUS_COLORS = {
+    running: "#4ade80",
+    waiting: "#6b7280",
+    paused: "#facc15",
+    idle: "#fb923c",
+    stopped: "#f87171",
+};
+export function statusColor(status) {
+    return STATUS_COLORS[status] ?? "#9ca3af";
+}
+export function tabAccentColor(tab) {
+    const map = {
+        loops: darkTheme.accent.loop,
+        tasks: darkTheme.accent.task,
+        projects: darkTheme.accent.project,
+    };
+    return map[tab] ?? darkTheme.accent.brand;
+}

package/dist/shared/utils/log-lines.js

@@ -0,0 +1,13 @@
+import { LOG_LINE_CHARS_MAX } from "../config/constants.js";
+const TRUNCATION_MARKER = " …[line truncated]";
+export function clampLine(line, maxChars = LOG_LINE_CHARS_MAX) {
+    return line.length > maxChars ? line.slice(0, maxChars) + TRUNCATION_MARKER : line;
+}
+export function clampLines(lines, maxCount, maxChars = LOG_LINE_CHARS_MAX) {
+    const tail = lines.length > maxCount ? lines.slice(lines.length - maxCount) : lines;
+    return tail.map((l) => clampLine(l, maxChars));
+}
+export function appendClamped(prev, line, maxCount) {
+    const next = [...prev, clampLine(line)];
+    return next.length > maxCount ? next.slice(next.length - maxCount) : next;
+}

package/dist/shared/utils/paste.js

@@ -0,0 +1,37 @@
+import { PASTE_MAX_CHARS } from "../config/constants.js";
+import { CODE_EDITOR_WRAP_LENGTH } from "../config/constants.js";
+export function sanitizePaste(raw) {
+    return raw
+        .replace(/\x1b\[20[01]~/g, "")
+        .replace(/[\r\n]+/g, " ")
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "")
+        .slice(0, PASTE_MAX_CHARS);
+}
+export function sanitizeMultilinePaste(raw) {
+    return raw
+        .replace(/\x1b\[20[01]~/g, "")
+        .replace(/\r\n/g, "\n")
+        .replace(/\r/g, "\n")
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "")
+        .slice(0, PASTE_MAX_CHARS);
+}
+export function wrapCommand(text, maxLen = CODE_EDITOR_WRAP_LENGTH) {
+    const words = text.split(" ");
+    const lines = [];
+    let current = "";
+    for (const word of words) {
+        if (current.length === 0) {
+            current = word;
+        }
+        else if (current.length + 1 + word.length <= maxLen) {
+            current += " " + word;
+        }
+        else {
+            lines.push(current);
+            current = word;
+        }
+    }
+    if (current)
+        lines.push(current);
+    return lines.join("\n");
+}

package/dist/shared/utils/syntax.js

@@ -0,0 +1,128 @@
+const OPERATORS = new Set(["|", "&&", "||", ";", ">", ">>", "<"]);
+/**
+ * Scan a command line into tokens, preserving whitespace runs as
+ * "whitespace" tokens. Used by highlightSegments for rendering.
+ */
+function scanTokens(line) {
+    if (!line)
+        return [];
+    const tokens = [];
+    let i = 0;
+    const len = line.length;
+    while (i < len) {
+        // Whitespace run  preserve it as a token
+        if (line[i] === " " || line[i] === "\t") {
+            let j = i;
+            while (j < len && (line[j] === " " || line[j] === "\t"))
+                j++;
+            tokens.push({ type: "whitespace", value: line.slice(i, j) });
+            i = j;
+            continue;
+        }
+        // Try to match multi-char operators first (&&, ||, >>)
+        let opMatch;
+        for (const op of OPERATORS) {
+            if (op.length > 1 && line.slice(i, i + op.length) === op) {
+                opMatch = op;
+                break;
+            }
+        }
+        if (opMatch) {
+            tokens.push({ type: "operator", value: opMatch });
+            i += opMatch.length;
+            continue;
+        }
+        // Try to match single-char operators
+        if (OPERATORS.has(line[i])) {
+            tokens.push({ type: "operator", value: line[i] });
+            i++;
+            continue;
+        }
+        // Quoted string
+        if (line[i] === '"' || line[i] === "'") {
+            const quote = line[i];
+            let j = i + 1;
+            while (j < len && line[j] !== quote) {
+                // Handle escaped quote
+                if (line[j] === "\\" && j + 1 < len) {
+                    j += 2;
+                }
+                else {
+                    j++;
+                }
+            }
+            // Include closing quote if found
+            if (j < len && line[j] === quote)
+                j++;
+            tokens.push({ type: "string", value: line.slice(i, j) });
+            i = j;
+            continue;
+        }
+        // Unquoted word  consume until whitespace or operator
+        let j = i;
+        while (j < len) {
+            if (line[j] === " " || line[j] === "\t")
+                break;
+            // Check for multi-char operator boundary
+            let isOpBoundary = false;
+            for (const op of OPERATORS) {
+                if (op.length > 1 && line.slice(j, j + op.length) === op) {
+                    isOpBoundary = true;
+                    break;
+                }
+            }
+            if (isOpBoundary)
+                break;
+            // Check for single-char operator boundary
+            if (OPERATORS.has(line[j])) {
+                break;
+            }
+            // Check for quoted string start
+            if (line[j] === '"' || line[j] === "'")
+                break;
+            j++;
+        }
+        const raw = line.slice(i, j);
+        tokens.push(classifyWord(raw));
+        i = j;
+    }
+    return tokens;
+}
+/**
+ * Tokenize a command line for syntax highlighting purposes.
+ * This is a cosmetic tokenizer  the real parsing for execution
+ * lives in src/loop-config.ts parseCommandLine.
+ *
+ * Whitespace is not returned (use highlightSegments for rendering
+ * that needs to preserve spacing).
+ */
+export function tokenizeCommand(line) {
+    return scanTokens(line).filter((tok) => tok.type !== "whitespace");
+}
+/**
+ * Produce colored segments for a command line, preserving whitespace
+ * exactly so token-by-token rendering does not collapse spaces.
+ */
+export function highlightSegments(line, colors, whitespaceColor) {
+    return scanTokens(line).map((tok) => ({
+        value: tok.value,
+        color: tok.type === "whitespace" ? whitespaceColor : colors[tok.type],
+    }));
+}
+function classifyWord(value) {
+    // Flag: --something (long flag)
+    if (value.startsWith("--") && value.length > 2) {
+        return { type: "flag", value };
+    }
+    // Flag: -f (single letter flag, not negative number like -1)
+    if (value.startsWith("-") &&
+        value.length === 2 &&
+        /[a-zA-Z]/.test(value[1])) {
+        return { type: "flag", value };
+    }
+    // Flag: -abc (combined short flags like -xyz)
+    if (value.startsWith("-") && value.length > 1 && /^[a-zA-Z]+$/.test(value.slice(1))) {
+        return { type: "flag", value };
+    }
+    return { type: "word", value };
+}

package/dist/shared/utils/validation.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import { parseDuration } from "../../duration.js";
+import { parseMaxRuns } from "../../loop-config.js";
+import { t } from "../i18n/index.js";
+const validators = {
+    name(value) {
+        if (!value.trim())
+            return t("errors.commandEmpty");
+        return null;
+    },
+    interval(value) {
+        if (!value.trim())
+            return null;
+        try {
+            parseDuration(value);
+            return null;
+        }
+        catch (err) {
+            return err instanceof Error ? err.message : t("wizard.validationError");
+        }
+    },
+    command(value, options) {
+        if (options?.taskMode === "existing")
+            return null;
+        if (!value.trim())
+            return t("errors.commandEmpty");
+        return null;
+    },
+    description(value) {
+        if (!value.trim())
+            return null;
+        return null;
+    },
+    maxRuns(value) {
+        if (!value.trim())
+            return null;
+        try {
+            parseMaxRuns(value);
+            return null;
+        }
+        catch (err) {
+            return err instanceof Error ? err.message : t("wizard.validationError");
+        }
+    },
+    cwd(value) {
+        if (!value.trim())
+            return null;
+        if (!fs.existsSync(value))
+            return t("board.cwdMissing", { cwd: value });
+        return null;
+    },
+};
+export function validateField(key, value, options) {
+    const fn = validators[key];
+    return fn ? fn(value, options) : null;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export const DEFAULT_TASK_MAX_RUNS = 5;

package/dist/visual-evidence/capture.js

@@ -0,0 +1,51 @@
+/**
+ * capture.ts — Capture CLI output as evidence assets.
+ *
+ * For a CLI app, evidence is text-based (stdout/stderr captured to .txt files),
+ * not browser screenshots. Each capture checkpoint writes a numbered .txt file.
+ */
+import { writeFileSync, existsSync, mkdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+/** Max bytes per capture file (1 MB) */
+const MAX_CAPTURE_BYTES = 1_024_000;
+/**
+ * Write capture files and return asset descriptors.
+ * Files go to openspec/changes/<changeId>/evidence/NN-label.txt
+ */
+export function captureOutput(changeId, checkpoints) {
+    const evidenceDir = join("openspec", "changes", changeId, "evidence");
+    if (!existsSync(evidenceDir)) {
+        mkdirSync(evidenceDir, { recursive: true });
+    }
+    return checkpoints.map((cp, i) => {
+        const num = String(i + 1).padStart(2, "0");
+        const filename = `${num}-${cp.label.replace(/\s+/g, "-").toLowerCase()}.txt`;
+        const filepath = join(evidenceDir, filename);
+        const content = [
+            `# ${cp.label}`,
+            `# Exit code: ${cp.exitCode}`,
+            "",
+            "## stdout",
+            truncate(cp.stdout, MAX_CAPTURE_BYTES),
+            "",
+            "## stderr",
+            truncate(cp.stderr, MAX_CAPTURE_BYTES),
+        ].join("\n");
+        writeFileSync(filepath, content, "utf-8");
+        const bytes = statSync(filepath).size;
+        return {
+            type: "text-capture",
+            path: filepath,
+            caption: cp.label,
+            bytes,
+            format: "txt",
+        };
+    });
+}
+function truncate(text, maxBytes) {
+    const buf = Buffer.from(text, "utf-8");
+    if (buf.length <= maxBytes)
+        return text;
+    return (buf.subarray(0, maxBytes).toString("utf-8") +
+        `\n... [truncated, ${buf.length} bytes total]`);
+}

package/dist/visual-evidence/cli.js

@@ -0,0 +1,85 @@
+/**
+ * cli.ts — Visual evidence capture CLI.
+ *
+ * Usage:
+ *   pnpm visual-evidence --change <id>
+ *   pnpm visual-evidence --input <path.json>
+ *
+ * Exit codes: 0 = passed/skipped, 1 = failed, 2 = blocked, 3 = invalid input
+ *
+ * Capture never commits or pushes.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { runEvidence } from "./run.js";
+function parseArgs(args) {
+    const result = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--change" && args[i + 1]) {
+            result.changeId = args[++i];
+        }
+        else if (args[i] === "--input" && args[i + 1]) {
+            result.inputPath = args[++i];
+        }
+    }
+    return result;
+}
+async function main() {
+    const args = process.argv.slice(2);
+    const parsed = parseArgs(args);
+    if (!parsed.changeId && !parsed.inputPath) {
+        console.error("Usage: visual-evidence --change <id> | --input <path.json>");
+        return 3;
+    }
+    let changeId;
+    if (parsed.inputPath) {
+        if (!existsSync(parsed.inputPath)) {
+            console.error(`Input file not found: ${parsed.inputPath}`);
+            return 3;
+        }
+        const input = JSON.parse(readFileSync(parsed.inputPath, "utf-8"));
+        if (!input.changeId) {
+            console.error("Input JSON missing 'changeId'");
+            return 3;
+        }
+        changeId = input.changeId;
+    }
+    else {
+        changeId = parsed.changeId;
+    }
+    console.log(`🔍 Running evidence capture for change: ${changeId}`);
+    const result = await runEvidence(changeId);
+    const emoji = {
+        passed: "✅",
+        skipped: "⏭️",
+        failed: "❌",
+        blocked: "🚫",
+    };
+    console.log(`${emoji[result.status] ?? ""} Status: ${result.status}`);
+    if (result.reason) {
+        console.log(`   Reason: ${result.reason}`);
+    }
+    if (result.failedStep) {
+        console.log(`   Failed step: ${result.failedStep}`);
+    }
+    if (result.manifestPath) {
+        console.log(`   Manifest: ${result.manifestPath}`);
+    }
+    // Exit codes
+    switch (result.status) {
+        case "passed":
+        case "skipped":
+            return 0;
+        case "failed":
+            return 1;
+        case "blocked":
+            return 2;
+    }
+}
+main()
+    .then((code) => {
+    process.exit(code);
+})
+    .catch((err) => {
+    console.error("Unexpected error:", err);
+    process.exit(1);
+});