@plusplusoneplusplus/coc 1.0.0

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

@@ -0,0 +1,658 @@
+"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