task-o-matic 0.0.1

package/dist/lib/storage.js

@@ -0,0 +1,768 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LocalStorage = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = require("./config");
+class LocalStorage {
+    taskOMatic = null;
+    tasksFile = null;
+    initialized = false;
+    constructor() {
+        // Pure constructor - NO side effects
+    }
+    sanitizeForFilename(name) {
+        // console.log('=== SANITIZE DEBUG ===');
+        // console.log('name type:', typeof name);
+        // console.log('name value:', name);
+        // console.log("name length:", name.length);
+        // console.log("====================");
+        // Replace slashes with a safe character and remove other invalid characters
+        return name.replace(/[\/\?%*:|"<>]/g, "-");
+    }
+    validateTaskId(taskId) {
+        if (!taskId || typeof taskId !== "string" || taskId.trim() === "") {
+            throw new Error("Task ID must be a non-empty string");
+        }
+    }
+    validateTaskRequest(task) {
+        if (!task || typeof task !== "object") {
+            throw new Error("Task request must be a valid object");
+        }
+        if (!task.title ||
+            typeof task.title !== "string" ||
+            task.title.trim() === "") {
+            throw new Error("Task title is required and must be a non-empty string");
+        }
+        if (task.parentId && typeof task.parentId !== "string") {
+            throw new Error("Parent ID must be a string if provided");
+        }
+        if (task.estimatedEffort &&
+            !["small", "medium", "large"].includes(task.estimatedEffort)) {
+            throw new Error("Estimated effort must be 'small', 'medium', or 'large'");
+        }
+        if (task.dependencies && !Array.isArray(task.dependencies)) {
+            throw new Error("Dependencies must be an array if provided");
+        }
+        if (task.tags && !Array.isArray(task.tags)) {
+            throw new Error("Tags must be an array if provided");
+        }
+    }
+    ensureInitialized() {
+        if (this.initialized) {
+            return;
+        }
+        this.taskOMatic = config_1.configManager.getTaskOMaticDir();
+        this.tasksFile = (0, path_1.join)(this.taskOMatic, "tasks.json");
+        this.initialized = true;
+    }
+    ensureDirectories() {
+        this.ensureInitialized();
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const dirs = [
+            "prd",
+            "logs",
+            "tasks",
+            "tasks/enhanced",
+            "docs",
+            "docs/tasks",
+            "plans",
+        ];
+        dirs.forEach((dir) => {
+            const fullPath = (0, path_1.join)(this.taskOMatic, dir);
+            if (!(0, fs_1.existsSync)(fullPath)) {
+                (0, fs_1.mkdirSync)(fullPath, { recursive: true });
+            }
+        });
+    }
+    loadTasksData() {
+        this.ensureInitialized();
+        if (!this.tasksFile || !(0, fs_1.existsSync)(this.tasksFile)) {
+            return { tasks: [], nextId: 1 };
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(this.tasksFile, "utf-8");
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error("Failed to read tasks file:", error);
+            return { tasks: [], nextId: 1 };
+        }
+    }
+    saveTasksData(data) {
+        this.ensureInitialized();
+        if (!this.tasksFile) {
+            throw new Error("LocalStorage not initialized");
+        }
+        try {
+            (0, fs_1.writeFileSync)(this.tasksFile, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            throw new Error(`Failed to save tasks data: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    findTaskInHierarchy(tasks, id) {
+        for (let i = 0; i < tasks.length; i++) {
+            const task = tasks[i];
+            if (task.id === id) {
+                return { task, parent: null, index: i };
+            }
+            if (task.subtasks) {
+                const result = this.findTaskInHierarchy(task.subtasks, id);
+                if (result.task) {
+                    return { ...result, parent: task };
+                }
+            }
+        }
+        return { task: null, parent: null, index: -1 };
+    }
+    flattenTasks(tasks) {
+        const result = [];
+        for (const task of tasks) {
+            const { subtasks, ...taskWithoutSubtasks } = task;
+            result.push(taskWithoutSubtasks);
+            if (subtasks) {
+                result.push(...this.flattenTasks(subtasks));
+            }
+        }
+        return result;
+    }
+    // Tasks
+    async getTasks() {
+        const data = this.loadTasksData();
+        return this.flattenTasks(data.tasks);
+    }
+    async getTopLevelTasks() {
+        const data = this.loadTasksData();
+        return data.tasks;
+    }
+    async getTask(id) {
+        this.validateTaskId(id);
+        const data = this.loadTasksData();
+        const result = this.findTaskInHierarchy(data.tasks, id);
+        return result.task;
+    }
+    async createTask(task, aiMetadata) {
+        this.validateTaskRequest(task);
+        this.ensureDirectories(); // Ensure directories exist when actually creating tasks
+        const data = this.loadTasksData();
+        let id;
+        if (task.parentId) {
+            // Generate dot notation ID for subtask
+            const parentResult = this.findTaskInHierarchy(data.tasks, task.parentId);
+            if (!parentResult.task) {
+                throw new Error(`Parent task with ID ${task.parentId} not found`);
+            }
+            const siblingCount = (parentResult.task.subtasks?.length || 0) + 1;
+            id = `${task.parentId}.${siblingCount}`;
+        }
+        else {
+            // Check if task has a predefined ID (from AI generation)
+            if (task.id && typeof task.id === "string") {
+                id = task.id;
+            }
+            else {
+                // Top-level task - use incremental ID
+                id = data.nextId.toString();
+                data.nextId++;
+            }
+        }
+        // Validate dependencies if provided
+        if (task.dependencies && task.dependencies.length > 0) {
+            // Check if all dependency tasks exist
+            for (const depId of task.dependencies) {
+                const depExists = this.taskExists(data.tasks, depId);
+                if (!depExists) {
+                    throw new Error(`Dependency task not found: ${depId}`);
+                }
+            }
+            // Check for circular dependencies
+            if (this.wouldCreateCircularDependency(data.tasks, id, task.dependencies)) {
+                throw new Error(`Circular dependency detected for task ${id}`);
+            }
+        }
+        // Handle content separation
+        let contentFile;
+        let description = task.description || "";
+        if (task.content && task.content.length > 200) {
+            // Save long content to MD file
+            contentFile = await this.saveTaskContent(id, task.content);
+            // Keep first 200 chars as description
+            description = task.description || task.content.substring(0, 200) + "...";
+        }
+        else if (task.content) {
+            // Short content goes in description
+            description = task.description || task.content;
+        }
+        const newTask = {
+            id,
+            title: task.title,
+            description,
+            contentFile,
+            status: task.status || "todo",
+            estimatedEffort: task.estimatedEffort,
+            dependencies: task.dependencies,
+            tags: task.tags,
+            subtasks: [],
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            prdFile: task.prdFile,
+        };
+        if (task.parentId) {
+            // Find parent and add as subtask
+            const parentResult = this.findTaskInHierarchy(data.tasks, task.parentId);
+            if (parentResult.task) {
+                if (!parentResult.task.subtasks) {
+                    parentResult.task.subtasks = [];
+                }
+                parentResult.task.subtasks.push(newTask);
+            }
+        }
+        else {
+            // Top-level task
+            data.tasks.push(newTask);
+        }
+        this.saveTasksData(data);
+        // Save AI metadata separately if provided
+        if (aiMetadata) {
+            await this.saveTaskAIMetadata({
+                ...aiMetadata,
+                taskId: id,
+                generatedAt: Date.now(),
+            });
+        }
+        return newTask;
+    }
+    async updateTask(id, updates) {
+        this.validateTaskId(id);
+        if (!updates || typeof updates !== "object") {
+            throw new Error("Updates must be a valid object");
+        }
+        const data = this.loadTasksData();
+        const result = this.findTaskInHierarchy(data.tasks, id);
+        if (!result.task)
+            return null;
+        const updatedTask = {
+            ...result.task,
+            ...updates,
+            id,
+            updatedAt: Date.now(),
+        };
+        if (result.parent) {
+            // Update in parent's subtasks
+            const parentIndex = result.parent.subtasks.findIndex((t) => t.id === id);
+            result.parent.subtasks[parentIndex] = updatedTask;
+        }
+        else {
+            // Update top-level task
+            const taskIndex = data.tasks.findIndex((t) => t.id === id);
+            data.tasks[taskIndex] = updatedTask;
+        }
+        this.saveTasksData(data);
+        return updatedTask;
+    }
+    async deleteTask(id) {
+        this.validateTaskId(id);
+        const data = this.loadTasksData();
+        const result = this.findTaskInHierarchy(data.tasks, id);
+        if (!result.task)
+            return false;
+        if (result.parent) {
+            // Remove from parent's subtasks
+            const parentIndex = result.parent.subtasks.findIndex((t) => t.id === id);
+            result.parent.subtasks.splice(parentIndex, 1);
+        }
+        else {
+            // Remove top-level task
+            const taskIndex = data.tasks.findIndex((t) => t.id === id);
+            data.tasks.splice(taskIndex, 1);
+        }
+        this.saveTasksData(data);
+        return true;
+    }
+    async getSubtasks(parentId) {
+        const data = this.loadTasksData();
+        const result = this.findTaskInHierarchy(data.tasks, parentId);
+        return result.task?.subtasks || [];
+    }
+    // Helper methods for dependency validation
+    taskExists(tasks, taskId) {
+        // Check for exact match first
+        const exactMatch = this.findTaskInHierarchy(tasks, taskId).task;
+        if (exactMatch)
+            return true;
+        // Check for task- prefix match (AI generates "1" but stored as "task-1")
+        const taskPrefixedId = taskId.startsWith("task-")
+            ? taskId.substring(5)
+            : `task-${taskId}`;
+        const prefixedMatch = this.findTaskInHierarchy(tasks, taskPrefixedId).task;
+        if (prefixedMatch)
+            return true;
+        // Check reverse (stored as "1" but looking for "task-1")
+        if (taskId.startsWith("task-")) {
+            const numericId = taskId.substring(5);
+            const numericMatch = this.findTaskInHierarchy(tasks, numericId).task;
+            if (numericMatch)
+                return true;
+        }
+        return false;
+    }
+    wouldCreateCircularDependency(tasks, newTaskId, dependencies) {
+        const visited = new Set();
+        const checkCircular = (taskId) => {
+            if (visited.has(taskId)) {
+                return true; // Circular dependency detected
+            }
+            if (taskId === newTaskId) {
+                return true; // Found circular reference back to new task
+            }
+            visited.add(taskId);
+            const task = this.findTaskInHierarchy(tasks, taskId).task;
+            if (task && task.dependencies) {
+                for (const depId of task.dependencies) {
+                    if (checkCircular(depId)) {
+                        return true;
+                    }
+                }
+            }
+            visited.delete(taskId);
+            return false;
+        };
+        // Check each dependency chain
+        for (const depId of dependencies) {
+            visited.clear();
+            if (checkCircular(depId)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // AI Metadata
+    getAIMetadataFile() {
+        this.ensureInitialized();
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        return (0, path_1.join)(this.taskOMatic, "ai-metadata.json");
+    }
+    loadAIMetadata() {
+        const metadataFile = this.getAIMetadataFile();
+        if (!(0, fs_1.existsSync)(metadataFile)) {
+            return [];
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(metadataFile, "utf-8");
+            return JSON.parse(content);
+        }
+        catch (error) {
+            console.error("Failed to read AI metadata file:", error);
+            return [];
+        }
+    }
+    saveAIMetadata(metadata) {
+        const metadataFile = this.getAIMetadataFile();
+        (0, fs_1.writeFileSync)(metadataFile, JSON.stringify(metadata, null, 2));
+    }
+    async getTaskAIMetadata(taskId) {
+        const metadata = this.loadAIMetadata();
+        return metadata.find((meta) => meta.taskId === taskId) || null;
+    }
+    async saveTaskAIMetadata(metadata) {
+        const allMetadata = this.loadAIMetadata();
+        const existingIndex = allMetadata.findIndex((meta) => meta.taskId === metadata.taskId);
+        if (existingIndex >= 0) {
+            allMetadata[existingIndex] = metadata;
+        }
+        else {
+            allMetadata.push(metadata);
+        }
+        this.saveAIMetadata(allMetadata);
+    }
+    async deleteTaskAIMetadata(taskId) {
+        const metadata = this.loadAIMetadata();
+        const filtered = metadata.filter((meta) => meta.taskId !== taskId);
+        this.saveAIMetadata(filtered);
+    }
+    // Task Content Files
+    async saveTaskContent(taskId, content) {
+        this.validateTaskId(taskId);
+        if (typeof content !== "string") {
+            throw new Error("Content must be a string");
+        }
+        this.ensureDirectories(); // Ensure directories exist when saving content
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const contentFileName = `tasks/${taskId}.md`;
+        const contentFilePath = (0, path_1.join)(this.taskOMatic, contentFileName);
+        try {
+            (0, fs_1.writeFileSync)(contentFilePath, content, "utf-8");
+        }
+        catch (error) {
+            throw new Error(`Failed to save task content: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        return contentFileName;
+    }
+    async saveEnhancedTaskContent(taskId, content) {
+        this.validateTaskId(taskId);
+        if (typeof content !== "string") {
+            throw new Error("Content must be a string");
+        }
+        this.ensureDirectories(); // Ensure directories exist when saving content
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const contentFileName = `tasks/enhanced/${taskId}.md`;
+        const contentFilePath = (0, path_1.join)(this.taskOMatic, contentFileName);
+        try {
+            (0, fs_1.writeFileSync)(contentFilePath, content, "utf-8");
+        }
+        catch (error) {
+            throw new Error(`Failed to save enhanced task content: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        return contentFileName;
+    }
+    async getTaskContent(taskId) {
+        this.validateTaskId(taskId);
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const contentFileName = `tasks/${taskId}.md`;
+        const contentFilePath = (0, path_1.join)(this.taskOMatic, contentFileName);
+        if (!(0, fs_1.existsSync)(contentFilePath)) {
+            return null;
+        }
+        try {
+            return (0, fs_1.readFileSync)(contentFilePath, "utf-8");
+        }
+        catch (error) {
+            console.error(`Failed to read task content for ${taskId}:`, error);
+            return null;
+        }
+    }
+    async deleteTaskContent(taskId) {
+        this.validateTaskId(taskId);
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const contentFileName = `tasks/${taskId}.md`;
+        const contentFilePath = (0, path_1.join)(this.taskOMatic, contentFileName);
+        if ((0, fs_1.existsSync)(contentFilePath)) {
+            try {
+                (0, fs_1.unlinkSync)(contentFilePath);
+            }
+            catch (error) {
+                console.error(`Failed to delete task content for ${taskId}:`, error);
+            }
+        }
+    }
+    async saveContext7Documentation(library, query, content) {
+        this.ensureDirectories(); // Ensure .task-o-matic/docs exists
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const sanitizedLibrary = this.sanitizeForFilename(library);
+        const sanitizedQuery = this.sanitizeForFilename(query);
+        const libraryDir = (0, path_1.join)(this.taskOMatic, "docs", sanitizedLibrary);
+        if (!(0, fs_1.existsSync)(libraryDir)) {
+            (0, fs_1.mkdirSync)(libraryDir, { recursive: true });
+        }
+        const filePath = (0, path_1.join)(libraryDir, `${sanitizedQuery}.md`);
+        (0, fs_1.writeFileSync)(filePath, content, "utf-8");
+        // Return the relative path for storage
+        return `docs/${sanitizedLibrary}/${sanitizedQuery}.md`;
+    }
+    async getDocumentationFile(fileName) {
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const filePath = (0, path_1.join)(this.taskOMatic, "docs", fileName);
+        if (!(0, fs_1.existsSync)(filePath)) {
+            return null;
+        }
+        try {
+            return (0, fs_1.readFileSync)(filePath, "utf-8");
+        }
+        catch (error) {
+            console.error(`Failed to read documentation file ${fileName}:`, error);
+            return null;
+        }
+    }
+    // List all available documentation files
+    async listDocumentationFiles() {
+        this.ensureInitialized();
+        try {
+            const docsDir = (0, path_1.join)(this.taskOMatic, "docs");
+            if (!(0, fs_1.existsSync)(docsDir)) {
+                return [];
+            }
+            const files = [];
+            const scanDirectory = (dir, basePath = "") => {
+                const items = (0, fs_1.readdirSync)(dir);
+                for (const item of items) {
+                    const fullPath = (0, path_1.join)(dir, item);
+                    const relativePath = basePath ? (0, path_1.join)(basePath, item) : item;
+                    if ((0, fs_1.statSync)(fullPath).isDirectory() && item !== "_cache") {
+                        scanDirectory(fullPath, relativePath);
+                    }
+                    else if (item.endsWith(".md") || item.endsWith(".txt")) {
+                        files.push(relativePath);
+                    }
+                }
+            };
+            scanDirectory(docsDir);
+            return files;
+        }
+        catch (error) {
+            console.error("Failed to list documentation files:", error);
+            return [];
+        }
+    }
+    // Migration: Separate existing task content into MD files
+    async migrateTaskContent() {
+        const data = this.loadTasksData();
+        let migratedCount = 0;
+        const migrateTask = (task) => {
+            let updatedTask = { ...task };
+            // Check if task has old content property and no contentFile
+            if ("content" in task && task.content && !task.contentFile) {
+                const oldContent = task.content;
+                if (oldContent.length > 200) {
+                    // Move long content to MD file
+                    if (!this.taskOMatic) {
+                        throw new Error("LocalStorage not initialized");
+                    }
+                    const contentFile = `tasks/${task.id}.md`;
+                    const contentFilePath = (0, path_1.join)(this.taskOMatic, contentFile);
+                    (0, fs_1.writeFileSync)(contentFilePath, oldContent, "utf-8");
+                    updatedTask.contentFile = contentFile;
+                    updatedTask.description =
+                        task.description || oldContent.substring(0, 200) + "...";
+                }
+                else {
+                    // Keep short content as description
+                    updatedTask.description = task.description || oldContent;
+                }
+                // Remove old content property
+                const { content: _, ...taskWithoutContent } = updatedTask;
+                updatedTask = taskWithoutContent;
+                migratedCount++;
+            }
+            // Migrate subtasks
+            if (task.subtasks) {
+                updatedTask.subtasks = task.subtasks.map(migrateTask);
+            }
+            return updatedTask;
+        };
+        // Process all tasks
+        data.tasks = data.tasks.map(migrateTask);
+        if (migratedCount > 0) {
+            this.saveTasksData(data);
+        }
+        return migratedCount;
+    }
+    // Cleanup utilities
+    async cleanupOrphanedContent() {
+        const data = this.loadTasksData();
+        const allTasks = this.flattenTasks(data.tasks);
+        const validContentFiles = new Set(allTasks
+            .filter((task) => task.contentFile)
+            .map((task) => task.contentFile));
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const tasksDir = (0, path_1.join)(this.taskOMatic, "tasks");
+        let cleanedCount = 0;
+        try {
+            const files = (0, fs_1.readdirSync)(tasksDir);
+            for (const file of files) {
+                if (file.endsWith(".md")) {
+                    const contentFile = `tasks/${file}`;
+                    if (!validContentFiles.has(contentFile)) {
+                        const filePath = (0, path_1.join)(tasksDir, file);
+                        try {
+                            (0, fs_1.unlinkSync)(filePath);
+                            cleanedCount++;
+                            console.log(`Cleaned up orphaned content file: ${file}`);
+                        }
+                        catch (error) {
+                            console.error(`Failed to delete orphaned file ${file}:`, error);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error("Failed to cleanup orphaned content:", error);
+        }
+        return cleanedCount;
+    }
+    async validateStorageIntegrity() {
+        const issues = [];
+        try {
+            // Check if directories exist
+            this.ensureDirectories();
+            // Validate tasks data structure
+            const data = this.loadTasksData();
+            if (!Array.isArray(data.tasks)) {
+                issues.push("Tasks data is not an array");
+            }
+            if (typeof data.nextId !== "number" || data.nextId < 1) {
+                issues.push("Invalid nextId in tasks data");
+            }
+            // Check for duplicate task IDs
+            const allTasks = this.flattenTasks(data.tasks);
+            const taskIds = allTasks.map((task) => task.id);
+            const duplicateIds = taskIds.filter((id, index) => taskIds.indexOf(id) !== index);
+            if (duplicateIds.length > 0) {
+                issues.push(`Duplicate task IDs found: ${duplicateIds.join(", ")}`);
+            }
+            // Check for invalid dependencies
+            for (const task of allTasks) {
+                if (task.dependencies) {
+                    for (const depId of task.dependencies) {
+                        if (!taskIds.includes(depId)) {
+                            issues.push(`Task ${task.id} has invalid dependency: ${depId}`);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            issues.push(`Storage validation error: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        return {
+            isValid: issues.length === 0,
+            issues,
+        };
+    }
+    // Plan storage methods
+    async savePlan(taskId, plan) {
+        this.validateTaskId(taskId);
+        this.ensureInitialized();
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const planFile = (0, path_1.join)(this.taskOMatic, "plans", `${taskId}.md`);
+        try {
+            const planData = {
+                taskId,
+                plan,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            (0, fs_1.writeFileSync)(planFile, JSON.stringify(planData, null, 2));
+        }
+        catch (error) {
+            throw new Error(`Failed to save plan for task ${taskId}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async getPlan(taskId) {
+        this.validateTaskId(taskId);
+        this.ensureInitialized();
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const planFile = (0, path_1.join)(this.taskOMatic, "plans", `${taskId}.json`);
+        if (!(0, fs_1.existsSync)(planFile)) {
+            return null;
+        }
+        try {
+            const content = (0, fs_1.readFileSync)(planFile, "utf-8");
+            return JSON.parse(content);
+        }
+        catch (error) {
+            throw new Error(`Failed to read plan for task ${taskId}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async listPlans() {
+        this.ensureInitialized();
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const plansDir = (0, path_1.join)(this.taskOMatic, "plans");
+        if (!(0, fs_1.existsSync)(plansDir)) {
+            return [];
+        }
+        try {
+            const plans = [];
+            const files = (0, fs_1.readdirSync)(plansDir);
+            for (const file of files) {
+                if (file.endsWith(".json")) {
+                    const taskId = file.replace(".json", "");
+                    const planData = await this.getPlan(taskId);
+                    if (planData) {
+                        plans.push({
+                            taskId,
+                            plan: planData.plan,
+                            createdAt: planData.createdAt,
+                            updatedAt: planData.updatedAt,
+                        });
+                    }
+                }
+            }
+            return plans.sort((a, b) => b.updatedAt - a.updatedAt); // Most recent first
+        }
+        catch (error) {
+            throw new Error(`Failed to list plans: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async deletePlan(taskId) {
+        this.validateTaskId(taskId);
+        this.ensureInitialized();
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const planFile = (0, path_1.join)(this.taskOMatic, "plans", `${taskId}.json`);
+        if (!(0, fs_1.existsSync)(planFile)) {
+            return false;
+        }
+        try {
+            (0, fs_1.unlinkSync)(planFile);
+            return true;
+        }
+        catch (error) {
+            throw new Error(`Failed to delete plan for task ${taskId}: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+    }
+    async saveTaskDocumentation(taskId, documentation) {
+        this.validateTaskId(taskId);
+        if (typeof documentation !== "string") {
+            throw new Error("Documentation must be a string");
+        }
+        this.ensureDirectories(); // Ensure docs/tasks directory exists
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const documentationFileName = `docs/tasks/${taskId}.md`;
+        const documentationFilePath = (0, path_1.join)(this.taskOMatic, documentationFileName);
+        try {
+            (0, fs_1.writeFileSync)(documentationFilePath, documentation, "utf-8");
+        }
+        catch (error) {
+            throw new Error(`Failed to save task documentation: ${error instanceof Error ? error.message : "Unknown error"}`);
+        }
+        return documentationFileName;
+    }
+    async getTaskDocumentation(taskId) {
+        this.validateTaskId(taskId);
+        if (!this.taskOMatic) {
+            throw new Error("LocalStorage not initialized");
+        }
+        const documentationFileName = `docs/tasks/${taskId}.md`;
+        const documentationFilePath = (0, path_1.join)(this.taskOMatic, documentationFileName);
+        if (!(0, fs_1.existsSync)(documentationFilePath)) {
+            return null;
+        }
+        try {
+            return (0, fs_1.readFileSync)(documentationFilePath, "utf-8");
+        }
+        catch (error) {
+            console.error(`Failed to read task documentation for ${taskId}:`, error);
+            return null;
+        }
+    }
+}
+exports.LocalStorage = LocalStorage;