Merge pull request #26 from AutoMaker-Org/bugfix/appspec-complete-overhaul

Complete overhaul for app spec system. Created logic to auto generate…

Author: webdevcody

app/electron/auto-mode-service.js

@@ -391,8 +391,7 @@ class AutoModeService {
           featureId,
           "waiting_approval",
           projectPath,
-          null, // no summary
-          error.message // pass error message
+          { error: error.message }
         );
       } catch (statusError) {
         console.error("[AutoMode] Failed to update feature status after error:", statusError);
@@ -495,8 +494,7 @@ class AutoModeService {
           featureId,
           "waiting_approval",
           projectPath,
-          null, // no summary
-          error.message // pass error message
+          { error: error.message }
         );
       } catch (statusError) {
         console.error("[AutoMode] Failed to update feature status after error:", statusError);
@@ -662,8 +660,7 @@ class AutoModeService {
           featureId,
           "waiting_approval",
           projectPath,
-          null, // no summary
-          error.message // pass error message
+          { error: error.message }
         );
       } catch (statusError) {
         console.error("[AutoMode] Failed to update feature status after error:", statusError);
@@ -859,8 +856,7 @@ class AutoModeService {
           featureId,
           "waiting_approval",
           projectPath,
-          null, // no summary
-          error.message // pass error message
+          { error: error.message }
         );
       } catch (statusError) {
         console.error("[AutoMode] Failed to update feature status after error:", statusError);
@@ -1102,8 +1098,7 @@ class AutoModeService {
           featureId,
           "waiting_approval",
           projectPath,
-          null, // no summary
-          error.message // pass error message
+          { error: error.message }
         );
       } catch (statusError) {
         console.error("[AutoMode] Failed to update feature status after error:", statusError);

app/electron/main.js

@@ -898,7 +898,7 @@ ipcMain.handle(
         featureId,
         status,
         projectPath,
-        summary
+        { summary }
       );
 
       // Notify renderer if window is available
@@ -1170,6 +1170,7 @@ ipcMain.handle("spec-regeneration:status", () => {
     isRunning:
       specRegenerationExecution !== null &&
       specRegenerationExecution.isActive(),
+    currentPhase: specRegenerationService.getCurrentPhase(),
   };
 });
 
@@ -1234,6 +1235,62 @@ ipcMain.handle(
   }
 );
 
+/**
+ * Generate features from existing app_spec.txt
+ * This allows users to generate features retroactively without regenerating the spec
+ */
+ipcMain.handle(
+  "spec-regeneration:generate-features",
+  async (_, { projectPath }) => {
+    try {
+      // Add project path to allowed paths
+      addAllowedPath(projectPath);
+
+      // Check if already running
+      if (specRegenerationExecution && specRegenerationExecution.isActive()) {
+        return { success: false, error: "Spec regeneration is already running" };
+      }
+
+      // Create execution context
+      specRegenerationExecution = {
+        abortController: null,
+        query: null,
+        isActive: () => specRegenerationExecution !== null,
+      };
+
+      const sendToRenderer = (data) => {
+        if (mainWindow && !mainWindow.isDestroyed()) {
+          mainWindow.webContents.send("spec-regeneration:event", data);
+        }
+      };
+
+      // Start generating features (runs in background)
+      specRegenerationService
+        .generateFeaturesOnly(projectPath, sendToRenderer, specRegenerationExecution)
+        .catch((error) => {
+          console.error(
+            "[IPC] spec-regeneration:generate-features background error:",
+            error
+          );
+          sendToRenderer({
+            type: "spec_regeneration_error",
+            error: error.message,
+          });
+        })
+        .finally(() => {
+          specRegenerationExecution = null;
+        });
+
+      // Return immediately
+      return { success: true };
+    } catch (error) {
+      console.error("[IPC] spec-regeneration:generate-features error:", error);
+      specRegenerationExecution = null;
+      return { success: false, error: error.message };
+    }
+  }
+);
+
 /**
  * Merge feature worktree changes back to main branch
  */

