Merge pull request #94 from AutoMaker-Org/app_spec_fixes

working on improving the app spec page

apps/server/src/index.ts

@@ -27,7 +27,6 @@ import { createGitRoutes } from "./routes/git.js";
 import { createSetupRoutes } from "./routes/setup.js";
 import { createSuggestionsRoutes } from "./routes/suggestions.js";
 import { createModelsRoutes } from "./routes/models.js";
-import { createSpecRegenerationRoutes } from "./routes/spec-regeneration.js";
 import { createRunningAgentsRoutes } from "./routes/running-agents.js";
 import { createWorkspaceRoutes } from "./routes/workspace.js";
 import { createTemplatesRoutes } from "./routes/templates.js";
@@ -41,6 +40,7 @@ import { AgentService } from "./services/agent-service.js";
 import { FeatureLoader } from "./services/feature-loader.js";
 import { AutoModeService } from "./services/auto-mode-service.js";
 import { getTerminalService } from "./services/terminal-service.js";
+import { createSpecRegenerationRoutes } from "./routes/app-spec/index.js";
 
 // Load environment variables
 dotenv.config();

apps/server/src/lib/logger.ts

@@ -0,0 +1,74 @@
+/**
+ * Simple logger utility with log levels
+ * Configure via LOG_LEVEL environment variable: error, warn, info, debug
+ * Defaults to 'info' if not set
+ */
+
+export enum LogLevel {
+  ERROR = 0,
+  WARN = 1,
+  INFO = 2,
+  DEBUG = 3,
+}
+
+const LOG_LEVEL_NAMES: Record<string, LogLevel> = {
+  error: LogLevel.ERROR,
+  warn: LogLevel.WARN,
+  info: LogLevel.INFO,
+  debug: LogLevel.DEBUG,
+};
+
+let currentLogLevel: LogLevel = LogLevel.INFO;
+
+// Initialize log level from environment variable
+const envLogLevel = process.env.LOG_LEVEL?.toLowerCase();
+if (envLogLevel && LOG_LEVEL_NAMES[envLogLevel] !== undefined) {
+  currentLogLevel = LOG_LEVEL_NAMES[envLogLevel];
+}
+
+/**
+ * Create a logger instance with a context prefix
+ */
+export function createLogger(context: string) {
+  const prefix = `[${context}]`;
+
+  return {
+    error: (...args: unknown[]): void => {
+      if (currentLogLevel >= LogLevel.ERROR) {
+        console.error(prefix, ...args);
+      }
+    },
+
+    warn: (...args: unknown[]): void => {
+      if (currentLogLevel >= LogLevel.WARN) {
+        console.warn(prefix, ...args);
+      }
+    },
+
+    info: (...args: unknown[]): void => {
+      if (currentLogLevel >= LogLevel.INFO) {
+        console.log(prefix, ...args);
+      }
+    },
+
+    debug: (...args: unknown[]): void => {
+      if (currentLogLevel >= LogLevel.DEBUG) {
+        console.log(prefix, "[DEBUG]", ...args);
+      }
+    },
+  };
+}
+
+/**
+ * Get the current log level
+ */
+export function getLogLevel(): LogLevel {
+  return currentLogLevel;
+}
+
+/**
+ * Set the log level programmatically (useful for testing)
+ */
+export function setLogLevel(level: LogLevel): void {
+  currentLogLevel = level;
+}

apps/server/src/routes/app-spec/common.ts

@@ -0,0 +1,73 @@
+/**
+ * Common utilities and state management for spec regeneration
+ */
+
+import { createLogger } from "../../lib/logger.js";
+
+const logger = createLogger("SpecRegeneration");
+
+// Shared state for tracking generation status
+export let isRunning = false;
+export let currentAbortController: AbortController | null = null;
+
+/**
+ * Set the running state and abort controller
+ */
+export function setRunningState(
+  running: boolean,
+  controller: AbortController | null = null
+): void {
+  isRunning = running;
+  currentAbortController = controller;
+}
+
+/**
+ * Helper to log authentication status
+ */
+export function logAuthStatus(context: string): void {
+  const hasOAuthToken = !!process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
+
+  logger.info(`${context} - Auth Status:`);
+  logger.info(
+    `  CLAUDE_CODE_OAUTH_TOKEN: ${
+      hasOAuthToken
+        ? "SET (" +
+          process.env.CLAUDE_CODE_OAUTH_TOKEN?.substring(0, 20) +
+          "...)"
+        : "NOT SET"
+    }`
+  );
+  logger.info(
+    `  ANTHROPIC_API_KEY: ${
+      hasApiKey
+        ? "SET (" + process.env.ANTHROPIC_API_KEY?.substring(0, 20) + "...)"
+        : "NOT SET"
+    }`
+  );
+
+  if (!hasOAuthToken && !hasApiKey) {
+    logger.warn("⚠️  WARNING: No authentication configured! SDK will fail.");
+  }
+}
+
+/**
+ * Log error details consistently
+ */
+export function logError(error: unknown, context: string): void {
+  logger.error(`❌ ${context}:`);
+  logger.error("Error name:", (error as any)?.name);
+  logger.error("Error message:", (error as Error)?.message);
+  logger.error("Error stack:", (error as Error)?.stack);
+  logger.error(
+    "Full error object:",
+    JSON.stringify(error, Object.getOwnPropertyNames(error), 2)
+  );
+}
+
+/**
+ * Get error message from error object
+ */
+export function getErrorMessage(error: unknown): string {
+  return error instanceof Error ? error.message : "Unknown error";
+}

apps/server/src/routes/app-spec/generate-features-from-spec.ts

