@plusplusoneplusplus/coc 1.0.0 → 1.0.2

package/node_modules/@plusplusoneplusplus/forge/dist/tasks/task-operations.js

@@ -1,658 +0,0 @@
-"use strict";
-/**
- * Task CRUD operations and composite helpers — Pure Node.js functions for task file management.
- * No VS Code dependencies. Every function takes explicit path arguments.
- */
-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.sanitizeFileName = exports.parseFileName = void 0;
-exports.createTask = createTask;
-exports.createFeature = createFeature;
-exports.createSubfolder = createSubfolder;
-exports.renameTask = renameTask;
-exports.renameFolder = renameFolder;
-exports.renameDocumentGroup = renameDocumentGroup;
-exports.renameDocument = renameDocument;
-exports.deleteTask = deleteTask;
-exports.deleteFolder = deleteFolder;
-exports.archiveTask = archiveTask;
-exports.unarchiveTask = unarchiveTask;
-exports.archiveDocument = archiveDocument;
-exports.unarchiveDocument = unarchiveDocument;
-exports.archiveDocumentGroup = archiveDocumentGroup;
-exports.unarchiveDocumentGroup = unarchiveDocumentGroup;
-exports.moveTask = moveTask;
-exports.moveFolder = moveFolder;
-exports.moveTaskGroup = moveTaskGroup;
-exports.importTask = importTask;
-exports.moveExternalTask = moveExternalTask;
-exports.taskExistsInFolder = taskExistsInFolder;
-exports.taskExists = taskExists;
-exports.resolveTaskPaths = resolveTaskPaths;
-exports.ensureTaskFolders = ensureTaskFolders;
-exports.getAllTasks = getAllTasks;
-exports.getAllDocuments = getAllDocuments;
-exports.getAllDocumentGroups = getAllDocumentGroups;
-exports.getFullTaskHierarchy = getFullTaskHierarchy;
-exports.getFeatureFolders = getFeatureFolders;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const utils_1 = require("../utils");
-const path_utils_1 = require("../utils/path-utils");
-const task_parser_1 = require("./task-parser");
-const task_scanner_1 = require("./task-scanner");
-const related_items_loader_1 = require("./related-items-loader");
-// Re-export parseFileName and sanitizeFileName for convenience
-var task_parser_2 = require("./task-parser");
-Object.defineProperty(exports, "parseFileName", { enumerable: true, get: function () { return task_parser_2.parseFileName; } });
-Object.defineProperty(exports, "sanitizeFileName", { enumerable: true, get: function () { return task_parser_2.sanitizeFileName; } });
-// ============================================================================
-// Create operations
-// ============================================================================
-/**
- * Create a new task file in the tasks folder.
- * @param tasksFolder - Absolute path to the tasks folder
- * @param name - Display name for the task
- * @returns The path to the created file
- */
-async function createTask(tasksFolder, name) {
-    const sanitized = (0, task_parser_1.sanitizeFileName)(name);
-    const filePath = path.join(tasksFolder, `${sanitized}.md`);
-    if ((0, utils_1.safeExists)(filePath)) {
-        throw new Error(`Task "${name}" already exists`);
-    }
-    const content = `# ${name}\n\n`;
-    (0, utils_1.safeWriteFile)(filePath, content);
-    return filePath;
-}
-/**
- * Create a new feature folder with a placeholder file.
- * @param tasksFolder - Absolute path to the tasks folder
- * @param name - Display name for the feature
- * @returns The path to the created folder
- */
-async function createFeature(tasksFolder, name) {
-    const sanitized = (0, task_parser_1.sanitizeFileName)(name);
-    const folderPath = path.join(tasksFolder, sanitized);
-    if ((0, utils_1.safeExists)(folderPath)) {
-        throw new Error(`Feature "${name}" already exists`);
-    }
-    (0, utils_1.ensureDirectoryExists)(folderPath);
-    const placeholderFilePath = path.join(folderPath, 'placeholder.md');
-    (0, utils_1.safeWriteFile)(placeholderFilePath, '');
-    return folderPath;
-}
-/**
- * Create a new subfolder inside an existing folder.
- * @param parentFolderPath - Absolute path to the parent folder
- * @param name - Name of the subfolder to create
- * @returns The path to the created subfolder
- */
-async function createSubfolder(parentFolderPath, name) {
-    if (!(0, utils_1.safeExists)(parentFolderPath)) {
-        throw new Error(`Parent folder not found: ${parentFolderPath}`);
-    }
-    const sanitized = (0, task_parser_1.sanitizeFileName)(name);
-    const subfolderPath = path.join(parentFolderPath, sanitized);
-    if ((0, utils_1.safeExists)(subfolderPath)) {
-        throw new Error(`Subfolder "${name}" already exists`);
-    }
-    (0, utils_1.ensureDirectoryExists)(subfolderPath);
-    const placeholderFilePath = path.join(subfolderPath, 'placeholder.md');
-    (0, utils_1.safeWriteFile)(placeholderFilePath, '');
-    return subfolderPath;
-}
-// ============================================================================
-// Rename operations
-// ============================================================================
-/**
- * Rename a task file.
- * @param oldPath - Absolute path to the existing task file
- * @param newName - New display name for the task
- * @returns The new file path
- */
-async function renameTask(oldPath, newName) {
-    if (!(0, utils_1.safeExists)(oldPath)) {
-        throw new Error(`Task file not found: ${oldPath}`);
-    }
-    const sanitized = (0, task_parser_1.sanitizeFileName)(newName);
-    const directory = path.dirname(oldPath);
-    const newPath = path.join(directory, `${sanitized}.md`);
-    if (oldPath !== newPath && (0, utils_1.safeExists)(newPath)) {
-        throw new Error(`Task "${newName}" already exists`);
-    }
-    (0, utils_1.safeRename)(oldPath, newPath);
-    return newPath;
-}
-/**
- * Rename a folder.
- * @param folderPath - Absolute path to the folder
- * @param newName - New folder name
- * @returns The new folder path
- */
-async function renameFolder(folderPath, newName) {
-    if (!(0, utils_1.safeExists)(folderPath)) {
-        throw new Error(`Folder not found: ${folderPath}`);
-    }
-    const statsResult = (0, utils_1.safeStats)(folderPath);
-    if (!statsResult.success || !statsResult.data?.isDirectory()) {
-        throw new Error(`Path is not a directory: ${folderPath}`);
-    }
-    const sanitized = (0, task_parser_1.sanitizeFileName)(newName);
-    const parentDir = path.dirname(folderPath);
-    const newPath = path.join(parentDir, sanitized);
-    if (folderPath !== newPath && (0, utils_1.safeExists)(newPath)) {
-        throw new Error(`Folder "${newName}" already exists`);
-    }
-    (0, utils_1.safeRename)(folderPath, newPath);
-    return newPath;
-}
-/**
- * Rename a document group (all documents sharing the same base name).
- * @param folderPath - Absolute path to the folder containing the documents
- * @param oldBaseName - Current base name of the document group
- * @param newBaseName - New base name for the documents
- * @returns Array of new file paths
- */
-async function renameDocumentGroup(folderPath, oldBaseName, newBaseName) {
-    if (!(0, utils_1.safeExists)(folderPath)) {
-        throw new Error(`Folder not found: ${folderPath}`);
-    }
-    const sanitizedNewBaseName = (0, task_parser_1.sanitizeFileName)(newBaseName);
-    const renamedPaths = [];
-    const failedRenames = [];
-    const readResult = (0, utils_1.safeReadDir)(folderPath);
-    if (!readResult.success || !readResult.data) {
-        throw new Error(`Failed to read folder: ${folderPath}`);
-    }
-    const filesToRename = [];
-    for (const fileName of readResult.data) {
-        if (!fileName.endsWith('.md')) {
-            continue;
-        }
-        const { baseName, docType } = (0, task_parser_1.parseFileName)(fileName);
-        if (baseName !== oldBaseName) {
-            continue;
-        }
-        const oldFilePath = path.join(folderPath, fileName);
-        const newFileName = docType
-            ? `${sanitizedNewBaseName}.${docType}.md`
-            : `${sanitizedNewBaseName}.md`;
-        const newFilePath = path.join(folderPath, newFileName);
-        if (oldFilePath !== newFilePath && (0, utils_1.safeExists)(newFilePath)) {
-            throw new Error(`File "${newFileName}" already exists`);
-        }
-        filesToRename.push({ oldPath: oldFilePath, newPath: newFilePath });
-    }
-    if (filesToRename.length === 0) {
-        throw new Error(`No documents found with base name "${oldBaseName}"`);
-    }
-    for (const { oldPath, newPath } of filesToRename) {
-        try {
-            (0, utils_1.safeRename)(oldPath, newPath);
-            renamedPaths.push(newPath);
-        }
-        catch (error) {
-            failedRenames.push(path.basename(oldPath));
-        }
-    }
-    if (failedRenames.length > 0) {
-        throw new Error(`Failed to rename: ${failedRenames.join(', ')}`);
-    }
-    return renamedPaths;
-}
-/**
- * Rename a single document (preserving doc type suffix).
- * @param oldPath - Absolute path to the document
- * @param newBaseName - New base name for the document
- * @returns The new file path
- */
-async function renameDocument(oldPath, newBaseName) {
-    if (!(0, utils_1.safeExists)(oldPath)) {
-        throw new Error(`Document not found: ${oldPath}`);
-    }
-    const fileName = path.basename(oldPath);
-    const { docType } = (0, task_parser_1.parseFileName)(fileName);
-    const sanitizedNewBaseName = (0, task_parser_1.sanitizeFileName)(newBaseName);
-    const directory = path.dirname(oldPath);
-    const newFileName = docType
-        ? `${sanitizedNewBaseName}.${docType}.md`
-        : `${sanitizedNewBaseName}.md`;
-    const newPath = path.join(directory, newFileName);
-    if (oldPath !== newPath && (0, utils_1.safeExists)(newPath)) {
-        throw new Error(`Document "${newFileName}" already exists`);
-    }
-    (0, utils_1.safeRename)(oldPath, newPath);
-    return newPath;
-}
-// ============================================================================
-// Delete operations
-// ============================================================================
-/**
- * Delete a task file.
- * @param filePath - Absolute path to the task file
- */
-async function deleteTask(filePath) {
-    if (!(0, utils_1.safeExists)(filePath)) {
-        throw new Error(`Task file not found: ${filePath}`);
-    }
-    await fs.promises.unlink(filePath);
-}
-/**
- * Delete a folder and all its contents recursively.
- * @param folderPath - Absolute path to the folder to delete
- */
-async function deleteFolder(folderPath) {
-    if (!(0, utils_1.safeExists)(folderPath)) {
-        throw new Error(`Folder not found: ${folderPath}`);
-    }
-    const statsResult = (0, utils_1.safeStats)(folderPath);
-    if (!statsResult.success || !statsResult.data?.isDirectory()) {
-        throw new Error(`Path is not a directory: ${folderPath}`);
-    }
-    await fs.promises.rm(folderPath, { recursive: true, force: true });
-}
-// ============================================================================
-// Archive / unarchive operations
-// ============================================================================
-/**
- * Archive a task (move to archive folder).
- * @param filePath - Absolute path to the task file
- * @param tasksFolder - Absolute path to the tasks folder
- * @param archiveFolder - Absolute path to the archive folder
- * @param preserveStructure - If true, preserves the relative folder structure under archive
- * @returns The new file path
- */
-async function archiveTask(filePath, tasksFolder, archiveFolder, preserveStructure = false) {
-    if (!(0, utils_1.safeExists)(filePath)) {
-        throw new Error(`Task file not found: ${filePath}`);
-    }
-    const fileName = path.basename(filePath);
-    let targetFolder = archiveFolder;
-    if (preserveStructure) {
-        const fileDir = path.dirname(filePath);
-        const normalizedTasksFolder = (0, path_utils_1.toForwardSlashes)(tasksFolder);
-        const normalizedFileDir = (0, path_utils_1.toForwardSlashes)(fileDir);
-        if (normalizedFileDir.startsWith(normalizedTasksFolder)) {
-            const relativePath = normalizedFileDir.substring(normalizedTasksFolder.length).replace(/^[/\\]/, '');
-            if (relativePath && relativePath !== 'archive' && !relativePath.startsWith('archive/') && !relativePath.startsWith('archive\\')) {
-                targetFolder = path.join(archiveFolder, relativePath);
-                (0, utils_1.ensureDirectoryExists)(targetFolder);
-            }
-        }
-    }
-    const newPath = path.join(targetFolder, fileName);
-    let finalPath = newPath;
-    if ((0, utils_1.safeExists)(newPath)) {
-        const baseName = path.basename(fileName, '.md');
-        const timestamp = Date.now();
-        finalPath = path.join(targetFolder, `${baseName}-${timestamp}.md`);
-    }
-    (0, utils_1.safeRename)(filePath, finalPath);
-    return finalPath;
-}
-/**
- * Unarchive a task (move back to tasks root).
- * @param filePath - Absolute path to the archived task file
- * @param tasksFolder - Absolute path to the tasks folder
- * @returns The new file path
- */
-async function unarchiveTask(filePath, tasksFolder) {
-    if (!(0, utils_1.safeExists)(filePath)) {
-        throw new Error(`Task file not found: ${filePath}`);
-    }
-    const fileName = path.basename(filePath);
-    const newPath = path.join(tasksFolder, fileName);
-    let finalPath = newPath;
-    if ((0, utils_1.safeExists)(newPath)) {
-        const baseName = path.basename(fileName, '.md');
-        const timestamp = Date.now();
-        finalPath = path.join(tasksFolder, `${baseName}-${timestamp}.md`);
-    }
-    (0, utils_1.safeRename)(filePath, finalPath);
-    return finalPath;
-}
-/**
- * Archive a document (delegates to archiveTask).
- */
-async function archiveDocument(filePath, tasksFolder, archiveFolder, preserveStructure = false) {
-    return archiveTask(filePath, tasksFolder, archiveFolder, preserveStructure);
-}
-/**
- * Unarchive a document (delegates to unarchiveTask).
- */
-async function unarchiveDocument(filePath, tasksFolder) {
-    return unarchiveTask(filePath, tasksFolder);
-}
-/**
- * Archive a document group (move all documents to archive folder).
- * @param filePaths - Array of file paths in the group
- * @param tasksFolder - Absolute path to the tasks folder
- * @param archiveFolder - Absolute path to the archive folder
- * @param preserveStructure - If true, preserves the relative folder structure under archive
- * @returns Array of new file paths
- */
-async function archiveDocumentGroup(filePaths, tasksFolder, archiveFolder, preserveStructure = false) {
-    const newPaths = [];
-    for (const filePath of filePaths) {
-        const newPath = await archiveTask(filePath, tasksFolder, archiveFolder, preserveStructure);
-        newPaths.push(newPath);
-    }
-    return newPaths;
-}
-/**
- * Unarchive a document group (move all documents back to tasks root).
- * @param filePaths - Array of file paths in the group
- * @param tasksFolder - Absolute path to the tasks folder
- * @returns Array of new file paths
- */
-async function unarchiveDocumentGroup(filePaths, tasksFolder) {
-    const newPaths = [];
-    for (const filePath of filePaths) {
-        const newPath = await unarchiveTask(filePath, tasksFolder);
-        newPaths.push(newPath);
-    }
-    return newPaths;
-}
-// ============================================================================
-// Move / import operations
-// ============================================================================
-/**
- * Move a task file to a different folder.
- * @param sourcePath - Absolute path to the source file
- * @param targetFolder - Absolute path to the target folder
- * @returns The new file path
- */
-async function moveTask(sourcePath, targetFolder) {
-    if (!(0, utils_1.safeExists)(sourcePath)) {
-        throw new Error(`Task file not found: ${sourcePath}`);
-    }
-    (0, utils_1.ensureDirectoryExists)(targetFolder);
-    const fileName = path.basename(sourcePath);
-    let newPath = path.join(targetFolder, fileName);
-    if (sourcePath !== newPath && (0, utils_1.safeExists)(newPath)) {
-        const baseName = path.basename(fileName, '.md');
-        let counter = 1;
-        while ((0, utils_1.safeExists)(newPath)) {
-            newPath = path.join(targetFolder, `${baseName}-${counter}.md`);
-            counter++;
-        }
-    }
-    if (sourcePath === newPath) {
-        return sourcePath;
-    }
-    (0, utils_1.safeRename)(sourcePath, newPath);
-    return newPath;
-}
-/**
- * Move an entire folder (and all its contents) into a target folder.
- * Prevents circular moves (moving a folder into its own subtree).
- * @param sourceFolderPath - Absolute path to the folder to move
- * @param targetParentFolder - Absolute path to the destination parent folder
- * @returns The new folder path
- */
-async function moveFolder(sourceFolderPath, targetParentFolder) {
-    if (!(0, utils_1.safeExists)(sourceFolderPath)) {
-        throw new Error(`Folder not found: ${sourceFolderPath}`);
-    }
-    const statsResult = (0, utils_1.safeStats)(sourceFolderPath);
-    if (!statsResult.success || !statsResult.data?.isDirectory()) {
-        throw new Error(`Path is not a directory: ${sourceFolderPath}`);
-    }
-    if (!(0, utils_1.safeExists)(targetParentFolder)) {
-        throw new Error(`Target folder not found: ${targetParentFolder}`);
-    }
-    const targetStats = (0, utils_1.safeStats)(targetParentFolder);
-    if (!targetStats.success || !targetStats.data?.isDirectory()) {
-        throw new Error(`Target path is not a directory: ${targetParentFolder}`);
-    }
-    // Prevent circular move
-    const normalizedSource = sourceFolderPath.replace(/\\/g, '/').toLowerCase();
-    const normalizedTarget = targetParentFolder.replace(/\\/g, '/').toLowerCase();
-    if (normalizedTarget.startsWith(normalizedSource + '/') || normalizedTarget === normalizedSource) {
-        throw new Error('Cannot move a folder into itself or its own subtree');
-    }
-    const folderName = path.basename(sourceFolderPath);
-    let newPath = path.join(targetParentFolder, folderName);
-    if (sourceFolderPath !== newPath && (0, utils_1.safeExists)(newPath)) {
-        let counter = 1;
-        while ((0, utils_1.safeExists)(newPath)) {
-            newPath = path.join(targetParentFolder, `${folderName}-${counter}`);
-            counter++;
-        }
-    }
-    if (sourceFolderPath === newPath) {
-        return sourceFolderPath;
-    }
-    (0, utils_1.safeRename)(sourceFolderPath, newPath);
-    return newPath;
-}
-/**
- * Move multiple task files to a different folder (for document groups).
- * @param sourcePaths - Array of absolute paths to source files
- * @param targetFolder - Absolute path to the target folder
- * @returns Array of new file paths
- */
-async function moveTaskGroup(sourcePaths, targetFolder) {
-    const newPaths = [];
-    for (const sourcePath of sourcePaths) {
-        const newPath = await moveTask(sourcePath, targetFolder);
-        newPaths.push(newPath);
-    }
-    return newPaths;
-}
-/**
- * Import an external markdown file into the tasks folder (copy semantics).
- * @param sourcePath - Path to the source file
- * @param tasksFolder - Absolute path to the tasks folder
- * @param newName - Optional new name for the task (without .md extension)
- * @returns The path to the imported file
- */
-async function importTask(sourcePath, tasksFolder, newName) {
-    const sourceFileName = path.basename(sourcePath);
-    const targetName = newName
-        ? (0, task_parser_1.sanitizeFileName)(newName)
-        : path.basename(sourceFileName, '.md');
-    const targetPath = path.join(tasksFolder, `${targetName}.md`);
-    if ((0, utils_1.safeExists)(targetPath)) {
-        throw new Error(`Task "${targetName}" already exists`);
-    }
-    // Copy file content (not move, to preserve original)
-    const content = fs.readFileSync(sourcePath, 'utf-8');
-    (0, utils_1.safeWriteFile)(targetPath, content);
-    return targetPath;
-}
-/**
- * Move an external markdown file into the tasks folder (move semantics - source is deleted).
- * @param sourcePath - Path to the source file
- * @param tasksFolder - Absolute path to the tasks folder
- * @param targetFolder - Absolute path to the target folder (defaults to tasksFolder)
- * @param newName - Optional new name for the task (without .md extension)
- * @returns The path to the moved file
- */
-async function moveExternalTask(sourcePath, tasksFolder, targetFolder, newName) {
-    if (!(0, utils_1.safeExists)(sourcePath)) {
-        throw new Error(`Source file not found: ${sourcePath}`);
-    }
-    if (!sourcePath.toLowerCase().endsWith('.md')) {
-        throw new Error('Only markdown (.md) files can be moved to tasks');
-    }
-    const resolvedTargetFolder = targetFolder || tasksFolder;
-    (0, utils_1.ensureDirectoryExists)(resolvedTargetFolder);
-    const sourceFileName = path.basename(sourcePath);
-    const targetName = newName
-        ? (0, task_parser_1.sanitizeFileName)(newName)
-        : path.basename(sourceFileName, '.md');
-    const targetPath = path.join(resolvedTargetFolder, `${targetName}.md`);
-    if ((0, utils_1.safeExists)(targetPath)) {
-        throw new Error(`Task "${targetName}" already exists`);
-    }
-    (0, utils_1.safeRename)(sourcePath, targetPath);
-    return targetPath;
-}
-// ============================================================================
-// Helper / query functions
-// ============================================================================
-/**
- * Check if a task with the given name exists in a specific folder.
- * @param name - Task name (without .md extension)
- * @param tasksFolder - Absolute path to the tasks folder
- * @param folder - Optional specific folder path (defaults to tasksFolder)
- */
-function taskExistsInFolder(name, tasksFolder, folder) {
-    const sanitized = (0, task_parser_1.sanitizeFileName)(name);
-    const targetFolder = folder || tasksFolder;
-    const filePath = path.join(targetFolder, `${sanitized}.md`);
-    return (0, utils_1.safeExists)(filePath);
-}
-/**
- * Check if a task with the given name exists in the tasks folder.
- * @param name - Task name (without .md extension)
- * @param tasksFolder - Absolute path to the tasks folder
- */
-function taskExists(name, tasksFolder) {
-    const sanitized = (0, task_parser_1.sanitizeFileName)(name);
-    const filePath = path.join(tasksFolder, `${sanitized}.md`);
-    return (0, utils_1.safeExists)(filePath);
-}
-// ============================================================================
-// Path resolution helpers
-// ============================================================================
-/**
- * Resolve the absolute tasks-folder and archive-folder paths from workspace root and settings.
- */
-function resolveTaskPaths(workspaceRoot, settings) {
-    const folderPath = settings.folderPath || '.vscode/tasks';
-    const tasksFolder = path.isAbsolute(folderPath)
-        ? folderPath
-        : path.join(workspaceRoot, folderPath);
-    return {
-        tasksFolder,
-        archiveFolder: path.join(tasksFolder, 'archive'),
-    };
-}
-/**
- * Ensure both the tasks folder and archive sub-folder exist on disk.
- */
-function ensureTaskFolders(tasksFolder) {
-    (0, utils_1.ensureDirectoryExists)(tasksFolder);
-    (0, utils_1.ensureDirectoryExists)(path.join(tasksFolder, 'archive'));
-}
-// ============================================================================
-// Composite scanning helpers
-// ============================================================================
-/**
- * Scan and return all tasks, optionally including archived tasks.
- */
-async function getAllTasks(tasksFolder, showArchived = false) {
-    const tasks = (0, task_scanner_1.scanTasksRecursively)(tasksFolder, '', false);
-    if (showArchived) {
-        const archiveFolder = path.join(tasksFolder, 'archive');
-        tasks.push(...(0, task_scanner_1.scanTasksRecursively)(archiveFolder, '', true));
-    }
-    return tasks;
-}
-/**
- * Scan and return all task documents, optionally including archived documents.
- */
-async function getAllDocuments(tasksFolder, showArchived = false) {
-    const documents = (0, task_scanner_1.scanDocumentsRecursively)(tasksFolder, '', false);
-    if (showArchived) {
-        const archiveFolder = path.join(tasksFolder, 'archive');
-        documents.push(...(0, task_scanner_1.scanDocumentsRecursively)(archiveFolder, '', true));
-    }
-    return documents;
-}
-/**
- * Scan documents and group them by base name.
- */
-async function getAllDocumentGroups(tasksFolder, showArchived = false) {
-    const documents = await getAllDocuments(tasksFolder, showArchived);
-    return (0, task_scanner_1.groupTaskDocuments)(documents);
-}
-/**
- * Build the full task folder hierarchy, optionally loading related items.
- */
-async function getFullTaskHierarchy(tasksFolder, options) {
-    const showArchived = options?.showArchived ?? false;
-    const documents = await getAllDocuments(tasksFolder, showArchived);
-    const archiveFolder = path.join(tasksFolder, 'archive');
-    const { root, folderMap } = (0, task_scanner_1.buildTaskFolderHierarchy)(tasksFolder, documents, showArchived, showArchived ? archiveFolder : undefined);
-    if (options?.discovery?.enabled && options?.discovery?.showRelatedInTree) {
-        for (const [, folder] of folderMap) {
-            if (!folder.relativePath)
-                continue;
-            const relatedItems = await (0, related_items_loader_1.loadRelatedItems)(folder.folderPath);
-            if (relatedItems) {
-                folder.relatedItems = relatedItems;
-            }
-        }
-    }
-    return root;
-}
-/**
- * Recursively collect feature sub-folders under a tasks folder, excluding `archive/`.
- */
-async function getFeatureFolders(tasksFolder) {
-    const folders = [];
-    await collectFeatureFoldersRecursively(tasksFolder, '', folders);
-    return folders;
-}
-async function collectFeatureFoldersRecursively(dirPath, relativePath, folders) {
-    const archiveFolderName = 'archive';
-    const readResult = (0, utils_1.safeReadDir)(dirPath);
-    if (!readResult.success || !readResult.data) {
-        return;
-    }
-    for (const item of readResult.data) {
-        if (item === archiveFolderName) {
-            continue;
-        }
-        const itemPath = path.join(dirPath, item);
-        const statsResult = (0, utils_1.safeStats)(itemPath);
-        if (!statsResult.success || !statsResult.data || !statsResult.data.isDirectory()) {
-            continue;
-        }
-        const itemRelativePath = (0, path_utils_1.toForwardSlashes)(relativePath ? path.join(relativePath, item) : item);
-        const displayName = relativePath ? `${relativePath}/${item}` : item;
-        folders.push({
-            path: itemPath,
-            displayName,
-            relativePath: itemRelativePath,
-        });
-        await collectFeatureFoldersRecursively(itemPath, itemRelativePath, folders);
-    }
-}
-//# sourceMappingURL=task-operations.js.map