app/electron/preload.js

@@ -285,6 +285,12 @@ contextBridge.exposeInMainWorld("electronAPI", {
         projectDefinition,
       }),
 
+    // Generate features from existing app_spec.txt
+    generateFeatures: (projectPath) =>
+      ipcRenderer.invoke("spec-regeneration:generate-features", {
+        projectPath,
+      }),
+
     // Stop regenerating spec
     stop: () => ipcRenderer.invoke("spec-regeneration:stop"),
 

app/electron/services/feature-loader.js

@@ -170,14 +170,38 @@ class FeatureLoader {
         const featureJsonPath = this.getFeatureJsonPath(projectPath, featureId);
 
         try {
+          // Read feature.json directly - handle ENOENT in catch block
+          // This avoids TOCTOU race condition from checking with fs.access first
           const content = await fs.readFile(featureJsonPath, "utf-8");
           const feature = JSON.parse(content);
+          
+          // Validate that the feature has required fields
+          if (!feature.id) {
+            console.warn(
+              `[FeatureLoader] Feature ${featureId} missing required 'id' field, skipping`
+            );
+            continue;
+          }
+          
           features.push(feature);
         } catch (error) {
-          console.error(
-            `[FeatureLoader] Failed to load feature ${featureId}:`,
-            error
-          );
+          // Handle different error types appropriately
+          if (error.code === "ENOENT") {
+            // File doesn't exist - this is expected for incomplete feature directories
+            // Skip silently (feature.json not yet created or was removed)
+            continue;
+          } else if (error instanceof SyntaxError) {
+            // JSON parse error - log as warning since file exists but is malformed
+            console.warn(
+              `[FeatureLoader] Failed to parse feature.json for ${featureId}: ${error.message}`
+            );
+          } else {
+            // Other errors - log as error
+            console.error(
+              `[FeatureLoader] Failed to load feature ${featureId}:`,
+              error.message || error
+            );
+          }
           // Continue loading other features
         }
       }