@@ -0,0 +1,154 @@
+/**
+ * Generate features from existing app_spec.txt
+ */
+
+import { query, type Options } from "@anthropic-ai/claude-agent-sdk";
+import path from "path";
+import fs from "fs/promises";
+import type { EventEmitter } from "../../lib/events.js";
+import { createLogger } from "../../lib/logger.js";
+import { logAuthStatus } from "./common.js";
+import { parseAndCreateFeatures } from "./parse-and-create-features.js";
+
+const logger = createLogger("SpecRegeneration");
+
+export async function generateFeaturesFromSpec(
+  projectPath: string,
+  events: EventEmitter,
+  abortController: AbortController
+): Promise<void> {
+  logger.debug("========== generateFeaturesFromSpec() started ==========");
+  logger.debug("projectPath:", projectPath);
+
+  // Read existing spec
+  const specPath = path.join(projectPath, ".automaker", "app_spec.txt");
+  let spec: string;
+
+  logger.debug("Reading spec from:", specPath);
+
+  try {
+    spec = await fs.readFile(specPath, "utf-8");
+    logger.info(`Spec loaded successfully (${spec.length} chars)`);
+  } catch (readError) {
+    logger.error("❌ Failed to read spec file:", readError);
+    events.emit("spec-regeneration:event", {
+      type: "spec_regeneration_error",
+      error: "No project spec found. Generate spec first.",
+      projectPath: projectPath,
+    });
+    return;
+  }
+
+  const prompt = `Based on this project specification:
+
+${spec}
+
+Generate a prioritized list of implementable features. For each feature provide:
+
+1. **id**: A unique lowercase-hyphenated identifier
+2. **title**: Short descriptive title
+3. **description**: What this feature does (2-3 sentences)
+4. **priority**: 1 (high), 2 (medium), or 3 (low)
+5. **complexity**: "simple", "moderate", or "complex"
+6. **dependencies**: Array of feature IDs this depends on (can be empty)
+
+Format as JSON:
+{
+  "features": [
+    {
+      "id": "feature-id",
+      "title": "Feature Title",
+      "description": "What it does",
+      "priority": 1,
+      "complexity": "moderate",
+      "dependencies": []
+    }
+  ]
+}
+
+Generate 5-15 features that build on each other logically.`;
+
+  logger.debug("Prompt length:", `${prompt.length} chars`);
+
+  events.emit("spec-regeneration:event", {
+    type: "spec_regeneration_progress",
+    content: "Analyzing spec and generating features...\n",
+    projectPath: projectPath,
+  });
+
+  const options: Options = {
+    model: "claude-sonnet-4-20250514",
+    maxTurns: 5,
+    cwd: projectPath,
+    allowedTools: ["Read", "Glob"],
+    permissionMode: "acceptEdits",
+    abortController,
+  };
+
+  logger.debug("SDK Options:", JSON.stringify(options, null, 2));
+  logger.info("Calling Claude Agent SDK query() for features...");
+
+  logAuthStatus("Right before SDK query() for features");
+
+  let stream;
+  try {
+    stream = query({ prompt, options });
+    logger.debug("query() returned stream successfully");
+  } catch (queryError) {
+    logger.error("❌ query() threw an exception:");
+    logger.error("Error:", queryError);
+    throw queryError;
+  }
+
+  let responseText = "";
+  let messageCount = 0;
+
+  logger.debug("Starting to iterate over feature stream...");
+
+  try {
+    for await (const msg of stream) {
+      messageCount++;
+      logger.debug(
+        `Feature stream message #${messageCount}:`,
+        JSON.stringify(
+          { type: msg.type, subtype: (msg as any).subtype },
+          null,
+          2
+        )
+      );
+
+      if (msg.type === "assistant" && msg.message.content) {
+        for (const block of msg.message.content) {
+          if (block.type === "text") {
+            responseText = block.text;
+            logger.debug(
+              `Feature text block received (${block.text.length} chars)`
+            );
+            events.emit("spec-regeneration:event", {
+              type: "spec_regeneration_progress",
+              content: block.text,
+              projectPath: projectPath,
+            });
+          }
+        }
+      } else if (msg.type === "result" && (msg as any).subtype === "success") {
+        logger.debug("Received success result for features");
+        responseText = (msg as any).result || responseText;
+      } else if ((msg as { type: string }).type === "error") {
+        logger.error("❌ Received error message from feature stream:");
+        logger.error("Error message:", JSON.stringify(msg, null, 2));
+      }
+    }
+  } catch (streamError) {
+    logger.error("❌ Error while iterating feature stream:");
+    logger.error("Stream error:", streamError);
+    throw streamError;
+  }
+
+  logger.info(`Feature stream complete. Total messages: ${messageCount}`);
+  logger.info(`Feature response length: ${responseText.length} chars`);
+
+  await parseAndCreateFeatures(projectPath, responseText, events);
+
+  logger.debug("========== generateFeaturesFromSpec() completed ==========");
+}

apps/server/src/routes/app-spec/generate-spec.ts

