task-o-matic 0.0.2 → 0.0.4

package/dist/lib/{storage.js → storage/file-system.js}

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LocalStorage = void 0;
-const fs_1 = require("fs");
+exports.FileSystemStorage = void 0;
+const promises_1 = require("fs/promises");
 const path_1 = require("path");
-const config_1 = require("./config");
-class LocalStorage {
+const config_1 = require("../config");
+class FileSystemStorage {
     taskOMatic = null;
     tasksFile = null;
     initialized = false;
@@ -12,12 +12,6 @@ class LocalStorage {
         // 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) {
@@ -56,10 +50,10 @@ class LocalStorage {
         this.tasksFile = (0, path_1.join)(this.taskOMatic, "tasks.json");
         this.initialized = true;
     }
-    ensureDirectories() {
+    async ensureDirectories() {
         this.ensureInitialized();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
         const dirs = [
             "prd",
@@ -70,20 +64,31 @@ class LocalStorage {
             "docs/tasks",
             "plans",
         ];
-        dirs.forEach((dir) => {
+        for (const dir of dirs) {
             const fullPath = (0, path_1.join)(this.taskOMatic, dir);
-            if (!(0, fs_1.existsSync)(fullPath)) {
-                (0, fs_1.mkdirSync)(fullPath, { recursive: true });
+            try {
+                await (0, promises_1.mkdir)(fullPath, { recursive: true });
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
             }
-        });
+        }
     }
-    loadTasksData() {
+    async loadTasksData() {
         this.ensureInitialized();
-        if (!this.tasksFile || !(0, fs_1.existsSync)(this.tasksFile)) {
+        if (!this.tasksFile) {
             return { tasks: [], nextId: 1 };
         }
         try {
-            const content = (0, fs_1.readFileSync)(this.tasksFile, "utf-8");
+            // Check if file exists using access or stat, or just try reading
+            await (0, promises_1.stat)(this.tasksFile);
+        }
+        catch {
+            return { tasks: [], nextId: 1 };
+        }
+        try {
+            const content = await (0, promises_1.readFile)(this.tasksFile, "utf-8");
             return JSON.parse(content);
         }
         catch (error) {
@@ -91,13 +96,13 @@ class LocalStorage {
             return { tasks: [], nextId: 1 };
         }
     }
-    saveTasksData(data) {
+    async saveTasksData(data) {
         this.ensureInitialized();
         if (!this.tasksFile) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
         try {
-            (0, fs_1.writeFileSync)(this.tasksFile, JSON.stringify(data, null, 2));
+            await (0, promises_1.writeFile)(this.tasksFile, JSON.stringify(data, null, 2));
         }
         catch (error) {
             throw new Error(`Failed to save tasks data: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -131,26 +136,25 @@ class LocalStorage {
     }
     // Tasks
     async getTasks() {
-        const data = this.loadTasksData();
+        const data = await this.loadTasksData();
         return this.flattenTasks(data.tasks);
     }
     async getTopLevelTasks() {
-        const data = this.loadTasksData();
+        const data = await this.loadTasksData();
         return data.tasks;
     }
     async getTask(id) {
         this.validateTaskId(id);
-        const data = this.loadTasksData();
+        const data = await 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();
+        await this.ensureDirectories();
+        const data = await 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`);
@@ -159,41 +163,32 @@ class LocalStorage {
             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 = {
@@ -211,7 +206,6 @@ class LocalStorage {
             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) {
@@ -221,11 +215,9 @@ class LocalStorage {
             }
         }
         else {
-            // Top-level task
             data.tasks.push(newTask);
         }
-        this.saveTasksData(data);
-        // Save AI metadata separately if provided
+        await this.saveTasksData(data);
         if (aiMetadata) {
             await this.saveTaskAIMetadata({
                 ...aiMetadata,
@@ -240,7 +232,7 @@ class LocalStorage {
         if (!updates || typeof updates !== "object") {
             throw new Error("Updates must be a valid object");
         }
-        const data = this.loadTasksData();
+        const data = await this.loadTasksData();
         const result = this.findTaskInHierarchy(data.tasks, id);
         if (!result.task)
             return null;
@@ -251,56 +243,48 @@ class LocalStorage {
             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);
+        await this.saveTasksData(data);
         return updatedTask;
     }
     async deleteTask(id) {
         this.validateTaskId(id);
-        const data = this.loadTasksData();
+        const data = await 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);
+        await this.saveTasksData(data);
         return true;
     }
     async getSubtasks(parentId) {
-        const data = this.loadTasksData();
+        const data = await 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;
@@ -313,10 +297,10 @@ class LocalStorage {
         const visited = new Set();
         const checkCircular = (taskId) => {
             if (visited.has(taskId)) {
-                return true; // Circular dependency detected
+                return true;
             }
             if (taskId === newTaskId) {
-                return true; // Found circular reference back to new task
+                return true;
             }
             visited.add(taskId);
             const task = this.findTaskInHierarchy(tasks, taskId).task;
@@ -330,7 +314,6 @@ class LocalStorage {
             visited.delete(taskId);
             return false;
         };
-        // Check each dependency chain
         for (const depId of dependencies) {
             visited.clear();
             if (checkCircular(depId)) {
@@ -339,21 +322,23 @@ class LocalStorage {
         }
         return false;
     }
-    // AI Metadata
     getAIMetadataFile() {
         this.ensureInitialized();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
         return (0, path_1.join)(this.taskOMatic, "ai-metadata.json");
     }
-    loadAIMetadata() {
+    async loadAIMetadata() {
         const metadataFile = this.getAIMetadataFile();
-        if (!(0, fs_1.existsSync)(metadataFile)) {
+        try {
+            await (0, promises_1.stat)(metadataFile);
+        }
+        catch {
             return [];
         }
         try {
-            const content = (0, fs_1.readFileSync)(metadataFile, "utf-8");
+            const content = await (0, promises_1.readFile)(metadataFile, "utf-8");
             return JSON.parse(content);
         }
         catch (error) {
@@ -361,16 +346,16 @@ class LocalStorage {
             return [];
         }
     }
-    saveAIMetadata(metadata) {
+    async saveAIMetadata(metadata) {
         const metadataFile = this.getAIMetadataFile();
-        (0, fs_1.writeFileSync)(metadataFile, JSON.stringify(metadata, null, 2));
+        await (0, promises_1.writeFile)(metadataFile, JSON.stringify(metadata, null, 2));
     }
     async getTaskAIMetadata(taskId) {
-        const metadata = this.loadAIMetadata();
+        const metadata = await this.loadAIMetadata();
         return metadata.find((meta) => meta.taskId === taskId) || null;
     }
     async saveTaskAIMetadata(metadata) {
-        const allMetadata = this.loadAIMetadata();
+        const allMetadata = await this.loadAIMetadata();
         const existingIndex = allMetadata.findIndex((meta) => meta.taskId === metadata.taskId);
         if (existingIndex >= 0) {
             allMetadata[existingIndex] = metadata;
@@ -378,27 +363,26 @@ class LocalStorage {
         else {
             allMetadata.push(metadata);
         }
-        this.saveAIMetadata(allMetadata);
+        await this.saveAIMetadata(allMetadata);
     }
     async deleteTaskAIMetadata(taskId) {
-        const metadata = this.loadAIMetadata();
+        const metadata = await this.loadAIMetadata();
         const filtered = metadata.filter((meta) => meta.taskId !== taskId);
-        this.saveAIMetadata(filtered);
+        await 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
+        await this.ensureDirectories();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage 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");
+            await (0, promises_1.writeFile)(contentFilePath, content, "utf-8");
         }
         catch (error) {
             throw new Error(`Failed to save task content: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -410,14 +394,14 @@ class LocalStorage {
         if (typeof content !== "string") {
             throw new Error("Content must be a string");
         }
-        this.ensureDirectories(); // Ensure directories exist when saving content
+        await this.ensureDirectories();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage 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");
+            await (0, promises_1.writeFile)(contentFilePath, content, "utf-8");
         }
         catch (error) {
             throw new Error(`Failed to save enhanced task content: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -427,15 +411,18 @@ class LocalStorage {
     async getTaskContent(taskId) {
         this.validateTaskId(taskId);
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
         const contentFileName = `tasks/${taskId}.md`;
         const contentFilePath = (0, path_1.join)(this.taskOMatic, contentFileName);
-        if (!(0, fs_1.existsSync)(contentFilePath)) {
+        try {
+            await (0, promises_1.stat)(contentFilePath);
+        }
+        catch {
             return null;
         }
         try {
-            return (0, fs_1.readFileSync)(contentFilePath, "utf-8");
+            return await (0, promises_1.readFile)(contentFilePath, "utf-8");
         }
         catch (error) {
             console.error(`Failed to read task content for ${taskId}:`, error);
@@ -445,74 +432,82 @@ class LocalStorage {
     async deleteTaskContent(taskId) {
         this.validateTaskId(taskId);
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage 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);
-            }
+        try {
+            await (0, promises_1.stat)(contentFilePath);
+            await (0, promises_1.unlink)(contentFilePath);
+        }
+        catch (error) {
+            // Ignore if file doesn't exist
         }
     }
     async saveContext7Documentation(library, query, content) {
-        this.ensureDirectories(); // Ensure .task-o-matic/docs exists
+        await this.ensureDirectories();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage 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 });
+        try {
+            await (0, promises_1.mkdir)(libraryDir, { recursive: true });
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
         }
         const filePath = (0, path_1.join)(libraryDir, `${sanitizedQuery}.md`);
-        (0, fs_1.writeFileSync)(filePath, content, "utf-8");
-        // Return the relative path for storage
+        await (0, promises_1.writeFile)(filePath, content, "utf-8");
         return `docs/${sanitizedLibrary}/${sanitizedQuery}.md`;
     }
     async getDocumentationFile(fileName) {
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
         const filePath = (0, path_1.join)(this.taskOMatic, "docs", fileName);
-        if (!(0, fs_1.existsSync)(filePath)) {
+        try {
+            await (0, promises_1.stat)(filePath);
+        }
+        catch {
             return null;
         }
         try {
-            return (0, fs_1.readFileSync)(filePath, "utf-8");
+            return await (0, promises_1.readFile)(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)) {
+            try {
+                await (0, promises_1.stat)(docsDir);
+            }
+            catch {
                 return [];
             }
             const files = [];
-            const scanDirectory = (dir, basePath = "") => {
-                const items = (0, fs_1.readdirSync)(dir);
+            const scanDirectory = async (dir, basePath = "") => {
+                const items = await (0, promises_1.readdir)(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);
+                    const stats = await (0, promises_1.stat)(fullPath);
+                    if (stats.isDirectory() && item !== "_cache") {
+                        await scanDirectory(fullPath, relativePath);
                     }
                     else if (item.endsWith(".md") || item.endsWith(".txt")) {
                         files.push(relativePath);
                     }
                 }
             };
-            scanDirectory(docsDir);
+            await scanDirectory(docsDir);
             return files;
         }
         catch (error) {
@@ -520,70 +515,62 @@ class LocalStorage {
             return [];
         }
     }
-    // Migration: Separate existing task content into MD files
     async migrateTaskContent() {
-        const data = this.loadTasksData();
+        const data = await this.loadTasksData();
         let migratedCount = 0;
-        const migrateTask = (task) => {
+        const migrateTask = async (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");
+                        throw new Error("FileSystemStorage 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");
+                    await (0, promises_1.writeFile)(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);
+                updatedTask.subtasks = await Promise.all(task.subtasks.map(migrateTask));
             }
             return updatedTask;
         };
-        // Process all tasks
-        data.tasks = data.tasks.map(migrateTask);
+        data.tasks = await Promise.all(data.tasks.map(migrateTask));
         if (migratedCount > 0) {
-            this.saveTasksData(data);
+            await this.saveTasksData(data);
         }
         return migratedCount;
     }
-    // Cleanup utilities
     async cleanupOrphanedContent() {
-        const data = this.loadTasksData();
+        const data = await 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");
+            throw new Error("FileSystemStorage not initialized");
         }
         const tasksDir = (0, path_1.join)(this.taskOMatic, "tasks");
         let cleanedCount = 0;
         try {
-            const files = (0, fs_1.readdirSync)(tasksDir);
+            const files = await (0, promises_1.readdir)(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);
+                            await (0, promises_1.unlink)(filePath);
                             cleanedCount++;
                             console.log(`Cleaned up orphaned content file: ${file}`);
                         }
@@ -602,24 +589,20 @@ class LocalStorage {
     async validateStorageIntegrity() {
         const issues = [];
         try {
-            // Check if directories exist
-            this.ensureDirectories();
-            // Validate tasks data structure
-            const data = this.loadTasksData();
+            await this.ensureDirectories();
+            const data = await 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) {
@@ -638,14 +621,13 @@ class LocalStorage {
             issues,
         };
     }
-    // Plan storage methods
     async savePlan(taskId, plan) {
         this.validateTaskId(taskId);
         this.ensureInitialized();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
-        const planFile = (0, path_1.join)(this.taskOMatic, "plans", `${taskId}.md`);
+        const planFile = (0, path_1.join)(this.taskOMatic, "plans", `${taskId}.json`);
         try {
             const planData = {
                 taskId,
@@ -653,7 +635,7 @@ class LocalStorage {
                 createdAt: Date.now(),
                 updatedAt: Date.now(),
             };
-            (0, fs_1.writeFileSync)(planFile, JSON.stringify(planData, null, 2));
+            await (0, promises_1.writeFile)(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"}`);
@@ -663,14 +645,17 @@ class LocalStorage {
         this.validateTaskId(taskId);
         this.ensureInitialized();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
         const planFile = (0, path_1.join)(this.taskOMatic, "plans", `${taskId}.json`);
-        if (!(0, fs_1.existsSync)(planFile)) {
+        try {
+            await (0, promises_1.stat)(planFile);
+        }
+        catch {
             return null;
         }
         try {
-            const content = (0, fs_1.readFileSync)(planFile, "utf-8");
+            const content = await (0, promises_1.readFile)(planFile, "utf-8");
             return JSON.parse(content);
         }
         catch (error) {
@@ -680,15 +665,18 @@ class LocalStorage {
     async listPlans() {
         this.ensureInitialized();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
         const plansDir = (0, path_1.join)(this.taskOMatic, "plans");
-        if (!(0, fs_1.existsSync)(plansDir)) {
+        try {
+            await (0, promises_1.stat)(plansDir);
+        }
+        catch {
             return [];
         }
         try {
             const plans = [];
-            const files = (0, fs_1.readdirSync)(plansDir);
+            const files = await (0, promises_1.readdir)(plansDir);
             for (const file of files) {
                 if (file.endsWith(".json")) {
                     const taskId = file.replace(".json", "");
@@ -703,7 +691,7 @@ class LocalStorage {
                     }
                 }
             }
-            return plans.sort((a, b) => b.updatedAt - a.updatedAt); // Most recent first
+            return plans.sort((a, b) => b.updatedAt - a.updatedAt);
         }
         catch (error) {
             throw new Error(`Failed to list plans: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -713,18 +701,16 @@ class LocalStorage {
         this.validateTaskId(taskId);
         this.ensureInitialized();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage 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);
+            await (0, promises_1.stat)(planFile);
+            await (0, promises_1.unlink)(planFile);
             return true;
         }
         catch (error) {
-            throw new Error(`Failed to delete plan for task ${taskId}: ${error instanceof Error ? error.message : "Unknown error"}`);
+            return false;
         }
     }
     async saveTaskDocumentation(taskId, documentation) {
@@ -732,14 +718,14 @@ class LocalStorage {
         if (typeof documentation !== "string") {
             throw new Error("Documentation must be a string");
         }
-        this.ensureDirectories(); // Ensure docs/tasks directory exists
+        await this.ensureDirectories();
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage 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");
+            await (0, promises_1.writeFile)(documentationFilePath, documentation, "utf-8");
         }
         catch (error) {
             throw new Error(`Failed to save task documentation: ${error instanceof Error ? error.message : "Unknown error"}`);
@@ -749,15 +735,18 @@ class LocalStorage {
     async getTaskDocumentation(taskId) {
         this.validateTaskId(taskId);
         if (!this.taskOMatic) {
-            throw new Error("LocalStorage not initialized");
+            throw new Error("FileSystemStorage not initialized");
         }
         const documentationFileName = `docs/tasks/${taskId}.md`;
         const documentationFilePath = (0, path_1.join)(this.taskOMatic, documentationFileName);
-        if (!(0, fs_1.existsSync)(documentationFilePath)) {
+        try {
+            await (0, promises_1.stat)(documentationFilePath);
+        }
+        catch {
             return null;
         }
         try {
-            return (0, fs_1.readFileSync)(documentationFilePath, "utf-8");
+            return await (0, promises_1.readFile)(documentationFilePath, "utf-8");
         }
         catch (error) {
             console.error(`Failed to read task documentation for ${taskId}:`, error);
@@ -765,4 +754,4 @@ class LocalStorage {
         }
     }
 }
-exports.LocalStorage = LocalStorage;
+exports.FileSystemStorage = FileSystemStorage;