@plainconceptsplatform/loop-task 2.6.0

package/dist/app/App.js

@@ -0,0 +1,132 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useCallback, useEffect } from "react";
+import { Box, useApp } from "ink";
+import { useLoopPolling } from "../shared/hooks/useLoopPolling.js";
+import { useDaemonSettings } from "../shared/hooks/useDaemonSettings.js";
+import { useLogStream } from "../shared/hooks/useLogStream.js";
+import { useBreakpoint } from "../shared/hooks/useBreakpoint.js";
+import { BoardLayout } from "./BoardLayout.js";
+import { useToasts } from "../shared/ui/Toast.js";
+import { Header } from "../widgets/header/Header.js";
+import { LeftPanel } from "../widgets/left-panel/LeftPanel.js";
+import { RightPanel } from "../widgets/right-panel/RightPanel.js";
+import { CommandInput } from "../widgets/command-input/CommandInput.js";
+import { DebugPanel } from "../shared/ui/DebugPanel.js";
+import { useInject } from "../shared/hooks/useInject.js";
+import { TYPES } from "../shared/services/types.js";
+import { cycleSortMode, cycleStatusFilter } from "../entities/loops/filters.js";
+import { t } from "../shared/i18n/index.js";
+import { darkTheme as theme } from "../shared/ui/theme.js";
+import { useRouter } from "./router/index.js";
+import { useAppState } from "../features/state/useAppState.js";
+import { useCommandHandlers } from "../features/commands/useCommandHandlers.js";
+import { useContextualActions } from "../features/commands/useContextualActions.js";
+import { useOverlayStack } from "../features/overlays/useOverlayStack.js";
+import { useGlobalShortcuts } from "../features/commands/useGlobalShortcuts.js";
+import { FormRouter } from "../features/forms/FormRouter.js";
+import { OverlayStack } from "../features/overlays/OverlayStack.js";
+import { MOUSE_TRACKING_ENABLE } from "../shared/config/constants.js";
+function viewKey(view, editTarget, editTask) {
+    if (view === "create")
+        return `${view}:${editTarget?.id ?? "new"}`;
+    if (view === "task-edit")
+        return `${view}:${editTask?.id ?? "new"}`;
+    return view;
+}
+function isBoardView(view) {
+    return view === "board";
+}
+export function App(props) {
+    const { onQuit } = props;
+    const { exit } = useApp();
+    const loopService = useInject(TYPES.LoopService);
+    const taskService = useInject(TYPES.TaskService);
+    const projectService = useInject(TYPES.ProjectService);
+    const logService = useInject(TYPES.LogService);
+    const exportService = useInject(TYPES.ExportService);
+    const { loops, daemonStatus, refresh } = useLoopPolling();
+    const daemonSettings = useDaemonSettings();
+    const { view, push, pop } = useRouter("board");
+    const { toasts, push: pushToast } = useToasts();
+    const breakpoint = useBreakpoint();
+    // Re-emit DECSET mouse tracking after layout changes or on first render.
+    // Ink's internal raw-mode toggling during the initial render cycle and
+    // subsequent re-renders (e.g., on resize) can suppress mouse scroll events;
+    // re-emitting ensures the terminal re-enables them.
+    useEffect(() => {
+        process.stdout.write(MOUSE_TRACKING_ENABLE);
+    }, [breakpoint]);
+    const s = useAppState(loops, pushToast, refresh, loopService, taskService, projectService, logService, view, push, pop);
+    useLogStream(s.selectedId, view, (error) => pushToast("error", error.message));
+    const { handleCommand } = useCommandHandlers({
+        activeTab: s.activeTab, selected: s.selected, selectedRunIndex: s.selectedRunIndex, selectedTask: s.selectedTask, selectedProjectEntity: s.selectedProjectEntity,
+        tasks: s.tasks, projects: s.projects, currentProjectId: s.currentProjectId, filters: s.filters, projectFilters: s.projectFilters,
+        setCloneMode: s.setCloneMode, setEditTarget: s.setEditTarget, setPendingTaskSelection: s.setPendingTaskSelection,
+        setEditTask: s.setEditTask, setEditProject: s.setEditProject, setActiveTab: s.setActiveTab,
+        setConfirmState: s.setConfirmState, setCommandsBrowserOpen: s.setCommandsBrowserOpen, setSearchValue: s.setSearchValue, setSearchState: s.setSearchState,
+        setFilters: s.setFilters, setSort: s.setSort, setCurrentProjectId: s.setCurrentProjectId,
+        setProjectFilters: s.setProjectFilters, setProjectSelectedIndex: s.setProjectSelectedIndex,
+        setDebugMode: s.setDebugMode, setExportModal: s.setExportModal, setDiagramModal: s.setDiagramModal,
+        push, pop, refresh, refreshTasks: s.refreshTasks, refreshProjects: s.refreshProjects, pushToast,
+        loopService, taskService, projectService, exportService, logService,
+        runAction: s.runAction, handleOpenRunLog: s.handleOpenRunLog,
+    });
+    const { handleContextualCopy, triggerContextualAction } = useContextualActions({
+        activeTab: s.activeTab, focusedPanel: s.focusedPanel, selected: s.selected, selectedRunIndex: s.selectedRunIndex, selectedTask: s.selectedTask, selectedProjectEntity: s.selectedProjectEntity,
+        tasks: s.tasks, push, setCloneMode: s.setCloneMode, setEditTarget: s.setEditTarget, setPendingTaskSelection: s.setPendingTaskSelection,
+        handleCommand, handleOpenRunLog: s.handleOpenRunLog, pushToast, isBoardView,
+        view, logModalRun: s.logModalRun, commandsBrowserOpen: s.commandsBrowserOpen, confirmState: s.confirmState, searchState: s.searchState,
+        setChordState: s.setChordState, chordState: s.chordState,
+    });
+    const { popLayer, anyModalOpen, commandInputDisabled, inputOwner } = useOverlayStack({
+        confirmState: s.confirmState, setConfirmState: s.setConfirmState, searchState: s.searchState, setSearchState: s.setSearchState, setSearchValue: s.setSearchValue,
+        logModalRun: s.logModalRun, setLogModalRun: s.setLogModalRun, logModalLoopId: s.logModalLoopId, setLogModalLoopId: s.setLogModalLoopId,
+        commandsBrowserOpen: s.commandsBrowserOpen, setCommandsBrowserOpen: s.setCommandsBrowserOpen, exportModal: s.exportModal, setExportModal: s.setExportModal,
+        diagramModal: s.diagramModal, setDiagramModal: s.setDiagramModal,
+        contextHelpOpen: s.contextHelpOpen, setContextHelpOpen: s.setContextHelpOpen, view, pop, onQuit, exit,
+        commandBarHasText: s.commandBarHasText, commandBarDropdownOpen: s.commandBarDropdownOpen,
+    });
+    useGlobalShortcuts({
+        activeTab: s.activeTab, focusedPanel: s.focusedPanel, setFocusedPanel: s.setFocusedPanel, setActiveTab: s.setActiveTab,
+        view, handleCommand, triggerContextualAction, popLayer,
+        anyModalOpen, debugMode: s.debugMode, setDebugEntries: s.setDebugEntries, inputOwner,
+        confirmState: s.confirmState, searchState: s.searchState, logModalRun: s.logModalRun, commandsBrowserOpen: s.commandsBrowserOpen, exportModal: s.exportModal,
+        diagramModal: s.diagramModal,
+        contextHelpOpen: s.contextHelpOpen, setContextHelpOpen: s.setContextHelpOpen, onQuit, exit, setConfirmState: s.setConfirmState,
+        setLogModalRun: s.setLogModalRun, setLogModalLoopId: s.setLogModalLoopId, setCommandsBrowserOpen: s.setCommandsBrowserOpen,
+        chordState: s.chordState, setChordState: s.setChordState,
+    });
+    const handleConfirmYes = useCallback(() => { if (s.confirmState) {
+        s.confirmState.onConfirm();
+        s.setConfirmState(null);
+    } }, [s.confirmState]);
+    const handleConfirmCancel = useCallback(() => { s.setConfirmState(null); }, []);
+    const cancelCreate = () => { s.setEditTarget(null); s.setCloneMode(false); s.setPendingTaskSelection(null); pop(); };
+    const cancelTask = () => { s.setEditTask(null); pop(); };
+    const cancelProject = () => { s.setEditProject(null); pop(); };
+    const handleChooseTask = (task) => { s.setPendingTaskSelection(task); };
+    const onCreateDone = (updated, _id, desc) => {
+        s.setEditTarget(null);
+        s.setCloneMode(false);
+        s.setPendingTaskSelection(null);
+        pop();
+        pushToast("success", updated ? t("board.toastUpdated", { desc }) : t("board.toastStarted", { desc }));
+        void refresh();
+    };
+    const onTaskDone = (updated, id) => {
+        s.setEditTask(null);
+        void s.refreshTasks();
+        pop();
+        pushToast("success", updated ? t("board.toastTaskUpdated", { id }) : t("board.toastTaskCreated", { id }));
+    };
+    const onProjectDone = (updated, name) => {
+        s.setEditProject(null);
+        void s.refreshProjects();
+        pop();
+        pushToast("success", updated ? t("project.toastUpdated", { name }) : t("project.toastCreated", { name }));
+    };
+    const commandContext = useMemo(() => ({ activeTab: s.activeTab, selectedLoop: s.selected, selectedTask: s.selectedTask, selectedProject: s.selectedProjectEntity }), [s.activeTab, s.selected, s.selectedTask]);
+    return (_jsxs(Box, { flexDirection: "column", width: "100%", height: process.stdout.rows || 24, backgroundColor: theme.bg.base, children: [_jsx(Header, { daemonStatus: daemonStatus, httpApiEnabled: daemonSettings.reachable ? daemonSettings.httpApiEnabled : undefined, mcpApiEnabled: daemonSettings.reachable ? daemonSettings.mcpApiEnabled : undefined, telemetryEnabled: daemonSettings.reachable ? daemonSettings.telemetryEnabled : undefined, counts: s.counts, activeTab: s.activeTab, onTabChange: s.setActiveTab, tabCounts: s.tabCounts }), _jsx(Box, { flexGrow: 1, width: "100%", children: isBoardView(view) ? (_jsxs(BoardLayout, { breakpoint: breakpoint, children: [_jsx(LeftPanel, { isFocused: (breakpoint === "minimal" || s.focusedPanel === "left") && !anyModalOpen, navActive: inputOwner === "panel", activeTab: s.activeTab, query: s.leftPanelQuery, loops: s.visible, selectedIndex: s.clampedIndex, filters: s.filters, sort: s.sort, breakpoint: breakpoint, projects: s.filteredProjects, onSelect: (i) => s.setSelectedIndex(i), onActivate: (i) => { s.setSelectedIndex(i); }, tasks: s.filteredTasks, taskSelectedIndex: s.taskClampedIndex, onTaskSelect: (i) => s.setTaskSelectedIndex(i), onTaskActivate: (i) => { s.setTaskSelectedIndex(i); s.setEditTask(s.filteredTasks[i] ?? null); push("task-edit"); }, onStatusCycle: () => s.setFilters((prev) => ({ ...prev, status: cycleStatusFilter(prev.status) })), onSortCycle: () => s.setSort(cycleSortMode(s.sort)), onSelectProject: () => s.setActiveTab("projects"), currentProjectName: s.currentProjectId === "all" ? t("project.showAll") : (s.projects.find(p => p.id === s.currentProjectId)?.name ?? "Default"), projectFilters: s.projectFilters, projectSelectedIndex: s.projectClampedIndex, onProjectSelect: (i) => s.setProjectSelectedIndex(i), onProjectActivate: (i) => { s.setProjectSelectedIndex(i); }, projectLoops: loops }), breakpoint !== "minimal" ? (_jsx(RightPanel, { breakpoint: breakpoint, isFocused: s.focusedPanel === "right" && !anyModalOpen, navActive: inputOwner === "panel", activeTab: s.activeTab, loop: s.selected, selectedRunIndex: s.selectedRunIndex, onSelectRun: (i) => s.setSelectedRunIndex(i), onOpenRun: s.handleOpenRunLog, selectedTask: s.selectedTask, allTasks: s.tasks, selectedProject: s.selectedProjectEntity, projectLoopCount: s.projectLoopCount, projects: s.projects, onProjectEdit: () => { if (s.selectedProjectEntity && !s.selectedProjectEntity.isSystem)
+                                handleCommand("edit"); }, onProjectDelete: () => { if (s.selectedProjectEntity && !s.selectedProjectEntity.isSystem)
+                                handleCommand("delete"); } })) : null, s.debugMode ? _jsx(DebugPanel, { breakpoint: breakpoint, entries: s.debugEntries }) : null] })) : (_jsx(FormRouter, { view: view, editTarget: s.editTarget, cloneMode: s.cloneMode, editTask: s.editTask, editProject: s.editProject, pendingTaskSelection: s.pendingTaskSelection, tasks: s.tasks, projects: s.projects, currentProjectId: s.currentProjectId, cancelCreate: cancelCreate, onCreateDone: onCreateDone, handleChooseTask: handleChooseTask, cancelTask: cancelTask, onTaskDone: onTaskDone, cancelProject: cancelProject, onProjectDone: onProjectDone })) }, viewKey(view, s.editTarget, s.editTask)), isBoardView(view) ? (_jsx(CommandInput, { context: commandContext, onCommand: handleCommand, confirmState: s.confirmState, searchState: s.searchState, searchValue: s.searchValue, onSearchChange: s.handleSearchChange, onSearchSubmit: s.handleSearchSubmit, onSearchCancel: s.handleSearchCancel, onConfirmYes: handleConfirmYes, onConfirmCancel: handleConfirmCancel, onCopy: handleContextualCopy, onPanelAction: triggerContextualAction, disabled: commandInputDisabled, navOwner: inputOwner, onInputStateChange: (hasText, dropdownOpen) => { s.setCommandBarHasText(hasText); s.setCommandBarDropdownOpen(dropdownOpen); } })) : null, _jsx(OverlayStack, { commandsBrowserOpen: s.commandsBrowserOpen, commandContext: commandContext, onCommandsBrowserClose: () => s.setCommandsBrowserOpen(false), onCommandsBrowserExecute: (v) => { s.setCommandsBrowserOpen(false); handleCommand(v); }, contextHelpOpen: s.contextHelpOpen, onContextHelpClose: () => s.setContextHelpOpen(false), exportModal: s.exportModal, onExportModalClose: () => s.setExportModal(null), onExportCopy: () => pushToast("success", t("board.toastCopied")), diagramModal: s.diagramModal, onDiagramModalClose: () => s.setDiagramModal(null), logModalRun: s.logModalRun, logModalLoopId: s.logModalLoopId, logModalLines: s.logModalLines, logModalLoading: s.logModalLoading, onLogModalClose: () => { s.setLogModalRun(null); s.setLogModalLoopId(null); }, onLogCopy: () => pushToast("success", t("board.toastCopied")), toasts: toasts })] }));
+}

