brainfile 0.18.0 → 0.19.0

package/dist/tui/actions.js

@@ -1,1251 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.moveTaskAction = moveTaskAction;
-exports.deleteTaskAction = deleteTaskAction;
-exports.archiveTaskAction = archiveTaskAction;
-exports.archiveTaskActionAsync = archiveTaskActionAsync;
-exports.patchTaskAction = patchTaskAction;
-exports.cyclePriorityAction = cyclePriorityAction;
-exports.toggleSubtaskAction = toggleSubtaskAction;
-exports.addTaskAction = addTaskAction;
-exports.newTaskInEditor = newTaskInEditor;
-exports.editTaskInEditor = editTaskInEditor;
-exports.copyToClipboard = copyToClipboard;
-exports.addRuleAction = addRuleAction;
-exports.updateRuleAction = updateRuleAction;
-exports.deleteRuleAction = deleteRuleAction;
-exports.loadLogs = loadLogs;
-exports.restoreTaskAction = restoreTaskAction;
-exports.deleteArchivedTaskAction = deleteArchivedTaskAction;
-/**
- * TUI Actions - Wrappers around @brainfile/core operations
- *
- * All actions read/write the brainfile directly. The file watcher
- * in useBrainfileLoader will detect changes and refresh the UI.
- */
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const child_process_1 = require("child_process");
-const core_1 = require("@brainfile/core");
-const config_1 = require("../utils/config");
-const v2_detect_1 = require("../utils/v2-detect");
-const github_auth_1 = require("../utils/github-auth");
-const linear_auth_1 = require("../utils/linear-auth");
-/**
- * Read and parse the brainfile
- */
-function readBrainfile(filePath) {
-    try {
-        const content = fs.readFileSync(filePath, 'utf-8');
-        const result = core_1.Brainfile.parseWithErrors(content);
-        if (!result.board) {
-            return { board: null, content, error: result.error || 'Failed to parse brainfile' };
-        }
-        return { board: result.board, content };
-    }
-    catch (err) {
-        return { board: null, content: '', error: err instanceof Error ? err.message : String(err) };
-    }
-}
-/**
- * Write the board back to the brainfile
- */
-function writeBrainfile(filePath, board) {
-    try {
-        const content = core_1.Brainfile.serialize(board);
-        fs.writeFileSync(filePath, content, 'utf-8');
-        return { success: true };
-    }
-    catch (err) {
-        return { success: false, error: err instanceof Error ? err.message : String(err) };
-    }
-}
-/**
- * Read board with tasks populated (v1: embedded, v2: reconstructed from board/ files).
- */
-function readBoardState(filePath) {
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const board = (0, v2_detect_1.buildBoardFromV2)(filePath);
-            return { board, content };
-        }
-        catch (err) {
-            return { board: null, content: '', error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    return readBrainfile(filePath);
-}
-/**
- * Read board config only (for rules/settings changes that should not touch task files).
- */
-function readBoardConfigOnly(filePath) {
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        try {
-            const content = fs.readFileSync(filePath, 'utf-8');
-            const board = (0, v2_detect_1.readV2BoardConfig)(filePath);
-            return { board, content };
-        }
-        catch (err) {
-            return { board: null, content: '', error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    return readBrainfile(filePath);
-}
-/**
- * Resolve a task file path in v2 board directory.
- */
-function resolveV2TaskPath(filePath, taskId) {
-    const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
-    const doc = (0, core_1.findTask)(dirs.boardDir, taskId);
-    if (!doc || !doc.filePath)
-        return null;
-    return { taskPath: doc.filePath, task: doc.task };
-}
-/**
- * Move a task to a different column
- */
-function moveTaskAction(filePath, taskId, targetColumnId) {
-    const { board, error } = readBoardState(filePath);
-    if (!board)
-        return { success: false, error };
-    const taskInfo = (0, core_1.findTaskById)(board, taskId);
-    if (!taskInfo)
-        return { success: false, error: `Task ${taskId} not found` };
-    const targetColumn = (0, core_1.findColumnById)(board, targetColumnId) || (0, core_1.findColumnByName)(board, targetColumnId);
-    if (!targetColumn)
-        return { success: false, error: `Column ${targetColumnId} not found` };
-    if (taskInfo.column.id === targetColumn.id) {
-        return { success: true, message: 'Task already in this column' };
-    }
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const located = resolveV2TaskPath(filePath, taskId);
-        if (!located)
-            return { success: false, error: `Task ${taskId} not found` };
-        const moveResult = (0, core_1.moveTaskFile)(located.taskPath, targetColumn.id, targetColumn.tasks.length);
-        if (!moveResult.success)
-            return { success: false, error: moveResult.error };
-        return { success: true, message: `Moved to ${targetColumn.title}` };
-    }
-    const result = (0, core_1.moveTask)(board, taskId, taskInfo.column.id, targetColumn.id, targetColumn.tasks.length);
-    if (!result.success)
-        return { success: false, error: result.error };
-    const writeResult = writeBrainfile(filePath, result.board);
-    if (!writeResult.success)
-        return writeResult;
-    return { success: true, message: `Moved to ${targetColumn.title}` };
-}
-/**
- * Delete a task permanently
- */
-function deleteTaskAction(filePath, taskId) {
-    const { board, error } = readBoardState(filePath);
-    if (!board)
-        return { success: false, error };
-    const taskInfo = (0, core_1.findTaskById)(board, taskId);
-    if (!taskInfo)
-        return { success: false, error: `Task ${taskId} not found` };
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const located = resolveV2TaskPath(filePath, taskId);
-        if (!located)
-            return { success: false, error: `Task ${taskId} not found` };
-        const result = (0, core_1.deleteTaskFile)(located.taskPath);
-        if (!result.success)
-            return { success: false, error: result.error };
-        return { success: true, message: `Deleted ${taskId}` };
-    }
-    const result = (0, core_1.deleteTask)(board, taskInfo.column.id, taskId);
-    if (!result.success)
-        return { success: false, error: result.error };
-    const writeResult = writeBrainfile(filePath, result.board);
-    if (!writeResult.success)
-        return writeResult;
-    return { success: true, message: `Deleted ${taskId}` };
-}
-/**
- * Get the archive file path for a brainfile
- * Archive lives in same directory: brainfile.md -> brainfile-archive.md
- */
-function getArchivePath(filePath) {
-    const dir = path.dirname(filePath);
-    const filename = path.basename(filePath);
-    const archiveFilename = filename.replace(/\.md$/, '-archive.md');
-    return path.join(dir, archiveFilename);
-}
-/**
- * Create an empty archive board structure
- */
-function createEmptyArchiveBoard() {
-    return {
-        title: 'Logs',
-        columns: [],
-        archive: [],
-    };
-}
-/**
- * Archive a task to a separate brainfile-archive.md file
- * Per protocol spec, archived tasks go to a separate file, not inline archive array
- */
-function archiveTaskAction(filePath, taskId) {
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
-        const located = resolveV2TaskPath(filePath, taskId);
-        if (!located)
-            return { success: false, error: `Task ${taskId} not found` };
-        const result = (0, core_1.completeTaskFile)(located.taskPath, dirs.logsDir);
-        if (!result.success)
-            return { success: false, error: result.error };
-        return { success: true, message: `Moved ${taskId} to logs` };
-    }
-    const { board, error } = readBrainfile(filePath);
-    if (!board)
-        return { success: false, error };
-    const taskInfo = (0, core_1.findTaskById)(board, taskId);
-    if (!taskInfo)
-        return { success: false, error: `Task ${taskId} not found` };
-    const task = taskInfo.task;
-    const columnId = taskInfo.column.id;
-    // Remove task from the main board (don't use archiveTask - it puts task in inline archive)
-    const result = (0, core_1.deleteTask)(board, columnId, taskId);
-    if (!result.success)
-        return { success: false, error: result.error };
-    // Save the main board without the task
-    const writeResult = writeBrainfile(filePath, result.board);
-    if (!writeResult.success)
-        return writeResult;
-    // Now add the task to the separate archive file
-    const archivePath = getArchivePath(filePath);
-    // Read or create archive file
-    let archiveBoard;
-    if (fs.existsSync(archivePath)) {
-        try {
-            const archiveContent = fs.readFileSync(archivePath, 'utf-8');
-            const parseResult = core_1.Brainfile.parseWithErrors(archiveContent);
-            if (parseResult.board) {
-                archiveBoard = parseResult.board;
-            }
-            else {
-                archiveBoard = createEmptyArchiveBoard();
-            }
-        }
-        catch {
-            archiveBoard = createEmptyArchiveBoard();
-        }
-    }
-    else {
-        archiveBoard = createEmptyArchiveBoard();
-    }
-    // Add task to archive (at beginning)
-    if (!archiveBoard.archive) {
-        archiveBoard.archive = [];
-    }
-    archiveBoard.archive.unshift(task);
-    // Save archive file
-    try {
-        const archiveContent = core_1.Brainfile.serialize(archiveBoard);
-        fs.writeFileSync(archivePath, archiveContent, 'utf-8');
-    }
-    catch (err) {
-        // Task was removed from main board but archive write failed
-        // This is a partial failure state - log and report
-        return {
-            success: false,
-            error: `Task removed from board but failed to write logs: ${err instanceof Error ? err.message : String(err)}`,
-        };
-    }
-    return { success: true, message: `Moved ${taskId} to logs` };
-}
-/**
- * Archive a task with support for external destinations (GitHub, Linear)
- * Respects archive.destination from brainfile.md or global config
- */
-async function archiveTaskActionAsync(filePath, taskId) {
-    const { board, error } = readBoardState(filePath);
-    if (!board)
-        return { success: false, error };
-    const taskInfo = (0, core_1.findTaskById)(board, taskId);
-    if (!taskInfo)
-        return { success: false, error: `Task ${taskId} not found` };
-    const task = taskInfo.task;
-    const columnId = taskInfo.column.id;
-    const columnTitle = taskInfo.column.title;
-    // Determine destination from brainfile or config
-    const brainfileDestination = board.archive?.destination;
-    const parsedDest = (0, config_1.getEffectiveDestination)(brainfileDestination);
-    const destination = parsedDest.type;
-    // Handle local archive (default behavior)
-    if (destination === 'local') {
-        return archiveTaskAction(filePath, taskId);
-    }
-    // Handle GitHub archive
-    if (destination === 'github') {
-        if (!(await (0, github_auth_1.isGitHubAuthenticated)())) {
-            return { success: false, error: 'Not authenticated with GitHub. Run: brainfile auth github' };
-        }
-        const config = (0, config_1.getArchiveConfig)();
-        const owner = parsedDest.owner || config.github?.owner;
-        const repo = parsedDest.repo || config.github?.repo;
-        if (!owner || !repo) {
-            return { success: false, error: 'GitHub owner/repo not configured. Set archive.destination: github:owner/repo' };
-        }
-        const payload = (0, core_1.formatTaskForGitHub)(task, {
-            includeMeta: true,
-            includeSubtasks: true,
-            includeRelatedFiles: true,
-            boardTitle: board.title,
-            fromColumn: columnTitle,
-            extraLabels: config.github?.labels,
-        });
-        const ghResult = await (0, github_auth_1.createGitHubIssue)({
-            owner,
-            repo,
-            title: payload.title,
-            body: payload.body,
-            labels: payload.labels,
-            state: 'closed',
-        });
-        if (!ghResult.success) {
-            return { success: false, error: `GitHub: ${ghResult.error}` };
-        }
-        // Remove task from board
-        if ((0, v2_detect_1.isV2)(filePath)) {
-            const located = resolveV2TaskPath(filePath, taskId);
-            if (located) {
-                (0, core_1.deleteTaskFile)(located.taskPath);
-            }
-        }
-        else {
-            const deleteResult = (0, core_1.deleteTask)(board, columnId, taskId);
-            if (deleteResult.success) {
-                writeBrainfile(filePath, deleteResult.board);
-            }
-        }
-        return { success: true, message: `Moved to logs via GitHub #${ghResult.issueNumber}` };
-    }
-    // Handle Linear archive
-    if (destination === 'linear') {
-        if (!(await (0, linear_auth_1.isLinearAuthenticated)())) {
-            return { success: false, error: 'Not authenticated with Linear. Run: brainfile auth linear --token <key>' };
-        }
-        const config = (0, config_1.getArchiveConfig)();
-        let teamId = config.linear?.teamId;
-        // Resolve teamKey to teamId if provided in destination
-        if (parsedDest.teamKey) {
-            const teams = await (0, linear_auth_1.getLinearTeams)();
-            const matchingTeam = teams.find((t) => t.key.toLowerCase() === parsedDest.teamKey.toLowerCase());
-            if (matchingTeam) {
-                teamId = matchingTeam.id;
-            }
-            else {
-                return { success: false, error: `Linear team "${parsedDest.teamKey}" not found` };
-            }
-        }
-        if (!teamId) {
-            // Try to auto-select if only one team
-            const teams = await (0, linear_auth_1.getLinearTeams)();
-            if (teams.length === 1) {
-                teamId = teams[0].id;
-            }
-            else if (teams.length > 1) {
-                return { success: false, error: 'Multiple Linear teams. Set archive.destination: linear:TEAM_KEY' };
-            }
-            else {
-                return { success: false, error: 'No Linear teams found' };
-            }
-        }
-        const payload = (0, core_1.formatTaskForLinear)(task, {
-            includeMeta: true,
-            includeSubtasks: true,
-            includeRelatedFiles: true,
-            boardTitle: board.title,
-            fromColumn: columnTitle,
-            stateName: 'Done',
-        });
-        const linearResult = await (0, linear_auth_1.createLinearIssue)({
-            teamId,
-            title: payload.title,
-            description: payload.description,
-            priority: payload.priority,
-            labelNames: payload.labelNames,
-            stateName: 'Done',
-        });
-        if (!linearResult.success) {
-            return { success: false, error: `Linear: ${linearResult.error}` };
-        }
-        // Remove task from board
-        if ((0, v2_detect_1.isV2)(filePath)) {
-            const located = resolveV2TaskPath(filePath, taskId);
-            if (located) {
-                (0, core_1.deleteTaskFile)(located.taskPath);
-            }
-        }
-        else {
-            const deleteResult = (0, core_1.deleteTask)(board, columnId, taskId);
-            if (deleteResult.success) {
-                writeBrainfile(filePath, deleteResult.board);
-            }
-        }
-        return { success: true, message: `Moved to logs via Linear ${linearResult.issueId}` };
-    }
-    return { success: false, error: `Unknown destination: ${destination}` };
-}
-/**
- * Patch/update task fields
- */
-function patchTaskAction(filePath, taskId, patch) {
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const located = resolveV2TaskPath(filePath, taskId);
-        if (!located)
-            return { success: false, error: `Task ${taskId} not found` };
-        const doc = (0, core_1.readTaskFile)(located.taskPath);
-        if (!doc)
-            return { success: false, error: `Failed to read task ${taskId}` };
-        const updatedTask = { ...doc.task };
-        if (patch.title !== undefined)
-            updatedTask.title = patch.title;
-        if (patch.description !== undefined) {
-            if (patch.description === null) {
-                delete updatedTask.description;
-            }
-            else {
-                updatedTask.description = patch.description;
-            }
-        }
-        if (patch.priority !== undefined) {
-            if (patch.priority === null) {
-                delete updatedTask.priority;
-            }
-            else {
-                updatedTask.priority = patch.priority;
-            }
-        }
-        if (patch.tags !== undefined) {
-            if (patch.tags === null) {
-                delete updatedTask.tags;
-            }
-            else {
-                updatedTask.tags = patch.tags;
-            }
-        }
-        if (patch.assignee !== undefined) {
-            if (patch.assignee === null) {
-                delete updatedTask.assignee;
-            }
-            else {
-                updatedTask.assignee = patch.assignee;
-            }
-        }
-        if (patch.dueDate !== undefined) {
-            if (patch.dueDate === null) {
-                delete updatedTask.dueDate;
-            }
-            else {
-                updatedTask.dueDate = patch.dueDate;
-            }
-        }
-        if (patch.relatedFiles !== undefined) {
-            if (patch.relatedFiles === null) {
-                delete updatedTask.relatedFiles;
-            }
-            else {
-                updatedTask.relatedFiles = patch.relatedFiles;
-            }
-        }
-        updatedTask.updatedAt = new Date().toISOString();
-        try {
-            (0, core_1.writeTaskFile)(located.taskPath, updatedTask, doc.body);
-            return { success: true, message: `Updated ${taskId}` };
-        }
-        catch (err) {
-            return { success: false, error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    const { board, error } = readBrainfile(filePath);
-    if (!board)
-        return { success: false, error };
-    const result = (0, core_1.patchTask)(board, taskId, patch);
-    if (!result.success)
-        return { success: false, error: result.error };
-    const writeResult = writeBrainfile(filePath, result.board);
-    if (!writeResult.success)
-        return writeResult;
-    return { success: true, message: `Updated ${taskId}` };
-}
-/**
- * Cycle task priority: none -> low -> medium -> high -> critical -> none
- */
-function cyclePriorityAction(filePath, taskId) {
-    const priorities = [undefined, 'low', 'medium', 'high', 'critical'];
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const located = resolveV2TaskPath(filePath, taskId);
-        if (!located)
-            return { success: false, error: `Task ${taskId} not found` };
-        const doc = (0, core_1.readTaskFile)(located.taskPath);
-        if (!doc)
-            return { success: false, error: `Failed to read task ${taskId}` };
-        const currentIndex = priorities.indexOf(doc.task.priority);
-        const nextIndex = (currentIndex + 1) % priorities.length;
-        const nextPriority = priorities[nextIndex];
-        const updatedTask = {
-            ...doc.task,
-            ...(nextPriority ? { priority: nextPriority } : {}),
-            updatedAt: new Date().toISOString(),
-        };
-        if (!nextPriority) {
-            delete updatedTask.priority;
-        }
-        try {
-            (0, core_1.writeTaskFile)(located.taskPath, updatedTask, doc.body);
-            return { success: true, message: `Priority: ${nextPriority || 'none'}` };
-        }
-        catch (err) {
-            return { success: false, error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    const { board, error } = readBrainfile(filePath);
-    if (!board)
-        return { success: false, error };
-    const taskInfo = (0, core_1.findTaskById)(board, taskId);
-    if (!taskInfo)
-        return { success: false, error: `Task ${taskId} not found` };
-    const currentIndex = priorities.indexOf(taskInfo.task.priority);
-    const nextIndex = (currentIndex + 1) % priorities.length;
-    const nextPriority = priorities[nextIndex];
-    const patch = { priority: nextPriority || null };
-    const result = (0, core_1.patchTask)(board, taskId, patch);
-    if (!result.success)
-        return { success: false, error: result.error };
-    const writeResult = writeBrainfile(filePath, result.board);
-    if (!writeResult.success)
-        return writeResult;
-    return { success: true, message: `Priority: ${nextPriority || 'none'}` };
-}
-/**
- * Toggle a subtask's completion status
- */
-function toggleSubtaskAction(filePath, taskId, subtaskId) {
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const located = resolveV2TaskPath(filePath, taskId);
-        if (!located)
-            return { success: false, error: `Task ${taskId} not found` };
-        const doc = (0, core_1.readTaskFile)(located.taskPath);
-        if (!doc)
-            return { success: false, error: `Failed to read task ${taskId}` };
-        if (!doc.task.subtasks || doc.task.subtasks.length === 0) {
-            return { success: false, error: `Task ${taskId} has no subtasks` };
-        }
-        const updatedSubtasks = doc.task.subtasks.map((subtask) => {
-            if (subtask.id !== subtaskId)
-                return subtask;
-            return { ...subtask, completed: !subtask.completed };
-        });
-        const found = updatedSubtasks.some((subtask) => subtask.id === subtaskId);
-        if (!found)
-            return { success: false, error: `Subtask ${subtaskId} not found` };
-        const updatedTask = {
-            ...doc.task,
-            subtasks: updatedSubtasks,
-            updatedAt: new Date().toISOString(),
-        };
-        try {
-            (0, core_1.writeTaskFile)(located.taskPath, updatedTask, doc.body);
-            return { success: true, message: `Toggled ${subtaskId}` };
-        }
-        catch (err) {
-            return { success: false, error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    const { board, error } = readBrainfile(filePath);
-    if (!board)
-        return { success: false, error };
-    const result = (0, core_1.toggleSubtask)(board, taskId, subtaskId);
-    if (!result.success)
-        return { success: false, error: result.error };
-    const writeResult = writeBrainfile(filePath, result.board);
-    if (!writeResult.success)
-        return writeResult;
-    return { success: true, message: `Toggled ${subtaskId}` };
-}
-/**
- * Add a new task to a column (quick add - title only)
- */
-function addTaskAction(filePath, columnId, taskInput) {
-    const { board, error } = readBoardState(filePath);
-    if (!board)
-        return { success: false, error };
-    const column = (0, core_1.findColumnById)(board, columnId) || (0, core_1.findColumnByName)(board, columnId);
-    if (!column)
-        return { success: false, error: `Column ${columnId} not found` };
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
-        const result = (0, core_1.addTaskFile)(dirs.boardDir, {
-            title: taskInput.title,
-            column: column.id,
-            description: taskInput.description,
-            priority: taskInput.priority,
-            tags: taskInput.tags,
-            assignee: taskInput.assignee,
-            dueDate: taskInput.dueDate,
-            relatedFiles: taskInput.relatedFiles,
-        }, taskInput.description ? `## Description\n${taskInput.description.trim()}\n` : '', dirs.logsDir);
-        if (!result.success)
-            return { success: false, error: result.error };
-        return { success: true, message: `Added ${result.task?.id || 'task'}` };
-    }
-    const result = (0, core_1.addTask)(board, column.id, taskInput);
-    if (!result.success)
-        return { success: false, error: result.error };
-    const writeResult = writeBrainfile(filePath, result.board);
-    if (!writeResult.success)
-        return writeResult;
-    // Get the new task ID
-    const newColumn = result.board.columns.find(c => c.id === column.id);
-    const newTask = newColumn?.tasks[newColumn.tasks.length - 1];
-    return { success: true, message: `Added ${newTask?.id || 'task'}` };
-}
-/**
- * Create a new task using $EDITOR with full template
- */
-function newTaskInEditor(filePath, columnId) {
-    const { board, error } = readBoardState(filePath);
-    if (!board)
-        return { success: false, error };
-    const column = (0, core_1.findColumnById)(board, columnId) || (0, core_1.findColumnByName)(board, columnId);
-    if (!column)
-        return { success: false, error: `Column ${columnId} not found` };
-    // Build template for new task
-    const template = buildNewTaskTemplate();
-    // Write to temp file
-    const tempDir = os.tmpdir();
-    const tempFile = path.join(tempDir, `brainfile-new-task.yaml`);
-    try {
-        fs.writeFileSync(tempFile, template, 'utf-8');
-    }
-    catch (err) {
-        return { success: false, error: `Failed to create temp file: ${err}` };
-    }
-    // Get editor from environment
-    const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
-    // Use spawnSync to block and give full terminal control to editor
-    // 5 minute timeout to prevent indefinite hangs
-    const result = (0, child_process_1.spawnSync)(editor, [tempFile], {
-        stdio: 'inherit',
-        shell: true,
-        timeout: 300000,
-    });
-    // Reset terminal state after editor exits - hide cursor and clear line
-    // This fixes cursor blink artifact when returning to Ink TUI
-    process.stdout.write('\x1b[?25l'); // Hide cursor
-    process.stdout.write('\x1b[2K'); // Clear current line
-    if (result.error) {
-        cleanupTempFile(tempFile);
-        return { success: false, error: `Failed to open editor: ${result.error.message}` };
-    }
-    if (result.signal === 'SIGTERM') {
-        cleanupTempFile(tempFile);
-        return { success: false, error: 'Editor timed out (5 minute limit)' };
-    }
-    if (result.status !== 0) {
-        cleanupTempFile(tempFile);
-        return { success: false, error: `Editor exited with code ${result.status}` };
-    }
-    // Read edited content
-    let editedYaml;
-    try {
-        editedYaml = fs.readFileSync(tempFile, 'utf-8');
-    }
-    catch (err) {
-        cleanupTempFile(tempFile);
-        return { success: false, error: `Failed to read edited file: ${err}` };
-    }
-    cleanupTempFile(tempFile);
-    // Parse the new task
-    const parseResult = parseNewTaskYaml(editedYaml);
-    if (!parseResult.success) {
-        return { success: false, error: parseResult.error };
-    }
-    if (!parseResult.taskInput || !parseResult.taskInput.title) {
-        return { success: false, error: 'Task title is required' };
-    }
-    // Add the task
-    return addTaskAction(filePath, columnId, parseResult.taskInput);
-}
-/**
- * Build template for a new task
- */
-function buildNewTaskTemplate() {
-    return `# New Task
-# Fill in the fields below. Save and close to create the task.
-# Lines starting with # are ignored. Title is required.
-
-title:
-description:
-priority:
-tags:
-assignee:
-dueDate:
-`;
-}
-/**
- * Parse new task YAML into TaskInput
- */
-function parseNewTaskYaml(yaml) {
-    try {
-        const lines = yaml.split('\n').filter(line => !line.startsWith('#') && line.trim());
-        const taskInput = { title: '' };
-        for (const line of lines) {
-            const colonIndex = line.indexOf(':');
-            if (colonIndex === -1)
-                continue;
-            const key = line.substring(0, colonIndex).trim();
-            const value = line.substring(colonIndex + 1).trim();
-            switch (key) {
-                case 'title':
-                    if (value)
-                        taskInput.title = value;
-                    break;
-                case 'description':
-                    if (value)
-                        taskInput.description = value;
-                    break;
-                case 'priority':
-                    const validPriorities = ['low', 'medium', 'high', 'critical'];
-                    if (validPriorities.includes(value)) {
-                        taskInput.priority = value;
-                    }
-                    break;
-                case 'tags':
-                    if (value) {
-                        taskInput.tags = value.split(',').map(t => t.trim()).filter(Boolean);
-                    }
-                    break;
-                case 'assignee':
-                    if (value)
-                        taskInput.assignee = value;
-                    break;
-                case 'dueDate':
-                    if (value)
-                        taskInput.dueDate = value;
-                    break;
-            }
-        }
-        return { success: true, taskInput };
-    }
-    catch (err) {
-        return { success: false, error: `Failed to parse task: ${err}` };
-    }
-}
-/**
- * Edit a task in the user's preferred editor
- * Uses spawnSync to fully block and give terminal control to the editor
- */
-function editTaskInEditor(filePath, taskId) {
-    const { board, error } = readBoardState(filePath);
-    if (!board) {
-        return { success: false, error };
-    }
-    const taskInfo = (0, core_1.findTaskById)(board, taskId);
-    if (!taskInfo) {
-        return { success: false, error: `Task ${taskId} not found` };
-    }
-    const task = taskInfo.task;
-    // Build YAML representation of just this task
-    const taskYaml = buildTaskYaml(task);
-    // Write to temp file
-    const tempDir = os.tmpdir();
-    const tempFile = path.join(tempDir, `brainfile-edit-${taskId}.yaml`);
-    try {
-        fs.writeFileSync(tempFile, taskYaml, 'utf-8');
-    }
-    catch (err) {
-        return { success: false, error: `Failed to create temp file: ${err}` };
-    }
-    // Get editor from environment
-    const editor = process.env.EDITOR || process.env.VISUAL || 'nano';
-    // Use spawnSync to block and give full terminal control to editor
-    // 5 minute timeout to prevent indefinite hangs
-    const result = (0, child_process_1.spawnSync)(editor, [tempFile], {
-        stdio: 'inherit',
-        shell: true,
-        timeout: 300000,
-    });
-    // Reset terminal state after editor exits - hide cursor and clear line
-    // This fixes cursor blink artifact when returning to Ink TUI
-    process.stdout.write('\x1b[?25l'); // Hide cursor
-    process.stdout.write('\x1b[2K'); // Clear current line
-    if (result.error) {
-        cleanupTempFile(tempFile);
-        return { success: false, error: `Failed to open editor: ${result.error.message}` };
-    }
-    if (result.signal === 'SIGTERM') {
-        cleanupTempFile(tempFile);
-        return { success: false, error: 'Editor timed out (5 minute limit)' };
-    }
-    if (result.status !== 0) {
-        cleanupTempFile(tempFile);
-        return { success: false, error: `Editor exited with code ${result.status}` };
-    }
-    // Read edited content
-    let editedYaml;
-    try {
-        editedYaml = fs.readFileSync(tempFile, 'utf-8');
-    }
-    catch (err) {
-        cleanupTempFile(tempFile);
-        return { success: false, error: `Failed to read edited file: ${err}` };
-    }
-    cleanupTempFile(tempFile);
-    // Parse edited YAML and apply as patch
-    const patchResult = parseEditedTaskYaml(editedYaml, task);
-    if (!patchResult.success) {
-        return { success: false, error: patchResult.error };
-    }
-    if (!patchResult.patch || Object.keys(patchResult.patch).length === 0) {
-        return { success: true, message: 'No changes made' };
-    }
-    // Apply the patch
-    return patchTaskAction(filePath, taskId, patchResult.patch);
-}
-/**
- * Build YAML representation of a task for editing
- */
-function buildTaskYaml(task) {
-    const lines = [
-        `# Edit task: ${task.id}`,
-        `# Save and close to apply changes. Delete a field to clear it.`,
-        `# Lines starting with # are ignored.`,
-        ``,
-        `title: ${task.title}`,
-    ];
-    if (task.description) {
-        // Handle multi-line descriptions
-        if (task.description.includes('\n')) {
-            lines.push(`description: |`);
-            task.description.split('\n').forEach(line => {
-                lines.push(`  ${line}`);
-            });
-        }
-        else {
-            lines.push(`description: ${task.description}`);
-        }
-    }
-    else {
-        lines.push(`# description: `);
-    }
-    lines.push(`priority: ${task.priority || ''}`);
-    lines.push(`tags: ${task.tags?.join(', ') || ''}`);
-    lines.push(`assignee: ${task.assignee || ''}`);
-    lines.push(`dueDate: ${task.dueDate || ''}`);
-    if (task.subtasks && task.subtasks.length > 0) {
-        lines.push(`subtasks:`);
-        task.subtasks.forEach(st => {
-            lines.push(`  - [${st.completed ? 'x' : ' '}] ${st.title}`);
-        });
-    }
-    if (task.relatedFiles && task.relatedFiles.length > 0) {
-        lines.push(`relatedFiles: ${task.relatedFiles.join(', ')}`);
-    }
-    return lines.join('\n') + '\n';
-}
-/**
- * Parse edited YAML and return a TaskPatch
- */
-function parseEditedTaskYaml(yaml, originalTask) {
-    const patch = {};
-    try {
-        const lines = yaml.split('\n').filter(line => !line.startsWith('#') && line.trim());
-        for (const line of lines) {
-            const colonIndex = line.indexOf(':');
-            if (colonIndex === -1)
-                continue;
-            const key = line.substring(0, colonIndex).trim();
-            const value = line.substring(colonIndex + 1).trim();
-            switch (key) {
-                case 'title':
-                    if (value && value !== originalTask.title) {
-                        patch.title = value;
-                    }
-                    break;
-                case 'description':
-                    if (value !== (originalTask.description || '')) {
-                        patch.description = value || undefined;
-                    }
-                    break;
-                case 'priority':
-                    const validPriorities = ['low', 'medium', 'high', 'critical', ''];
-                    if (validPriorities.includes(value) && value !== (originalTask.priority || '')) {
-                        patch.priority = value || null;
-                    }
-                    break;
-                case 'tags':
-                    const newTags = value ? value.split(',').map(t => t.trim()).filter(Boolean) : [];
-                    const oldTags = originalTask.tags || [];
-                    if (JSON.stringify(newTags) !== JSON.stringify(oldTags)) {
-                        patch.tags = newTags.length > 0 ? newTags : null;
-                    }
-                    break;
-                case 'assignee':
-                    if (value !== (originalTask.assignee || '')) {
-                        patch.assignee = value || null;
-                    }
-                    break;
-                case 'dueDate':
-                    if (value !== (originalTask.dueDate || '')) {
-                        patch.dueDate = value || null;
-                    }
-                    break;
-                case 'relatedFiles':
-                    const newFiles = value ? value.split(',').map(f => f.trim()).filter(Boolean) : [];
-                    const oldFiles = originalTask.relatedFiles || [];
-                    if (JSON.stringify(newFiles) !== JSON.stringify(oldFiles)) {
-                        patch.relatedFiles = newFiles.length > 0 ? newFiles : null;
-                    }
-                    break;
-            }
-        }
-        return { success: true, patch };
-    }
-    catch (err) {
-        return { success: false, error: `Failed to parse edited YAML: ${err}` };
-    }
-}
-/**
- * Clean up temp file
- */
-function cleanupTempFile(filePath) {
-    try {
-        if (fs.existsSync(filePath)) {
-            fs.unlinkSync(filePath);
-        }
-    }
-    catch {
-        // Ignore cleanup errors
-    }
-}
-/**
- * Copy text to clipboard (cross-platform)
- * Uses spawnSync with input option to pipe text to clipboard command
- */
-function copyToClipboard(text) {
-    try {
-        const platform = process.platform;
-        let command;
-        let args;
-        if (platform === 'darwin') {
-            command = 'pbcopy';
-            args = [];
-        }
-        else if (platform === 'linux') {
-            // Try xclip first, fall back to xsel
-            command = 'xclip';
-            args = ['-selection', 'clipboard'];
-        }
-        else if (platform === 'win32') {
-            command = 'clip';
-            args = [];
-        }
-        else {
-            return { success: false, error: 'Clipboard not supported on this platform' };
-        }
-        const result = (0, child_process_1.spawnSync)(command, args, {
-            input: text,
-            stdio: ['pipe', 'ignore', 'ignore'],
-        });
-        if (result.error) {
-            return { success: false, error: `Clipboard error: ${result.error.message}` };
-        }
-        return { success: true, message: 'Copied to clipboard' };
-    }
-    catch (err) {
-        return { success: false, error: `Failed to copy: ${err}` };
-    }
-}
-/**
- * Add a new rule to a rule category
- */
-function addRuleAction(filePath, ruleType, ruleText) {
-    const { board, error } = readBoardConfigOnly(filePath);
-    if (!board)
-        return { success: false, error };
-    // Initialize rules if not present
-    if (!board.rules) {
-        board.rules = {
-            always: [],
-            never: [],
-            prefer: [],
-            context: [],
-        };
-    }
-    // Ensure the rule type array exists
-    if (!board.rules[ruleType]) {
-        board.rules[ruleType] = [];
-    }
-    // Generate next rule ID
-    const existingIds = board.rules[ruleType].map((r) => r.id);
-    const maxId = existingIds.length > 0 ? Math.max(...existingIds) : 0;
-    const newRuleId = maxId + 1;
-    // Add the rule
-    board.rules[ruleType].push({
-        id: newRuleId,
-        rule: ruleText.trim(),
-    });
-    const writeResult = writeBrainfile(filePath, board);
-    if (!writeResult.success)
-        return writeResult;
-    return { success: true, message: `Added ${ruleType} rule #${newRuleId}` };
-}
-/**
- * Update an existing rule
- */
-function updateRuleAction(filePath, ruleType, ruleId, ruleText) {
-    const { board, error } = readBoardConfigOnly(filePath);
-    if (!board)
-        return { success: false, error };
-    if (!board.rules || !board.rules[ruleType]) {
-        return { success: false, error: `No ${ruleType} rules found` };
-    }
-    const rule = board.rules[ruleType].find((r) => r.id === ruleId);
-    if (!rule) {
-        return { success: false, error: `Rule #${ruleId} not found` };
-    }
-    rule.rule = ruleText.trim();
-    const writeResult = writeBrainfile(filePath, board);
-    if (!writeResult.success)
-        return writeResult;
-    return { success: true, message: `Updated ${ruleType} rule #${ruleId}` };
-}
-/**
- * Delete a rule
- */
-function deleteRuleAction(filePath, ruleType, ruleId) {
-    const { board, error } = readBoardConfigOnly(filePath);
-    if (!board)
-        return { success: false, error };
-    if (!board.rules || !board.rules[ruleType]) {
-        return { success: false, error: `No ${ruleType} rules found` };
-    }
-    const ruleIndex = board.rules[ruleType].findIndex((r) => r.id === ruleId);
-    if (ruleIndex === -1) {
-        return { success: false, error: `Rule #${ruleId} not found` };
-    }
-    board.rules[ruleType].splice(ruleIndex, 1);
-    const writeResult = writeBrainfile(filePath, board);
-    if (!writeResult.success)
-        return writeResult;
-    return { success: true, message: `Deleted ${ruleType} rule #${ruleId}` };
-}
-// =============================================================================
-// ARCHIVE OPERATIONS
-// =============================================================================
-/**
- * Load logs from the logs file
- */
-function loadLogs(filePath) {
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        try {
-            const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
-            const docs = (0, core_1.readTasksDir)(dirs.logsDir);
-            const logs = docs
-                .map((doc) => ({ ...doc.task }))
-                .sort((a, b) => {
-                const aTime = a.completedAt ? Date.parse(a.completedAt) : 0;
-                const bTime = b.completedAt ? Date.parse(b.completedAt) : 0;
-                return bTime - aTime;
-            });
-            return { logs };
-        }
-        catch (err) {
-            return { logs: [], error: err instanceof Error ? err.message : String(err) };
-        }
-    }
-    const archivePath = getArchivePath(filePath);
-    if (!fs.existsSync(archivePath)) {
-        return { logs: [] };
-    }
-    try {
-        const archiveContent = fs.readFileSync(archivePath, 'utf-8');
-        const parseResult = core_1.Brainfile.parseWithErrors(archiveContent);
-        if (parseResult.board && parseResult.board.archive) {
-            return { logs: parseResult.board.archive };
-        }
-        return { logs: [] };
-    }
-    catch (err) {
-        return { logs: [], error: err instanceof Error ? err.message : String(err) };
-    }
-}
-/**
- * Restore a task from logs to a column
- */
-function restoreTaskAction(filePath, taskId, toColumnId) {
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
-        const { board, error } = readBoardState(filePath);
-        if (!board)
-            return { success: false, error };
-        const column = (0, core_1.findColumnById)(board, toColumnId) || (0, core_1.findColumnByName)(board, toColumnId);
-        if (!column) {
-            return { success: false, error: `Column ${toColumnId} not found` };
-        }
-        if ((0, core_1.findTask)(dirs.boardDir, taskId)) {
-            return { success: false, error: `Task ${taskId} already exists in board` };
-        }
-        const logDoc = (0, core_1.findTask)(dirs.logsDir, taskId);
-        if (!logDoc || !logDoc.filePath) {
-            return { success: false, error: `Task ${taskId} not found in logs` };
-        }
-        const restoredTask = {
-            ...logDoc.task,
-            column: column.id,
-            updatedAt: new Date().toISOString(),
-        };
-        delete restoredTask.completedAt;
-        const targetPath = path.join(dirs.boardDir, `${taskId}.md`);
-        try {
-            (0, core_1.writeTaskFile)(targetPath, restoredTask, logDoc.body);
-            fs.unlinkSync(logDoc.filePath);
-            return { success: true, message: `Restored ${taskId} to ${column.title}` };
-        }
-        catch (err) {
-            return { success: false, error: `Failed to restore task: ${err instanceof Error ? err.message : String(err)}` };
-        }
-    }
-    const archivePath = getArchivePath(filePath);
-    // Read archive file
-    if (!fs.existsSync(archivePath)) {
-        return { success: false, error: 'Logs file not found' };
-    }
-    let archiveBoard;
-    try {
-        const archiveContent = fs.readFileSync(archivePath, 'utf-8');
-        const parseResult = core_1.Brainfile.parseWithErrors(archiveContent);
-        if (!parseResult.board) {
-            return { success: false, error: 'Failed to parse logs file' };
-        }
-        archiveBoard = parseResult.board;
-    }
-    catch (err) {
-        return { success: false, error: `Failed to read logs: ${err instanceof Error ? err.message : String(err)}` };
-    }
-    // Find task in archive
-    if (!archiveBoard.archive || archiveBoard.archive.length === 0) {
-        return { success: false, error: 'Logs are empty' };
-    }
-    const taskIndex = archiveBoard.archive.findIndex(t => t.id === taskId);
-    if (taskIndex === -1) {
-        return { success: false, error: `Task ${taskId} not found in logs` };
-    }
-    const task = archiveBoard.archive[taskIndex];
-    // Read main board
-    const { board: mainBoard, error: mainBoardError } = readBrainfile(filePath);
-    if (!mainBoard)
-        return { success: false, error: mainBoardError };
-    // Find target column
-    const column = (0, core_1.findColumnById)(mainBoard, toColumnId) || (0, core_1.findColumnByName)(mainBoard, toColumnId);
-    if (!column) {
-        return { success: false, error: `Column ${toColumnId} not found` };
-    }
-    // Add task to column (at beginning)
-    column.tasks.unshift(task);
-    // Remove from archive
-    archiveBoard.archive.splice(taskIndex, 1);
-    // Save both files
-    const writeResult = writeBrainfile(filePath, mainBoard);
-    if (!writeResult.success)
-        return writeResult;
-    try {
-        const archiveContent = core_1.Brainfile.serialize(archiveBoard);
-        fs.writeFileSync(archivePath, archiveContent, 'utf-8');
-    }
-    catch (err) {
-        return { success: false, error: `Task restored but failed to update logs: ${err}` };
-    }
-    return { success: true, message: `Restored ${taskId} to ${column.title}` };
-}
-/**
- * Permanently delete a task from logs
- */
-function deleteArchivedTaskAction(filePath, taskId) {
-    if ((0, v2_detect_1.isV2)(filePath)) {
-        const dirs = (0, v2_detect_1.getV2Dirs)(filePath);
-        const logDoc = (0, core_1.findTask)(dirs.logsDir, taskId);
-        if (!logDoc || !logDoc.filePath) {
-            return { success: false, error: `Task ${taskId} not found in logs` };
-        }
-        const result = (0, core_1.deleteTaskFile)(logDoc.filePath);
-        if (!result.success) {
-            return { success: false, error: result.error || `Failed to delete ${taskId}` };
-        }
-        return { success: true, message: `Permanently deleted ${taskId}` };
-    }
-    const archivePath = getArchivePath(filePath);
-    // Read archive file
-    if (!fs.existsSync(archivePath)) {
-        return { success: false, error: 'Logs file not found' };
-    }
-    let archiveBoard;
-    try {
-        const archiveContent = fs.readFileSync(archivePath, 'utf-8');
-        const parseResult = core_1.Brainfile.parseWithErrors(archiveContent);
-        if (!parseResult.board) {
-            return { success: false, error: 'Failed to parse logs file' };
-        }
-        archiveBoard = parseResult.board;
-    }
-    catch (err) {
-        return { success: false, error: `Failed to read logs: ${err instanceof Error ? err.message : String(err)}` };
-    }
-    // Find and remove task from archive
-    if (!archiveBoard.archive || archiveBoard.archive.length === 0) {
-        return { success: false, error: 'Logs are empty' };
-    }
-    const taskIndex = archiveBoard.archive.findIndex(t => t.id === taskId);
-    if (taskIndex === -1) {
-        return { success: false, error: `Task ${taskId} not found in logs` };
-    }
-    archiveBoard.archive.splice(taskIndex, 1);
-    // Save archive file
-    try {
-        const archiveContent = core_1.Brainfile.serialize(archiveBoard);
-        fs.writeFileSync(archivePath, archiveContent, 'utf-8');
-    }
-    catch (err) {
-        return { success: false, error: `Failed to update logs: ${err}` };
-    }
-    return { success: true, message: `Permanently deleted ${taskId}` };
-}
-//# sourceMappingURL=actions.js.map