@@ -0,0 +1,203 @@
+/**
+ * Generate app_spec.txt from project overview
+ */
+
+import { query, type Options } from "@anthropic-ai/claude-agent-sdk";
+import path from "path";
+import fs from "fs/promises";
+import type { EventEmitter } from "../../lib/events.js";
+import { getAppSpecFormatInstruction } from "../../lib/app-spec-format.js";
+import { createLogger } from "../../lib/logger.js";
+import { logAuthStatus } from "./common.js";
+import { generateFeaturesFromSpec } from "./generate-features-from-spec.js";
+
+const logger = createLogger("SpecRegeneration");
+
+export async function generateSpec(
+  projectPath: string,
+  projectOverview: string,
+  events: EventEmitter,
+  abortController: AbortController,
+  generateFeatures?: boolean,
+  analyzeProject?: boolean
+): Promise<void> {
+  logger.debug("========== generateSpec() started ==========");
+  logger.debug("projectPath:", projectPath);
+  logger.debug("projectOverview length:", `${projectOverview.length} chars`);
+  logger.debug("generateFeatures:", generateFeatures);
+  logger.debug("analyzeProject:", analyzeProject);
+
+  // Build the prompt based on whether we should analyze the project
+  let analysisInstructions = "";
+  let techStackDefaults = "";
+
+  if (analyzeProject !== false) {
+    // Default to true - analyze the project
+    analysisInstructions = `Based on this overview, analyze the project directory (if it exists) and create a comprehensive specification. Use the Read, Glob, and Grep tools to explore the codebase and understand:
+- Existing technologies and frameworks
+- Project structure and architecture
+- Current features and capabilities
+- Code patterns and conventions`;
+  } else {
+    // Use default tech stack
+    techStackDefaults = `Default Technology Stack:
+- Framework: TanStack Start (React-based full-stack framework)
+- Database: PostgreSQL with Drizzle ORM
+- UI Components: shadcn/ui
+- Styling: Tailwind CSS
+- Frontend: React
+
+Use these technologies as the foundation for the specification.`;
+  }
+
+  const prompt = `You are helping to define a software project specification.
+
+IMPORTANT: Never ask for clarification or additional information. Use the information provided and make reasonable assumptions to create the best possible specification. If details are missing, infer them based on common patterns and best practices.
+
+Project Overview:
+${projectOverview}
+
+${techStackDefaults}
+
+${analysisInstructions}
+
+${getAppSpecFormatInstruction()}`;
+
+  logger.debug("Prompt length:", `${prompt.length} chars`);
+
+  events.emit("spec-regeneration:event", {
+    type: "spec_progress",
+    content: "Starting spec generation...\n",
+  });
+
+  const options: Options = {
+    model: "claude-opus-4-5-20251101",
+    maxTurns: 10,
+    cwd: projectPath,
+    allowedTools: ["Read", "Glob", "Grep"],
+    permissionMode: "acceptEdits",
+    abortController,
+  };
+
+  logger.debug("SDK Options:", JSON.stringify(options, null, 2));
+  logger.info("Calling Claude Agent SDK query()...");
+
+  // Log auth status right before the SDK call
+  logAuthStatus("Right before SDK query()");
+
+  let stream;
+  try {
+    stream = query({ prompt, options });
+    logger.debug("query() returned stream successfully");
+  } catch (queryError) {
+    logger.error("❌ query() threw an exception:");
+    logger.error("Error:", queryError);
+    throw queryError;
+  }
+
+  let responseText = "";
+  let messageCount = 0;
+
+  logger.debug("Starting to iterate over stream...");
+
+  try {
+    for await (const msg of stream) {
+      messageCount++;
+      logger.debug(
+        `Stream message #${messageCount}:`,
+        JSON.stringify(
+          { type: msg.type, subtype: (msg as any).subtype },
+          null,
+          2
+        )
+      );
+
+      if (msg.type === "assistant" && msg.message.content) {
+        for (const block of msg.message.content) {
+          if (block.type === "text") {
+            responseText += block.text;
+            logger.debug(`Text block received (${block.text.length} chars)`);
+            events.emit("spec-regeneration:event", {
+              type: "spec_regeneration_progress",
+              content: block.text,
+              projectPath: projectPath,
+            });
+          } else if (block.type === "tool_use") {
+            logger.debug("Tool use:", block.name);
+            events.emit("spec-regeneration:event", {
+              type: "spec_tool",
+              tool: block.name,
+              input: block.input,
+            });
+          }
+        }
+      } else if (msg.type === "result" && (msg as any).subtype === "success") {
+        logger.debug("Received success result");
+        responseText = (msg as any).result || responseText;
+      } else if ((msg as { type: string }).type === "error") {
+        logger.error("❌ Received error message from stream:");
+        logger.error("Error message:", JSON.stringify(msg, null, 2));
+      }
+    }
+  } catch (streamError) {
+    logger.error("❌ Error while iterating stream:");
+    logger.error("Stream error:", streamError);
+    throw streamError;
+  }
+
+  logger.info(`Stream iteration complete. Total messages: ${messageCount}`);
+  logger.info(`Response text length: ${responseText.length} chars`);
+
+  // Save spec
+  const specDir = path.join(projectPath, ".automaker");
+  const specPath = path.join(specDir, "app_spec.txt");
+
+  logger.info("Saving spec to:", specPath);
+
+  await fs.mkdir(specDir, { recursive: true });
+  await fs.writeFile(specPath, responseText);
+
+  logger.info("Spec saved successfully");
+
+  // Emit spec completion event
+  if (generateFeatures) {
+    // If features will be generated, emit intermediate completion
+    events.emit("spec-regeneration:event", {
+      type: "spec_regeneration_progress",
+      content: "[Phase: spec_complete] Spec created! Generating features...\n",
+      projectPath: projectPath,
+    });
+  } else {
+    // If no features, emit final completion
+    events.emit("spec-regeneration:event", {
+      type: "spec_regeneration_complete",
+      message: "Spec regeneration complete!",
+      projectPath: projectPath,
+    });
+  }
+
+  // If generate features was requested, generate them from the spec
+  if (generateFeatures) {
+    logger.info("Starting feature generation from spec...");
+    // Create a new abort controller for feature generation
+    const featureAbortController = new AbortController();
+    try {
+      await generateFeaturesFromSpec(
+        projectPath,
+        events,
+        featureAbortController
+      );
+      // Final completion will be emitted by generateFeaturesFromSpec -> parseAndCreateFeatures
+    } catch (featureError) {
+      logger.error("Feature generation failed:", featureError);
+      // Don't throw - spec generation succeeded, feature generation is optional
+      events.emit("spec-regeneration:event", {
+        type: "spec_regeneration_error",
+        error: (featureError as Error).message || "Feature generation failed",
+        projectPath: projectPath,
+      });
+    }
+  }
+
+  logger.debug("========== generateSpec() completed ==========");
+}

apps/server/src/routes/app-spec/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Spec Regeneration routes - HTTP API for AI-powered spec generation
+ */
+
+import { Router } from "express";
+import type { EventEmitter } from "../../lib/events.js";
+import { createCreateHandler } from "./routes/create.js";
+import { createGenerateHandler } from "./routes/generate.js";
+import { createGenerateFeaturesHandler } from "./routes/generate-features.js";
+import { createStopHandler } from "./routes/stop.js";
+import { createStatusHandler } from "./routes/status.js";
+
+export function createSpecRegenerationRoutes(events: EventEmitter): Router {
+  const router = Router();
+
+  router.post("/create", createCreateHandler(events));
+  router.post("/generate", createGenerateHandler(events));
+  router.post("/generate-features", createGenerateFeaturesHandler(events));
+  router.post("/stop", createStopHandler());
+  router.get("/status", createStatusHandler());
+
+  return router;
+}

apps/server/src/routes/app-spec/parse-and-create-features.ts

@@ -0,0 +1,83 @@
+/**
+ * Parse agent response and create feature files
+ */
+
+import path from "path";
+import fs from "fs/promises";
+import type { EventEmitter } from "../../lib/events.js";
+import { createLogger } from "../../lib/logger.js";
+
+const logger = createLogger("SpecRegeneration");
+
+export async function parseAndCreateFeatures(
+  projectPath: string,
+  content: string,
+  events: EventEmitter
+): Promise<void> {
+  logger.debug("========== parseAndCreateFeatures() started ==========");
+  logger.debug("Content length:", `${content.length} chars`);
+
+  try {
+    // Extract JSON from response
+    logger.debug("Extracting JSON from response...");
+    const jsonMatch = content.match(/\{[\s\S]*"features"[\s\S]*\}/);
+    if (!jsonMatch) {
+      logger.error("❌ No valid JSON found in response");
+      logger.error("Content preview:", content.substring(0, 500));
+      throw new Error("No valid JSON found in response");
+    }
+
+    logger.debug(`JSON match found (${jsonMatch[0].length} chars)`);
+
+    const parsed = JSON.parse(jsonMatch[0]);
+    logger.info(`Parsed ${parsed.features?.length || 0} features`);
+
+    const featuresDir = path.join(projectPath, ".automaker", "features");
+    await fs.mkdir(featuresDir, { recursive: true });
+
+    const createdFeatures: Array<{ id: string; title: string }> = [];
+
+    for (const feature of parsed.features) {
+      logger.debug("Creating feature:", feature.id);
+      const featureDir = path.join(featuresDir, feature.id);
+      await fs.mkdir(featureDir, { recursive: true });
+
+      const featureData = {
+        id: feature.id,
+        title: feature.title,
+        description: feature.description,
+        status: "backlog", // Features go to backlog - user must manually start them
+        priority: feature.priority || 2,
+        complexity: feature.complexity || "moderate",
+        dependencies: feature.dependencies || [],
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      };
+
+      await fs.writeFile(
+        path.join(featureDir, "feature.json"),
+        JSON.stringify(featureData, null, 2)
+      );
+
+      createdFeatures.push({ id: feature.id, title: feature.title });
+    }
+
+    logger.info(`✓ Created ${createdFeatures.length} features successfully`);
+
+    events.emit("spec-regeneration:event", {
+      type: "spec_regeneration_complete",
+      message: `Spec regeneration complete! Created ${createdFeatures.length} features.`,
+      projectPath: projectPath,
+    });
+  } catch (error) {
+    logger.error("❌ parseAndCreateFeatures() failed:");
+    logger.error("Error:", error);
+    events.emit("spec-regeneration:event", {
+      type: "spec_regeneration_error",
+      error: (error as Error).message,
+      projectPath: projectPath,
+    });
+  }
+
+  logger.debug("========== parseAndCreateFeatures() completed ==========");
+}