package/dist/app/BoardLayout.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Box } from "ink";
+export function BoardLayout(props) {
+    return (_jsx(Box, { width: "100%", flexGrow: 1, children: _jsx(Box, { width: "100%", flexDirection: props.breakpoint === "wide" ? "row" : "column", flexGrow: 1, children: props.children }) }));
+}

package/dist/app/index.js

@@ -0,0 +1,48 @@
+import { render } from "ink";
+import React from "react";
+import { App } from "./App.js";
+import { BRACKETED_PASTE_ENABLE, BRACKETED_PASTE_DISABLE, MOUSE_TRACKING_ENABLE, MOUSE_TRACKING_DISABLE, USER_TIMING_SWEEP_MS } from "../shared/config/constants.js";
+import { InversifyProvider } from "../shared/providers/InversifyProvider.js";
+function startUserTimingSweep() {
+    const timer = setInterval(() => {
+        performance.clearMarks();
+        performance.clearMeasures();
+    }, USER_TIMING_SWEEP_MS);
+    timer.unref();
+}
+export async function launchBoard() {
+    startUserTimingSweep();
+    process.stdout.write(BRACKETED_PASTE_ENABLE);
+    process.stdout.write(MOUSE_TRACKING_ENABLE);
+    const disableBracketedPaste = () => process.stdout.write(BRACKETED_PASTE_DISABLE);
+    const disableMouseTracking = () => process.stdout.write(MOUSE_TRACKING_DISABLE);
+    const instance = render(React.createElement(InversifyProvider, null, React.createElement(App, {
+        onQuit: () => {
+            disableBracketedPaste();
+            disableMouseTracking();
+            instance.unmount();
+        }
+    })));
+    // Re-emit DECSET sequences after Ink's first render cycle completes.
+    // Ink internally toggles raw mode during mount, which can suppress the
+    // mouse tracking and bracketed paste modes we enabled above. Re-emitting
+    // after a tick ensures the terminal re-enables them once Ink is steady.
+    setTimeout(() => {
+        process.stdout.write(MOUSE_TRACKING_ENABLE);
+        process.stdout.write(BRACKETED_PASTE_ENABLE);
+    }, 100);
+    process.on("exit", () => {
+        disableBracketedPaste();
+        disableMouseTracking();
+    });
+    process.on("uncaughtException", (error) => {
+        console.error("Uncaught exception:", error);
+        disableBracketedPaste();
+        disableMouseTracking();
+        instance.unmount();
+        process.exit(1);
+    });
+    process.on("unhandledRejection", (reason) => {
+        console.error("Unhandled rejection:", reason);
+    });
+}