@@ -339,30 +363,93 @@ class FeatureLoader {
   /**
    * Update feature status (legacy API)
    * Features are stored in .automaker/features/{id}/feature.json
+   * Creates the feature if it doesn't exist.
    * @param {string} featureId - The ID of the feature to update
    * @param {string} status - The new status
    * @param {string} projectPath - Path to the project
-   * @param {string} [summary] - Optional summary of what was done
-   * @param {string} [error] - Optional error message if feature errored
+   * @param {Object} options - Options object for optional parameters
+   * @param {string} [options.summary] - Optional summary of what was done
+   * @param {string} [options.error] - Optional error message if feature errored
+   * @param {string} [options.description] - Optional detailed description
+   * @param {string} [options.category] - Optional category/phase
+   * @param {string[]} [options.steps] - Optional array of implementation steps
    */
-  async updateFeatureStatus(featureId, status, projectPath, summary, error) {
+  async updateFeatureStatus(featureId, status, projectPath, options = {}) {
+    const { summary, error, description, category, steps } = options;
+    // Check if feature exists
+    const existingFeature = await this.get(projectPath, featureId);
+    
+    if (!existingFeature) {
+      // Feature doesn't exist - create it with all required fields
+      console.log(`[FeatureLoader] Feature ${featureId} not found - creating new feature`);
+      const newFeature = {
+        id: featureId,
+        title: featureId.split('-').map(word => word.charAt(0).toUpperCase() + word.slice(1)).join(' '),
+        description: description || summary || '', // Use provided description, fall back to summary
+        category: category || "Uncategorized",
+        steps: steps || [],
+        status: status,
+        images: [],
+        imagePaths: [],
+        skipTests: false, // Auto-generated features should run tests by default
+        model: "sonnet",
+        thinkingLevel: "none",
+        summary: summary || description || '',
+        createdAt: new Date().toISOString(),
+      };
+      if (error !== undefined) {
+        newFeature.error = error;
+      }
+      await this.create(projectPath, newFeature);
+      console.log(
+        `[FeatureLoader] Created feature ${featureId}: status=${status}, category=${category || "Uncategorized"}, steps=${steps?.length || 0}${
+          summary ? `, summary="${summary}"` : ""
+        }`
+      );
+      return;
+    }
+
+    // Feature exists - update it
     const updates = { status };
     if (summary !== undefined) {
       updates.summary = summary;
+      // Also update description if it's empty or not set
+      if (!existingFeature.description) {
+        updates.description = summary;
+      }
+    }
+    if (description !== undefined) {
+      updates.description = description;
+    }
+    if (category !== undefined) {
+      updates.category = category;
+    }
+    if (steps !== undefined && Array.isArray(steps)) {
+      updates.steps = steps;
     }
     if (error !== undefined) {
       updates.error = error;
     } else {
       // Clear error if not provided
-      const feature = await this.get(projectPath, featureId);
-      if (feature && feature.error) {
+      if (existingFeature.error) {
         updates.error = undefined;
       }
     }
+    
+    // Ensure required fields exist (for features created before this fix)
+    if (!existingFeature.category && !updates.category) updates.category = "Uncategorized";
+    if (!existingFeature.steps && !updates.steps) updates.steps = [];
+    if (!existingFeature.images) updates.images = [];
+    if (!existingFeature.imagePaths) updates.imagePaths = [];
+    if (existingFeature.skipTests === undefined) updates.skipTests = false;
+    if (!existingFeature.model) updates.model = "sonnet";
+    if (!existingFeature.thinkingLevel) updates.thinkingLevel = "none";
 
     await this.update(projectPath, featureId, updates);
     console.log(
       `[FeatureLoader] Updated feature ${featureId}: status=${status}${
+        category ? `, category="${category}"` : ""
+      }${steps ? `, steps=${steps.length}` : ""}${
         summary ? `, summary="${summary}"` : ""
       }`
     );

app/electron/services/mcp-server-factory.js

@@ -19,37 +19,58 @@ class McpServerFactory {
       tools: [
         tool(
           "UpdateFeatureStatus",
-          "Update the status of a feature. Use this tool instead of directly modifying feature files to safely update feature status. IMPORTANT: If the feature has skipTests=true, you should NOT mark it as verified - instead it will automatically go to waiting_approval status for manual review. Always include a summary of what was done.",
+          "Create or update a feature. Use this tool to create new features with detailed information or update existing feature status. When creating features, provide comprehensive description, category, and implementation steps.",
           {
-            featureId: z.string().describe("The ID of the feature to update"),
-            status: z.enum(["backlog", "in_progress", "verified"]).describe("The new status for the feature. Note: If skipTests=true, verified will be converted to waiting_approval automatically."),
-            summary: z.string().optional().describe("A brief summary of what was implemented/changed. This will be displayed on the Kanban card. Example: 'Added dark mode toggle. Modified: settings.tsx, theme-provider.tsx'")
+            featureId: z.string().describe("The ID of the feature (lowercase, hyphens for spaces). Example: 'user-authentication', 'budget-tracking'"),
+            status: z.enum(["backlog", "todo", "in_progress", "verified"]).describe("The status for the feature. Use 'backlog' or 'todo' for new features."),
+            summary: z.string().optional().describe("A brief summary of what was implemented/changed or what the feature does."),
+            description: z.string().optional().describe("A detailed description of the feature. Be comprehensive - explain what the feature does, its purpose, and key functionality."),
+            category: z.string().optional().describe("The category/phase for this feature. Example: 'Phase 1: Foundation', 'Phase 2: Core Logic', 'Phase 3: Polish', 'Authentication', 'UI/UX'"),
+            steps: z.array(z.string()).optional().describe("Array of implementation steps. Each step should be a clear, actionable task. Example: ['Set up database schema', 'Create API endpoints', 'Build UI components', 'Add validation']")
           },
           async (args) => {
             try {
-              console.log(`[McpServerFactory] UpdateFeatureStatus tool called: featureId=${args.featureId}, status=${args.status}, summary=${args.summary || "(none)"}`);
+              console.log(`[McpServerFactory] UpdateFeatureStatus tool called: featureId=${args.featureId}, status=${args.status}, summary=${args.summary || "(none)"}, category=${args.category || "(none)"}, steps=${args.steps?.length || 0}`);
+              console.log(`[Feature Creation] Creating/updating feature "${args.featureId}" with status "${args.status}"`);
 
               // Load the feature to check skipTests flag
               const features = await featureLoader.loadFeatures(projectPath);
               const feature = features.find((f) => f.id === args.featureId);
 
               if (!feature) {
-                throw new Error(`Feature ${args.featureId} not found`);
+                console.log(`[Feature Creation] Feature ${args.featureId} not found - this might be a new feature being created`);
+                // This might be a new feature - try to proceed anyway
               }
 
               // If agent tries to mark as verified but feature has skipTests=true, convert to waiting_approval
               let finalStatus = args.status;
-              if (args.status === "verified" && feature.skipTests === true) {
+              // Convert 'todo' to 'backlog' for consistency, but only for new features
+              if (!feature && finalStatus === "todo") {
+                finalStatus = "backlog";
+              }
+              if (feature && args.status === "verified" && feature.skipTests === true) {
                 console.log(`[McpServerFactory] Feature ${args.featureId} has skipTests=true, converting verified -> waiting_approval`);
                 finalStatus = "waiting_approval";
               }
 
-              // Call the provided callback to update feature status with summary
-              await updateFeatureStatusCallback(args.featureId, finalStatus, projectPath, args.summary);
+              // Call the provided callback to update feature status
+              await updateFeatureStatusCallback(
+                args.featureId, 
+                finalStatus, 
+                projectPath, 
+                {
+                  summary: args.summary,
+                  description: args.description,
+                  category: args.category,
+                  steps: args.steps,
+                }
+              );
 
               const statusMessage = finalStatus !== args.status
-                ? `Successfully updated feature ${args.featureId} to status "${finalStatus}" (converted from "${args.status}" because skipTests=true)${args.summary ? ` with summary: "${args.summary}"` : ""}`
-                : `Successfully updated feature ${args.featureId} to status "${finalStatus}"${args.summary ? ` with summary: "${args.summary}"` : ""}`;
+                ? `Successfully created/updated feature ${args.featureId} to status "${finalStatus}" (converted from "${args.status}")${args.summary ? ` - ${args.summary}` : ""}`
+                : `Successfully created/updated feature ${args.featureId} to status "${finalStatus}"${args.summary ? ` - ${args.summary}` : ""}`;
+
+              console.log(`[Feature Creation] ✓ ${statusMessage}`);
 
               return {
                 content: [{
@@ -59,6 +80,7 @@ class McpServerFactory {
               };
             } catch (error) {
               console.error("[McpServerFactory] UpdateFeatureStatus tool error:", error);
+              console.error(`[Feature Creation] ✗ Failed to create/update feature ${args.featureId}: ${error.message}`);
               return {
                 content: [{
                   type: "text",

app/electron/services/mcp-server-stdio.js

@@ -215,7 +215,7 @@ async function handleToolsCall(params, id) {
     // Call the update callback via IPC or direct call
     // Since we're in a separate process, we need to use IPC to communicate back
     // For now, we'll call the feature loader directly since it has the update method
-    await featureLoader.updateFeatureStatus(featureId, finalStatus, projectPath, summary);
+    await featureLoader.updateFeatureStatus(featureId, finalStatus, projectPath, { summary });
 
     const statusMessage = finalStatus !== status
       ? `Successfully updated feature ${featureId} to status "${finalStatus}" (converted from "${status}" because skipTests=true)${summary ? ` with summary: "${summary}"` : ''}`