apps/server/src/routes/app-spec/routes/create.ts

@@ -0,0 +1,95 @@
+/**
+ * POST /create endpoint - Create project spec from overview
+ */
+
+import type { Request, Response } from "express";
+import type { EventEmitter } from "../../../lib/events.js";
+import { createLogger } from "../../../lib/logger.js";
+import {
+  isRunning,
+  setRunningState,
+  logAuthStatus,
+  logError,
+  getErrorMessage,
+} from "../common.js";
+import { generateSpec } from "../generate-spec.js";
+
+const logger = createLogger("SpecRegeneration");
+
+export function createCreateHandler(events: EventEmitter) {
+  return async (req: Request, res: Response): Promise<void> => {
+    logger.info("========== /create endpoint called ==========");
+    logger.debug("Request body:", JSON.stringify(req.body, null, 2));
+
+    try {
+      const { projectPath, projectOverview, generateFeatures, analyzeProject } =
+        req.body as {
+          projectPath: string;
+          projectOverview: string;
+          generateFeatures?: boolean;
+          analyzeProject?: boolean;
+        };
+
+      logger.debug("Parsed params:");
+      logger.debug("  projectPath:", projectPath);
+      logger.debug(
+        "  projectOverview length:",
+        `${projectOverview?.length || 0} chars`
+      );
+      logger.debug("  generateFeatures:", generateFeatures);
+      logger.debug("  analyzeProject:", analyzeProject);
+
+      if (!projectPath || !projectOverview) {
+        logger.error("Missing required parameters");
+        res.status(400).json({
+          success: false,
+          error: "projectPath and projectOverview required",
+        });
+        return;
+      }
+
+      if (isRunning) {
+        logger.warn("Generation already running, rejecting request");
+        res.json({ success: false, error: "Spec generation already running" });
+        return;
+      }
+
+      logAuthStatus("Before starting generation");
+
+      const abortController = new AbortController();
+      setRunningState(true, abortController);
+      logger.info("Starting background generation task...");
+
+      // Start generation in background
+      generateSpec(
+        projectPath,
+        projectOverview,
+        events,
+        abortController,
+        generateFeatures,
+        analyzeProject
+      )
+        .catch((error) => {
+          logError(error, "Generation failed with error");
+          events.emit("spec-regeneration:event", {
+            type: "spec_regeneration_error",
+            error: getErrorMessage(error),
+            projectPath: projectPath,
+          });
+        })
+        .finally(() => {
+          logger.info("Generation task finished (success or error)");
+          setRunningState(false, null);
+        });
+
+      logger.info(
+        "Returning success response (generation running in background)"
+      );
+      res.json({ success: true });
+    } catch (error) {
+      logger.error("❌ Route handler exception:");
+      logger.error("Error:", error);
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/app-spec/routes/generate-features.ts

@@ -0,0 +1,70 @@
+/**
+ * POST /generate-features endpoint - Generate features from existing spec
+ */
+
+import type { Request, Response } from "express";
+import type { EventEmitter } from "../../../lib/events.js";
+import { createLogger } from "../../../lib/logger.js";
+import {
+  isRunning,
+  setRunningState,
+  logAuthStatus,
+  logError,
+  getErrorMessage,
+} from "../common.js";
+import { generateFeaturesFromSpec } from "../generate-features-from-spec.js";
+
+const logger = createLogger("SpecRegeneration");
+
+export function createGenerateFeaturesHandler(events: EventEmitter) {
+  return async (req: Request, res: Response): Promise<void> => {
+    logger.info("========== /generate-features endpoint called ==========");
+    logger.debug("Request body:", JSON.stringify(req.body, null, 2));
+
+    try {
+      const { projectPath } = req.body as { projectPath: string };
+
+      logger.debug("projectPath:", projectPath);
+
+      if (!projectPath) {
+        logger.error("Missing projectPath parameter");
+        res.status(400).json({ success: false, error: "projectPath required" });
+        return;
+      }
+
+      if (isRunning) {
+        logger.warn("Generation already running, rejecting request");
+        res.json({ success: false, error: "Generation already running" });
+        return;
+      }
+
+      logAuthStatus("Before starting feature generation");
+
+      const abortController = new AbortController();
+      setRunningState(true, abortController);
+      logger.info("Starting background feature generation task...");
+
+      generateFeaturesFromSpec(projectPath, events, abortController)
+        .catch((error) => {
+          logError(error, "Feature generation failed with error");
+          events.emit("spec-regeneration:event", {
+            type: "features_error",
+            error: getErrorMessage(error),
+          });
+        })
+        .finally(() => {
+          logger.info("Feature generation task finished (success or error)");
+          setRunningState(false, null);
+        });
+
+      logger.info(
+        "Returning success response (generation running in background)"
+      );
+      res.json({ success: true });
+    } catch (error) {
+      logger.error("❌ Route handler exception:");
+      logger.error("Error:", error);
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/app-spec/routes/generate.ts

@@ -0,0 +1,98 @@
+/**
+ * POST /generate endpoint - Generate spec from project definition
+ */
+
+import type { Request, Response } from "express";
+import type { EventEmitter } from "../../../lib/events.js";
+import { createLogger } from "../../../lib/logger.js";
+import {
+  isRunning,
+  setRunningState,
+  logAuthStatus,
+  logError,
+  getErrorMessage,
+} from "../common.js";
+import { generateSpec } from "../generate-spec.js";
+
+const logger = createLogger("SpecRegeneration");
+
+export function createGenerateHandler(events: EventEmitter) {
+  return async (req: Request, res: Response): Promise<void> => {
+    logger.info("========== /generate endpoint called ==========");
+    logger.debug("Request body:", JSON.stringify(req.body, null, 2));
+
+    try {
+      const {
+        projectPath,
+        projectDefinition,
+        generateFeatures,
+        analyzeProject,
+      } = req.body as {
+        projectPath: string;
+        projectDefinition: string;
+        generateFeatures?: boolean;
+        analyzeProject?: boolean;
+      };
+
+      logger.debug("Parsed params:");
+      logger.debug("  projectPath:", projectPath);
+      logger.debug(
+        "  projectDefinition length:",
+        `${projectDefinition?.length || 0} chars`
+      );
+      logger.debug("  generateFeatures:", generateFeatures);
+      logger.debug("  analyzeProject:", analyzeProject);
+
+      if (!projectPath || !projectDefinition) {
+        logger.error("Missing required parameters");
+        res.status(400).json({
+          success: false,
+          error: "projectPath and projectDefinition required",
+        });
+        return;
+      }
+
+      if (isRunning) {
+        logger.warn("Generation already running, rejecting request");
+        res.json({ success: false, error: "Spec generation already running" });
+        return;
+      }
+
+      logAuthStatus("Before starting generation");
+
+      const abortController = new AbortController();
+      setRunningState(true, abortController);
+      logger.info("Starting background generation task...");
+
+      generateSpec(
+        projectPath,
+        projectDefinition,
+        events,
+        abortController,
+        generateFeatures,
+        analyzeProject
+      )
+        .catch((error) => {
+          logError(error, "Generation failed with error");
+          events.emit("spec-regeneration:event", {
+            type: "spec_regeneration_error",
+            error: getErrorMessage(error),
+            projectPath: projectPath,
+          });
+        })
+        .finally(() => {
+          logger.info("Generation task finished (success or error)");
+          setRunningState(false, null);
+        });
+
+      logger.info(
+        "Returning success response (generation running in background)"
+      );
+      res.json({ success: true });
+    } catch (error) {
+      logger.error("❌ Route handler exception:");
+      logger.error("Error:", error);
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/app-spec/routes/status.ts

@@ -0,0 +1,16 @@
+/**
+ * GET /status endpoint - Get generation status
+ */
+
+import type { Request, Response } from "express";
+import { isRunning, getErrorMessage } from "../common.js";
+
+export function createStatusHandler() {
+  return async (_req: Request, res: Response): Promise<void> => {
+    try {
+      res.json({ success: true, isRunning });
+    } catch (error) {
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/app-spec/routes/stop.ts

@@ -0,0 +1,24 @@
+/**
+ * POST /stop endpoint - Stop generation
+ */
+
+import type { Request, Response } from "express";
+import {
+  currentAbortController,
+  setRunningState,
+  getErrorMessage,
+} from "../common.js";
+
+export function createStopHandler() {
+  return async (_req: Request, res: Response): Promise<void> => {
+    try {
+      if (currentAbortController) {
+        currentAbortController.abort();
+      }
+      setRunningState(false, null);
+      res.json({ success: true });
+    } catch (error) {
+      res.status(500).json({ success: false, error: getErrorMessage(error) });
+    }
+  };
+}

apps/server/src/routes/spec-regeneration.ts

@@ -1,764 +0,0 @@
-/**
- * Spec Regeneration routes - HTTP API for AI-powered spec generation
- */
-
-import { Router, type Request, type Response } from "express";
-import { query, type Options } from "@anthropic-ai/claude-agent-sdk";
-import path from "path";
-import fs from "fs/promises";
-import type { EventEmitter } from "../lib/events.js";
-import { getAppSpecFormatInstruction } from "../lib/app-spec-format.js";
-
-let isRunning = false;
-let currentAbortController: AbortController | null = null;
-
-// Helper to log authentication status
-function logAuthStatus(context: string): void {
-  const hasOAuthToken = !!process.env.CLAUDE_CODE_OAUTH_TOKEN;
-  const hasApiKey = !!process.env.ANTHROPIC_API_KEY;
-
-  console.log(`[SpecRegeneration] ${context} - Auth Status:`);
-  console.log(
-    `[SpecRegeneration]   CLAUDE_CODE_OAUTH_TOKEN: ${
-      hasOAuthToken
-        ? "SET (" +
-          process.env.CLAUDE_CODE_OAUTH_TOKEN?.substring(0, 20) +
-          "...)"
-        : "NOT SET"
-    }`
-  );
-  console.log(
-    `[SpecRegeneration]   ANTHROPIC_API_KEY: ${
-      hasApiKey
-        ? "SET (" + process.env.ANTHROPIC_API_KEY?.substring(0, 20) + "...)"
-        : "NOT SET"
-    }`
-  );
-
-  if (!hasOAuthToken && !hasApiKey) {
-    console.error(
-      `[SpecRegeneration] ⚠️  WARNING: No authentication configured! SDK will fail.`
-    );
-  }
-}
-
-export function createSpecRegenerationRoutes(events: EventEmitter): Router {
-  const router = Router();
-
-  // Create project spec from overview
-  router.post("/create", async (req: Request, res: Response) => {
-    console.log(
-      "[SpecRegeneration] ========== /create endpoint called =========="
-    );
-    console.log(
-      "[SpecRegeneration] Request body:",
-      JSON.stringify(req.body, null, 2)
-    );
-
-    try {
-      const { projectPath, projectOverview, generateFeatures } = req.body as {
-        projectPath: string;
-        projectOverview: string;
-        generateFeatures?: boolean;
-      };
-
-      console.log(`[SpecRegeneration] Parsed params:`);
-      console.log(`[SpecRegeneration]   projectPath: ${projectPath}`);
-      console.log(
-        `[SpecRegeneration]   projectOverview length: ${
-          projectOverview?.length || 0
-        } chars`
-      );
-      console.log(`[SpecRegeneration]   generateFeatures: ${generateFeatures}`);
-
-      if (!projectPath || !projectOverview) {
-        console.error("[SpecRegeneration] Missing required parameters");
-        res.status(400).json({
-          success: false,
-          error: "projectPath and projectOverview required",
-        });
-        return;
-      }
-
-      if (isRunning) {
-        console.warn(
-          "[SpecRegeneration] Generation already running, rejecting request"
-        );
-        res.json({ success: false, error: "Spec generation already running" });
-        return;
-      }
-
-      logAuthStatus("Before starting generation");
-
-      isRunning = true;
-      currentAbortController = new AbortController();
-      console.log("[SpecRegeneration] Starting background generation task...");
-
-      // Start generation in background
-      generateSpec(
-        projectPath,
-        projectOverview,
-        events,
-        currentAbortController,
-        generateFeatures
-      )
-        .catch((error) => {
-          console.error("[SpecRegeneration] ❌ Generation failed with error:");
-          console.error("[SpecRegeneration] Error name:", error?.name);
-          console.error("[SpecRegeneration] Error message:", error?.message);
-          console.error("[SpecRegeneration] Error stack:", error?.stack);
-          console.error(
-            "[SpecRegeneration] Full error object:",
-            JSON.stringify(error, Object.getOwnPropertyNames(error), 2)
-          );
-          events.emit("spec-regeneration:event", {
-            type: "spec_regeneration_error",
-            error: error.message || String(error),
-            projectPath: projectPath,
-          });
-        })
-        .finally(() => {
-          console.log(
-            "[SpecRegeneration] Generation task finished (success or error)"
-          );
-          isRunning = false;
-          currentAbortController = null;
-        });
-
-      console.log(
-        "[SpecRegeneration] Returning success response (generation running in background)"
-      );
-      res.json({ success: true });
-    } catch (error) {
-      console.error("[SpecRegeneration] ❌ Route handler exception:");
-      console.error("[SpecRegeneration] Error:", error);
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
-    }
-  });
-
-  // Generate from project definition
-  router.post("/generate", async (req: Request, res: Response) => {
-    console.log(
-      "[SpecRegeneration] ========== /generate endpoint called =========="
-    );
-    console.log(
-      "[SpecRegeneration] Request body:",
-      JSON.stringify(req.body, null, 2)
-    );
-
-    try {
-      const { projectPath, projectDefinition } = req.body as {
-        projectPath: string;
-        projectDefinition: string;
-      };
-
-      console.log(`[SpecRegeneration] Parsed params:`);
-      console.log(`[SpecRegeneration]   projectPath: ${projectPath}`);
-      console.log(
-        `[SpecRegeneration]   projectDefinition length: ${
-          projectDefinition?.length || 0
-        } chars`
-      );
-
-      if (!projectPath || !projectDefinition) {
-        console.error("[SpecRegeneration] Missing required parameters");
-        res.status(400).json({
-          success: false,
-          error: "projectPath and projectDefinition required",
-        });
-        return;
-      }
-
-      if (isRunning) {
-        console.warn(
-          "[SpecRegeneration] Generation already running, rejecting request"
-        );
-        res.json({ success: false, error: "Spec generation already running" });
-        return;
-      }
-
-      logAuthStatus("Before starting generation");
-
-      isRunning = true;
-      currentAbortController = new AbortController();
-      console.log("[SpecRegeneration] Starting background generation task...");
-
-      generateSpec(
-        projectPath,
-        projectDefinition,
-        events,
-        currentAbortController,
-        false
-      )
-        .catch((error) => {
-          console.error("[SpecRegeneration] ❌ Generation failed with error:");
-          console.error("[SpecRegeneration] Error name:", error?.name);
-          console.error("[SpecRegeneration] Error message:", error?.message);
-          console.error("[SpecRegeneration] Error stack:", error?.stack);
-          console.error(
-            "[SpecRegeneration] Full error object:",
-            JSON.stringify(error, Object.getOwnPropertyNames(error), 2)
-          );
-          events.emit("spec-regeneration:event", {
-            type: "spec_regeneration_error",
-            error: error.message || String(error),
-            projectPath: projectPath,
-          });
-        })
-        .finally(() => {
-          console.log(
-            "[SpecRegeneration] Generation task finished (success or error)"
-          );
-          isRunning = false;
-          currentAbortController = null;
-        });
-
-      console.log(
-        "[SpecRegeneration] Returning success response (generation running in background)"
-      );
-      res.json({ success: true });
-    } catch (error) {
-      console.error("[SpecRegeneration] ❌ Route handler exception:");
-      console.error("[SpecRegeneration] Error:", error);
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
-    }
-  });
-
-  // Generate features from existing spec
-  router.post("/generate-features", async (req: Request, res: Response) => {
-    console.log(
-      "[SpecRegeneration] ========== /generate-features endpoint called =========="
-    );
-    console.log(
-      "[SpecRegeneration] Request body:",
-      JSON.stringify(req.body, null, 2)
-    );
-
-    try {
-      const { projectPath } = req.body as { projectPath: string };
-
-      console.log(`[SpecRegeneration] projectPath: ${projectPath}`);
-
-      if (!projectPath) {
-        console.error("[SpecRegeneration] Missing projectPath parameter");
-        res.status(400).json({ success: false, error: "projectPath required" });
-        return;
-      }
-
-      if (isRunning) {
-        console.warn(
-          "[SpecRegeneration] Generation already running, rejecting request"
-        );
-        res.json({ success: false, error: "Generation already running" });
-        return;
-      }
-
-      logAuthStatus("Before starting feature generation");
-
-      isRunning = true;
-      currentAbortController = new AbortController();
-      console.log(
-        "[SpecRegeneration] Starting background feature generation task..."
-      );
-
-      generateFeaturesFromSpec(projectPath, events, currentAbortController)
-        .catch((error) => {
-          console.error(
-            "[SpecRegeneration] ❌ Feature generation failed with error:"
-          );
-          console.error("[SpecRegeneration] Error name:", error?.name);
-          console.error("[SpecRegeneration] Error message:", error?.message);
-          console.error("[SpecRegeneration] Error stack:", error?.stack);
-          console.error(
-            "[SpecRegeneration] Full error object:",
-            JSON.stringify(error, Object.getOwnPropertyNames(error), 2)
-          );
-          events.emit("spec-regeneration:event", {
-            type: "features_error",
-            error: error.message || String(error),
-          });
-        })
-        .finally(() => {
-          console.log(
-            "[SpecRegeneration] Feature generation task finished (success or error)"
-          );
-          isRunning = false;
-          currentAbortController = null;
-        });
-
-      console.log(
-        "[SpecRegeneration] Returning success response (generation running in background)"
-      );
-      res.json({ success: true });
-    } catch (error) {
-      console.error("[SpecRegeneration] ❌ Route handler exception:");
-      console.error("[SpecRegeneration] Error:", error);
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
-    }
-  });
-
-  // Stop generation
-  router.post("/stop", async (_req: Request, res: Response) => {
-    try {
-      if (currentAbortController) {
-        currentAbortController.abort();
-      }
-      isRunning = false;
-      res.json({ success: true });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
-    }
-  });
-
-  // Get status
-  router.get("/status", async (_req: Request, res: Response) => {
-    try {
-      res.json({ success: true, isRunning });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : "Unknown error";
-      res.status(500).json({ success: false, error: message });
-    }
-  });
-
-  return router;
-}
-
-async function generateSpec(
-  projectPath: string,
-  projectOverview: string,
-  events: EventEmitter,
-  abortController: AbortController,
-  generateFeatures?: boolean
-) {
-  console.log(
-    "[SpecRegeneration] ========== generateSpec() started =========="
-  );
-  console.log(`[SpecRegeneration] projectPath: ${projectPath}`);
-  console.log(
-    `[SpecRegeneration] projectOverview length: ${projectOverview.length} chars`
-  );
-  console.log(`[SpecRegeneration] generateFeatures: ${generateFeatures}`);
-
-  const prompt = `You are helping to define a software project specification.
-
-Project Overview:
-${projectOverview}
-
-Based on this overview, analyze the project directory (if it exists) and create a comprehensive specification. Use the Read, Glob, and Grep tools to explore the codebase and understand:
-- Existing technologies and frameworks
-- Project structure and architecture
-- Current features and capabilities
-- Code patterns and conventions
-
-${getAppSpecFormatInstruction()}`;
-
-  console.log(`[SpecRegeneration] Prompt length: ${prompt.length} chars`);
-
-  events.emit("spec-regeneration:event", {
-    type: "spec_progress",
-    content: "Starting spec generation...\n",
-  });
-
-  const options: Options = {
-    model: "claude-opus-4-5-20251101",
-    maxTurns: 10,
-    cwd: projectPath,
-    allowedTools: ["Read", "Glob", "Grep"],
-    permissionMode: "acceptEdits",
-    abortController,
-  };
-
-  console.log(
-    "[SpecRegeneration] SDK Options:",
-    JSON.stringify(options, null, 2)
-  );
-  console.log("[SpecRegeneration] Calling Claude Agent SDK query()...");
-
-  // Log auth status right before the SDK call
-  logAuthStatus("Right before SDK query()");
-
-  let stream;
-  try {
-    stream = query({ prompt, options });
-    console.log("[SpecRegeneration] query() returned stream successfully");
-  } catch (queryError) {
-    console.error("[SpecRegeneration] ❌ query() threw an exception:");
-    console.error("[SpecRegeneration] Error:", queryError);
-    throw queryError;
-  }
-
-  let responseText = "";
-  let messageCount = 0;
-
-  console.log("[SpecRegeneration] Starting to iterate over stream...");
-
-  try {
-    for await (const msg of stream) {
-      messageCount++;
-      console.log(
-        `[SpecRegeneration] Stream message #${messageCount}:`,
-        JSON.stringify(
-          { type: msg.type, subtype: (msg as any).subtype },
-          null,
-          2
-        )
-      );
-
-      if (msg.type === "assistant" && msg.message.content) {
-        for (const block of msg.message.content) {
-          if (block.type === "text") {
-            responseText = block.text;
-            console.log(
-              `[SpecRegeneration] Text block received (${block.text.length} chars)`
-            );
-            events.emit("spec-regeneration:event", {
-              type: "spec_regeneration_progress",
-              content: block.text,
-              projectPath: projectPath,
-            });
-          } else if (block.type === "tool_use") {
-            console.log(`[SpecRegeneration] Tool use: ${block.name}`);
-            events.emit("spec-regeneration:event", {
-              type: "spec_tool",
-              tool: block.name,
-              input: block.input,
-            });
-          }
-        }
-      } else if (msg.type === "result" && (msg as any).subtype === "success") {
-        console.log("[SpecRegeneration] Received success result");
-        responseText = (msg as any).result || responseText;
-      } else if ((msg as { type: string }).type === "error") {
-        console.error(
-          "[SpecRegeneration] ❌ Received error message from stream:"
-        );
-        console.error(
-          "[SpecRegeneration] Error message:",
-          JSON.stringify(msg, null, 2)
-        );
-      }
-    }
-  } catch (streamError) {
-    console.error("[SpecRegeneration] ❌ Error while iterating stream:");
-    console.error("[SpecRegeneration] Stream error:", streamError);
-    throw streamError;
-  }
-
-  console.log(
-    `[SpecRegeneration] Stream iteration complete. Total messages: ${messageCount}`
-  );
-  console.log(
-    `[SpecRegeneration] Response text length: ${responseText.length} chars`
-  );
-
-  // Save spec
-  const specDir = path.join(projectPath, ".automaker");
-  const specPath = path.join(specDir, "app_spec.txt");
-
-  console.log(`[SpecRegeneration] Saving spec to: ${specPath}`);
-
-  await fs.mkdir(specDir, { recursive: true });
-  await fs.writeFile(specPath, responseText);
-
-  console.log("[SpecRegeneration] Spec saved successfully");
-
-  // Emit spec completion event
-  if (generateFeatures) {
-    // If features will be generated, emit intermediate completion
-    events.emit("spec-regeneration:event", {
-      type: "spec_regeneration_progress",
-      content: "[Phase: spec_complete] Spec created! Generating features...\n",
-      projectPath: projectPath,
-    });
-  } else {
-    // If no features, emit final completion
-    events.emit("spec-regeneration:event", {
-      type: "spec_regeneration_complete",
-      message: "Spec regeneration complete!",
-      projectPath: projectPath,
-    });
-  }
-
-  // If generate features was requested, generate them from the spec
-  if (generateFeatures) {
-    console.log("[SpecRegeneration] Starting feature generation from spec...");
-    // Create a new abort controller for feature generation
-    const featureAbortController = new AbortController();
-    try {
-      await generateFeaturesFromSpec(
-        projectPath,
-        events,
-        featureAbortController
-      );
-      // Final completion will be emitted by generateFeaturesFromSpec -> parseAndCreateFeatures
-    } catch (featureError) {
-      console.error(
-        "[SpecRegeneration] Feature generation failed:",
-        featureError
-      );
-      // Don't throw - spec generation succeeded, feature generation is optional
-      events.emit("spec-regeneration:event", {
-        type: "spec_regeneration_error",
-        error: (featureError as Error).message || "Feature generation failed",
-        projectPath: projectPath,
-      });
-    }
-  }
-
-  console.log(
-    "[SpecRegeneration] ========== generateSpec() completed =========="
-  );
-}
-
-async function generateFeaturesFromSpec(
-  projectPath: string,
-  events: EventEmitter,
-  abortController: AbortController
-) {
-  console.log(
-    "[SpecRegeneration] ========== generateFeaturesFromSpec() started =========="
-  );
-  console.log(`[SpecRegeneration] projectPath: ${projectPath}`);
-
-  // Read existing spec
-  const specPath = path.join(projectPath, ".automaker", "app_spec.txt");
-  let spec: string;
-
-  console.log(`[SpecRegeneration] Reading spec from: ${specPath}`);
-
-  try {
-    spec = await fs.readFile(specPath, "utf-8");
-    console.log(
-      `[SpecRegeneration] Spec loaded successfully (${spec.length} chars)`
-    );
-  } catch (readError) {
-    console.error("[SpecRegeneration] ❌ Failed to read spec file:", readError);
-    events.emit("spec-regeneration:event", {
-      type: "spec_regeneration_error",
-      error: "No project spec found. Generate spec first.",
-      projectPath: projectPath,
-    });
-    return;
-  }
-
-  const prompt = `Based on this project specification:
-
-${spec}
-
-Generate a prioritized list of implementable features. For each feature provide:
-
-1. **id**: A unique lowercase-hyphenated identifier
-2. **title**: Short descriptive title
-3. **description**: What this feature does (2-3 sentences)
-4. **priority**: 1 (high), 2 (medium), or 3 (low)
-5. **complexity**: "simple", "moderate", or "complex"
-6. **dependencies**: Array of feature IDs this depends on (can be empty)
-
-Format as JSON:
-{
-  "features": [
-    {
-      "id": "feature-id",
-      "title": "Feature Title",
-      "description": "What it does",
-      "priority": 1,
-      "complexity": "moderate",
-      "dependencies": []
-    }
-  ]
-}
-
-Generate 5-15 features that build on each other logically.`;
-
-  console.log(`[SpecRegeneration] Prompt length: ${prompt.length} chars`);
-
-  events.emit("spec-regeneration:event", {
-    type: "spec_regeneration_progress",
-    content: "Analyzing spec and generating features...\n",
-    projectPath: projectPath,
-  });
-
-  const options: Options = {
-    model: "claude-sonnet-4-20250514",
-    maxTurns: 5,
-    cwd: projectPath,
-    allowedTools: ["Read", "Glob"],
-    permissionMode: "acceptEdits",
-    abortController,
-  };
-
-  console.log(
-    "[SpecRegeneration] SDK Options:",
-    JSON.stringify(options, null, 2)
-  );
-  console.log(
-    "[SpecRegeneration] Calling Claude Agent SDK query() for features..."
-  );
-
-  logAuthStatus("Right before SDK query() for features");
-
-  let stream;
-  try {
-    stream = query({ prompt, options });
-    console.log("[SpecRegeneration] query() returned stream successfully");
-  } catch (queryError) {
-    console.error("[SpecRegeneration] ❌ query() threw an exception:");
-    console.error("[SpecRegeneration] Error:", queryError);
-    throw queryError;
-  }
-
-  let responseText = "";
-  let messageCount = 0;
-
-  console.log("[SpecRegeneration] Starting to iterate over feature stream...");
-
-  try {
-    for await (const msg of stream) {
-      messageCount++;
-      console.log(
-        `[SpecRegeneration] Feature stream message #${messageCount}:`,
-        JSON.stringify(
-          { type: msg.type, subtype: (msg as any).subtype },
-          null,
-          2
-        )
-      );
-
-      if (msg.type === "assistant" && msg.message.content) {
-        for (const block of msg.message.content) {
-          if (block.type === "text") {
-            responseText = block.text;
-            console.log(
-              `[SpecRegeneration] Feature text block received (${block.text.length} chars)`
-            );
-            events.emit("spec-regeneration:event", {
-              type: "spec_regeneration_progress",
-              content: block.text,
-              projectPath: projectPath,
-            });
-          }
-        }
-      } else if (msg.type === "result" && (msg as any).subtype === "success") {
-        console.log("[SpecRegeneration] Received success result for features");
-        responseText = (msg as any).result || responseText;
-      } else if ((msg as { type: string }).type === "error") {
-        console.error(
-          "[SpecRegeneration] ❌ Received error message from feature stream:"
-        );
-        console.error(
-          "[SpecRegeneration] Error message:",
-          JSON.stringify(msg, null, 2)
-        );
-      }
-    }
-  } catch (streamError) {
-    console.error(
-      "[SpecRegeneration] ❌ Error while iterating feature stream:"
-    );
-    console.error("[SpecRegeneration] Stream error:", streamError);
-    throw streamError;
-  }
-
-  console.log(
-    `[SpecRegeneration] Feature stream complete. Total messages: ${messageCount}`
-  );
-  console.log(
-    `[SpecRegeneration] Feature response length: ${responseText.length} chars`
-  );
-
-  await parseAndCreateFeatures(projectPath, responseText, events);
-
-  console.log(
-    "[SpecRegeneration] ========== generateFeaturesFromSpec() completed =========="
-  );
-}
-
-async function parseAndCreateFeatures(
-  projectPath: string,
-  content: string,
-  events: EventEmitter
-) {
-  console.log(
-    "[SpecRegeneration] ========== parseAndCreateFeatures() started =========="
-  );
-  console.log(`[SpecRegeneration] Content length: ${content.length} chars`);
-
-  try {
-    // Extract JSON from response
-    console.log("[SpecRegeneration] Extracting JSON from response...");
-    const jsonMatch = content.match(/\{[\s\S]*"features"[\s\S]*\}/);
-    if (!jsonMatch) {
-      console.error("[SpecRegeneration] ❌ No valid JSON found in response");
-      console.error(
-        "[SpecRegeneration] Content preview:",
-        content.substring(0, 500)
-      );
-      throw new Error("No valid JSON found in response");
-    }
-
-    console.log(
-      `[SpecRegeneration] JSON match found (${jsonMatch[0].length} chars)`
-    );
-
-    const parsed = JSON.parse(jsonMatch[0]);
-    console.log(
-      `[SpecRegeneration] Parsed ${parsed.features?.length || 0} features`
-    );
-
-    const featuresDir = path.join(projectPath, ".automaker", "features");
-    await fs.mkdir(featuresDir, { recursive: true });
-
-    const createdFeatures: Array<{ id: string; title: string }> = [];
-
-    for (const feature of parsed.features) {
-      console.log(`[SpecRegeneration] Creating feature: ${feature.id}`);
-      const featureDir = path.join(featuresDir, feature.id);
-      await fs.mkdir(featureDir, { recursive: true });
-
-      const featureData = {
-        id: feature.id,
-        title: feature.title,
-        description: feature.description,
-        status: "backlog", // Features go to backlog - user must manually start them
-        priority: feature.priority || 2,
-        complexity: feature.complexity || "moderate",
-        dependencies: feature.dependencies || [],
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-      };
-
-      await fs.writeFile(
-        path.join(featureDir, "feature.json"),
-        JSON.stringify(featureData, null, 2)
-      );
-
-      createdFeatures.push({ id: feature.id, title: feature.title });
-    }
-
-    console.log(
-      `[SpecRegeneration] ✓ Created ${createdFeatures.length} features successfully`
-    );
-
-    events.emit("spec-regeneration:event", {
-      type: "spec_regeneration_complete",
-      message: `Spec regeneration complete! Created ${createdFeatures.length} features.`,
-      projectPath: projectPath,
-    });
-  } catch (error) {
-    console.error("[SpecRegeneration] ❌ parseAndCreateFeatures() failed:");
-    console.error("[SpecRegeneration] Error:", error);
-    events.emit("spec-regeneration:event", {
-      type: "spec_regeneration_error",
-      error: (error as Error).message,
-      projectPath: projectPath,
-    });
-  }
-
-  console.log(
-    "[SpecRegeneration] ========== parseAndCreateFeatures() completed =========="
-  );
-}

apps/server/src/services/auto-mode-service.ts

@@ -1129,7 +1129,7 @@ When done, summarize what you implemented and any notes for the developer.`;
       if (msg.type === "assistant" && msg.message?.content) {
         for (const block of msg.message.content) {
           if (block.type === "text") {
-            responseText = block.text || "";
+            responseText += block.text || "";
 
             // Check for authentication errors in the response
             if (