package/dist/app/providers/index.js

@@ -0,0 +1 @@
+export { InversifyProvider, InversifyContext } from "../../shared/providers/InversifyProvider.js";

package/dist/app/router/index.js

@@ -0,0 +1,16 @@
+import { useState, useCallback } from "react";
+export function useRouter(initial = "board") {
+    const [stack, setStack] = useState([initial]);
+    const view = stack[stack.length - 1] ?? initial;
+    const canGoBack = stack.length > 1;
+    const push = useCallback((next) => {
+        setStack((s) => [...s, next]);
+    }, []);
+    const replace = useCallback((next) => {
+        setStack((s) => [...s.slice(0, -1), next]);
+    }, []);
+    const pop = useCallback(() => {
+        setStack((s) => (s.length > 1 ? s.slice(0, -1) : s));
+    }, []);
+    return { view, stack, push, replace, pop, canGoBack };
+}

package/dist/app/types.js

@@ -0,0 +1 @@
+export {};

package/dist/cli/import-validator.js

@@ -0,0 +1,152 @@
+const PROJECT_FIELDS = [
+    { name: "id", type: "string", nullable: false },
+    { name: "name", type: "string", nullable: false },
+    { name: "color", type: "string", nullable: false },
+    { name: "createdAt", type: "string", nullable: false },
+    { name: "isSystem", type: "boolean", nullable: false },
+    { name: "isDefault", type: "boolean", nullable: false },
+];
+const TASK_FIELDS = [
+    { name: "id", type: "string", nullable: false },
+    { name: "name", type: "string", nullable: false },
+    { name: "command", type: "string", nullable: false },
+    { name: "commandArgs", type: "array", nullable: false },
+    { name: "onSuccessTaskId", type: "string", nullable: true },
+    { name: "onFailureTaskId", type: "string", nullable: true },
+    { name: "maxRuns", type: "number", nullable: false },
+    { name: "createdAt", type: "string", nullable: false },
+];
+const LOOP_FIELDS = [
+    { name: "id", type: "string", nullable: false },
+    { name: "taskId", type: "string", nullable: true },
+    { name: "command", type: "string", nullable: false },
+    { name: "commandArgs", type: "array", nullable: false },
+    { name: "interval", type: "number", nullable: false },
+    { name: "intervalHuman", type: "string", nullable: false },
+    { name: "immediate", type: "boolean", nullable: false },
+    { name: "maxRuns", type: "number", nullable: true },
+    { name: "verbose", type: "boolean", nullable: false },
+    { name: "cwd", type: "string", nullable: false },
+    { name: "description", type: "string", nullable: false },
+    { name: "status", type: "string", nullable: false },
+    { name: "createdAt", type: "string", nullable: false },
+    { name: "sessionStartedAt", type: "string", nullable: true },
+    { name: "runCount", type: "number", nullable: false },
+    { name: "lastRunAt", type: "string", nullable: true },
+    { name: "lastExitCode", type: "number", nullable: true },
+    { name: "lastDuration", type: "number", nullable: true },
+    { name: "nextRunAt", type: "string", nullable: true },
+    { name: "remainingDelayMs", type: "number", nullable: true },
+    { name: "pid", type: "number", nullable: false },
+    { name: "maxRunsReached", type: "boolean", nullable: false },
+    { name: "runHistory", type: "array", nullable: true },
+    { name: "skippedCount", type: "number", nullable: false },
+    { name: "projectId", type: "string", nullable: false },
+    { name: "offset", type: "number", nullable: true },
+];
+const EXPECTED_VERSION = 2;
+const REQUIRED_KEYS = ["loops", "tasks", "projects"];
+function validateItems(items, fields, label) {
+    const errors = [];
+    for (let i = 0; i < items.length; i++) {
+        const item = items[i];
+        if (typeof item !== "object" || item === null || Array.isArray(item)) {
+            errors.push({ key: "item", message: `${label}[${i}]: must be an object` });
+            continue;
+        }
+        const record = item;
+        for (const field of fields) {
+            const value = record[field.name];
+            if (value === undefined || value === null) {
+                if (!field.nullable) {
+                    errors.push({ key: "item", message: `${label}[${i}]: missing field '${field.name}'` });
+                }
+                continue;
+            }
+            if (field.nullable && value === null)
+                continue;
+            switch (field.type) {
+                case "string":
+                    if (typeof value !== "string") {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be a string` });
+                    }
+                    break;
+                case "number":
+                    if (typeof value !== "number") {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be a number` });
+                    }
+                    break;
+                case "boolean":
+                    if (typeof value !== "boolean") {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be a boolean` });
+                    }
+                    break;
+                case "array":
+                    if (!Array.isArray(value)) {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be an array` });
+                    }
+                    break;
+                case "object":
+                    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+                        errors.push({ key: "item", message: `${label}[${i}]: field '${field.name}' must be an object` });
+                    }
+                    break;
+            }
+        }
+    }
+    return errors;
+}
+export function validateExportFile(raw) {
+    const errors = [];
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        return { valid: false, errors: [{ key: "version", message: "Invalid export file: expected a JSON object" }] };
+    }
+    const data = raw;
+    if (!("version" in data)) {
+        return { valid: false, errors: [{ key: "version", message: "Missing export version. Expected: 2" }] };
+    }
+    if (data.version !== EXPECTED_VERSION) {
+        return {
+            valid: false,
+            errors: [{ key: "version", message: `Unsupported export version: ${data.version}. Expected: ${EXPECTED_VERSION}` }],
+        };
+    }
+    const missingKeys = [];
+    const nonArrayKeys = [];
+    for (const key of REQUIRED_KEYS) {
+        if (!(key in data)) {
+            missingKeys.push(key);
+        }
+        else if (!Array.isArray(data[key])) {
+            nonArrayKeys.push(key);
+        }
+    }
+    if (missingKeys.length > 0) {
+        errors.push({ key: "missing_keys", message: `Missing required keys: ${missingKeys.join(", ")}` });
+    }
+    if (nonArrayKeys.length > 0) {
+        for (const key of nonArrayKeys) {
+            errors.push({ key: "non_array_keys", message: `field '${key}' must be an array` });
+        }
+    }
+    if (errors.length > 0) {
+        return { valid: false, errors };
+    }
+    const itemErrors = [
+        ...validateItems(data.loops, LOOP_FIELDS, "loops"),
+        ...validateItems(data.tasks, TASK_FIELDS, "tasks"),
+        ...validateItems(data.projects, PROJECT_FIELDS, "projects"),
+    ];
+    if (itemErrors.length > 0) {
+        return { valid: false, errors: itemErrors };
+    }
+    return {
+        valid: true,
+        errors: [],
+        data: {
+            loops: data.loops,
+            tasks: data.tasks,
+            projects: data.projects,
+        },
+    };
+}

package/dist/cli/import-writer.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import path from "node:path";
+import { writeFileAtomic } from "../shared/fs-utils.js";
+import { getDataDir } from "../shared/config/paths.js";
+const STORE_FILES = ["loops.json", "tasks.json", "projects.json"];
+function backupFilePath(filePath) {
+    return `${filePath}.bak`;
+}
+export function atomicImportWrite(loops, tasks, projects) {
+    const dataDir = getDataDir();
+    fs.mkdirSync(dataDir, { recursive: true });
+    const normalizedLoops = loops.map((loop) => ({
+        ...loop,
+        runHistory: Array.isArray(loop.runHistory) ? loop.runHistory : [],
+    }));
+    const contents = {
+        "loops.json": JSON.stringify(normalizedLoops, null, 2),
+        "tasks.json": JSON.stringify(tasks, null, 2),
+        "projects.json": JSON.stringify(projects, null, 2),
+    };
+    const backups = new Map();
+    for (const store of STORE_FILES) {
+        const storePath = path.join(dataDir, store);
+        if (fs.existsSync(storePath) && fs.statSync(storePath).isFile()) {
+            backups.set(store, fs.readFileSync(storePath, "utf-8"));
+        }
+        else {
+            backups.set(store, null);
+        }
+    }
+    const writtenStores = [];
+    try {
+        for (const store of STORE_FILES) {
+            const storePath = path.join(dataDir, store);
+            writeFileAtomic(storePath, contents[store]);
+            writtenStores.push(store);
+        }
+    }
+    catch (err) {
+        const writeError = err;
+        for (const store of STORE_FILES) {
+            const storePath = path.join(dataDir, store);
+            const backup = backups.get(store) ?? null;
+            if (backup !== null) {
+                try {
+                    writeFileAtomic(storePath, backup);
+                }
+                catch {
+                    // best-effort restore
+                }
+            }
+            else {
+                try {
+                    if (fs.existsSync(storePath) && fs.statSync(storePath).isFile()) {
+                        fs.unlinkSync(storePath);
+                    }
+                }
+                catch {
+                    // best-effort cleanup
+                }
+            }
+        }
+        return {
+            success: false,
+            error: writeError.message,
+            writtenStores,
+        };
+    }
+    for (const store of STORE_FILES) {
+        const bakPath = backupFilePath(path.join(dataDir, store));
+        try {
+            if (fs.existsSync(bakPath)) {
+                fs.unlinkSync(bakPath);
+            }
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+    return { success: true, writtenStores: [...STORE_FILES] };
+}