@evolve.labs/devflow 0.8.0

package/web/app/api/specs/route.ts

@@ -0,0 +1,405 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { promises as fs } from 'fs';
+import path from 'path';
+import {
+  parseUserStory,
+  parseADR,
+  getSpecType,
+  parseFrontmatter,
+  extractTasks,
+} from '@/lib/specsParser';
+import type { Spec, Requirement, DesignDecision, Task } from '@/lib/types';
+
+interface SpecsResponse {
+  specs: Spec[];
+  requirements: Requirement[];
+  decisions: DesignDecision[];
+  tasks: Task[];
+}
+
+/**
+ * GET /api/specs - List all specs from a project
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const searchParams = req.nextUrl.searchParams;
+    const projectPath = searchParams.get('projectPath');
+
+    if (!projectPath) {
+      return NextResponse.json(
+        { error: 'projectPath is required' },
+        { status: 400 }
+      );
+    }
+
+    // Security: Validate path
+    if (projectPath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    const response: SpecsResponse = {
+      specs: [],
+      requirements: [],
+      decisions: [],
+      tasks: [],
+    };
+
+    // Directories to scan for specs
+    const specDirs = [
+      'docs/planning/stories',
+      'docs/planning/specs',
+      'docs/planning',
+      'docs/decisions',
+      '.devflow/specs',
+      '.devflow/stories',
+      'specs',
+      'stories',
+    ];
+
+    for (const dir of specDirs) {
+      const fullPath = path.join(projectPath, dir);
+
+      try {
+        const stat = await fs.stat(fullPath);
+        if (!stat.isDirectory()) continue;
+
+        const files = await fs.readdir(fullPath);
+
+        for (const file of files) {
+          if (!file.endsWith('.md')) continue;
+
+          const filePath = path.join(fullPath, file);
+          const content = await fs.readFile(filePath, 'utf-8');
+          const specType = getSpecType(filePath);
+
+          try {
+            if (specType === 'story' || specType === 'spec') {
+              const { spec, requirement, tasks } = parseUserStory(content, filePath);
+              response.specs.push(spec);
+              response.requirements.push(requirement);
+              response.tasks.push(...tasks);
+            } else if (specType === 'adr') {
+              const { spec, decision } = parseADR(content, filePath);
+              response.specs.push(spec);
+              response.decisions.push(decision);
+            } else {
+              // Generic spec parsing
+              const { frontmatter, body } = parseFrontmatter(content);
+              const titleMatch = body.match(/^#\s+(.+)$/m);
+              const id = file.replace('.md', '');
+
+              const spec: Spec = {
+                id,
+                name: frontmatter.title || titleMatch?.[1] || id,
+                description: body.slice(0, 200).replace(/^#.+\n/, '').trim(),
+                phase: 'requirements',
+                status: 'draft',
+                createdAt: new Date(),
+                updatedAt: new Date(),
+                filePath,
+              };
+
+              response.specs.push(spec);
+              response.tasks.push(...extractTasks(body, id, filePath));
+            }
+          } catch (parseError) {
+            console.error(`Error parsing ${filePath}:`, parseError);
+          }
+        }
+      } catch {
+        // Directory doesn't exist, skip
+      }
+    }
+
+    // Deduplicate by ID
+    response.specs = [...new Map(response.specs.map(s => [s.id, s])).values()];
+    response.requirements = [...new Map(response.requirements.map(r => [r.id, r])).values()];
+    response.decisions = [...new Map(response.decisions.map(d => [d.id, d])).values()];
+    response.tasks = [...new Map(response.tasks.map(t => [t.id, t])).values()];
+
+    return NextResponse.json(response);
+  } catch (error) {
+    console.error('Error loading specs:', error);
+    return NextResponse.json(
+      { error: 'Failed to load specs' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/specs - Create a new spec
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { projectPath, type, title, description, priority, phase } = body;
+
+    if (!projectPath || !type || !title) {
+      return NextResponse.json(
+        { error: 'projectPath, type, and title are required' },
+        { status: 400 }
+      );
+    }
+
+    // Security: Validate path
+    if (projectPath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    // Determine directory based on type
+    let dir: string;
+    let prefix: string;
+    let template: string;
+
+    switch (type) {
+      case 'story':
+        dir = 'docs/planning/stories';
+        prefix = 'US';
+        template = generateStoryTemplate(title, description, priority);
+        break;
+      case 'adr':
+        dir = 'docs/decisions';
+        prefix = 'ADR';
+        template = generateADRTemplate(title, description);
+        break;
+      case 'spec':
+      default:
+        dir = 'docs/planning/specs';
+        prefix = 'SPEC';
+        template = generateSpecTemplate(title, description, phase);
+        break;
+    }
+
+    // Create directory if it doesn't exist
+    const fullDir = path.join(projectPath, dir);
+    await fs.mkdir(fullDir, { recursive: true });
+
+    // Find next ID
+    const files = await fs.readdir(fullDir).catch(() => []);
+    const existingIds = files
+      .filter(f => f.endsWith('.md'))
+      .map(f => {
+        const match = f.match(new RegExp(`${prefix}-(\\d+)`));
+        return match ? parseInt(match[1], 10) : 0;
+      });
+    const nextId = Math.max(0, ...existingIds) + 1;
+
+    // Generate filename
+    const slug = title
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-|-$/g, '')
+      .slice(0, 50);
+    const filename = `${prefix}-${String(nextId).padStart(3, '0')}-${slug}.md`;
+    const filePath = path.join(fullDir, filename);
+
+    // Write file
+    await fs.writeFile(filePath, template, 'utf-8');
+
+    return NextResponse.json({
+      success: true,
+      filePath,
+      id: `${prefix}-${String(nextId).padStart(3, '0')}`,
+    });
+  } catch (error) {
+    console.error('Error creating spec:', error);
+    return NextResponse.json(
+      { error: 'Failed to create spec' },
+      { status: 500 }
+    );
+  }
+}
+
+// Template generators
+function generateStoryTemplate(title: string, description?: string, priority?: string): string {
+  const date = new Date().toISOString().split('T')[0];
+  return `---
+title: "${title}"
+status: draft
+priority: ${priority || 'should'}
+created: ${date}
+---
+
+# ${title}
+
+${description || 'Description of the user story.'}
+
+## User Story
+
+As a [type of user],
+I want [goal/desire],
+So that [benefit].
+
+## Acceptance Criteria
+
+- [ ] Criteria 1
+- [ ] Criteria 2
+- [ ] Criteria 3
+
+## Tasks
+
+- [ ] Task 1
+- [ ] Task 2
+- [ ] Task 3
+
+## Notes
+
+_Additional notes and context._
+`;
+}
+
+function generateADRTemplate(title: string, description?: string): string {
+  const date = new Date().toISOString().split('T')[0];
+  return `---
+title: "${title}"
+status: proposed
+created: ${date}
+---
+
+# ${title}
+
+## Status
+
+Proposed
+
+## Context
+
+${description || 'Describe the context and problem statement.'}
+
+## Decision
+
+Describe the decision made.
+
+## Consequences
+
+- Positive consequence 1
+- Positive consequence 2
+- Negative consequence 1
+
+## Alternatives
+
+- Alternative 1: Description
+- Alternative 2: Description
+`;
+}
+
+function generateSpecTemplate(title: string, description?: string, phase?: string): string {
+  const date = new Date().toISOString().split('T')[0];
+  return `---
+title: "${title}"
+status: draft
+phase: ${phase || 'requirements'}
+created: ${date}
+---
+
+# ${title}
+
+${description || 'Description of the specification.'}
+
+## Overview
+
+Provide an overview of this specification.
+
+## Requirements
+
+- [ ] Requirement 1
+- [ ] Requirement 2
+
+## Implementation Notes
+
+_Notes for implementation._
+`;
+}
+
+/**
+ * PATCH /api/specs - Update task status in a spec file
+ */
+export async function PATCH(req: NextRequest) {
+  try {
+    const body = await req.json();
+    const { filePath, taskTitle, completed } = body;
+
+    if (!filePath || taskTitle === undefined || completed === undefined) {
+      return NextResponse.json(
+        { error: 'filePath, taskTitle, and completed are required' },
+        { status: 400 }
+      );
+    }
+
+    // Security: Validate path
+    if (filePath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    // Read the file
+    let content: string;
+    try {
+      content = await fs.readFile(filePath, 'utf-8');
+    } catch {
+      return NextResponse.json(
+        { error: 'File not found' },
+        { status: 404 }
+      );
+    }
+
+    // Find and update the task checkbox
+    // Task format: - [ ] Task title or - [x] Task title
+    const escapedTitle = taskTitle.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const taskRegex = new RegExp(
+      `^(\\s*[-*]\\s*)\\[([ xX])\\](\\s*(?:\\[[^\\]]+\\]\\s*)?)${escapedTitle}`,
+      'gm'
+    );
+
+    let found = false;
+    const newContent = content.replace(taskRegex, (match, prefix, _checkbox, priorityAndSpace) => {
+      found = true;
+      const newCheckbox = completed ? 'x' : ' ';
+      return `${prefix}[${newCheckbox}]${priorityAndSpace}${taskTitle}`;
+    });
+
+    if (!found) {
+      // Try a more lenient match (just the title anywhere in a checkbox line)
+      const lenientRegex = new RegExp(
+        `^(\\s*[-*]\\s*)\\[([ xX])\\](\\s*.*)${escapedTitle}(.*)$`,
+        'gm'
+      );
+
+      const newContentLenient = content.replace(lenientRegex, (match, prefix, _checkbox, beforeTitle, afterTitle) => {
+        found = true;
+        const newCheckbox = completed ? 'x' : ' ';
+        return `${prefix}[${newCheckbox}]${beforeTitle}${taskTitle}${afterTitle}`;
+      });
+
+      if (found) {
+        await fs.writeFile(filePath, newContentLenient, 'utf-8');
+        return NextResponse.json({ success: true, updated: true });
+      }
+
+      return NextResponse.json(
+        { error: 'Task not found in file' },
+        { status: 404 }
+      );
+    }
+
+    // Write the updated content
+    await fs.writeFile(filePath, newContent, 'utf-8');
+
+    return NextResponse.json({ success: true, updated: true });
+  } catch (error) {
+    console.error('Error updating task:', error);
+    return NextResponse.json(
+      { error: 'Failed to update task' },
+      { status: 500 }
+    );
+  }
+}

package/web/app/api/terminal/route.ts

@@ -0,0 +1,222 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { ptyManager } from '@/lib/ptyManager';
+
+// POST - Create session or write data
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { action, sessionId, data, cwd, cols, rows } = body;
+
+    switch (action) {
+      case 'create': {
+        if (!sessionId || !cwd) {
+          return NextResponse.json(
+            { error: 'sessionId and cwd are required' },
+            { status: 400 }
+          );
+        }
+
+        // Check if session already exists
+        const existing = ptyManager.getSession(sessionId);
+        if (existing) {
+          return NextResponse.json({
+            success: true,
+            sessionId,
+            message: 'Session already exists'
+          });
+        }
+
+        ptyManager.createSession(sessionId, cwd, cols || 80, rows || 24);
+        return NextResponse.json({
+          success: true,
+          sessionId,
+          message: 'Session created'
+        });
+      }
+
+      case 'write': {
+        if (!sessionId || data === undefined) {
+          return NextResponse.json(
+            { error: 'sessionId and data are required' },
+            { status: 400 }
+          );
+        }
+
+        const success = ptyManager.write(sessionId, data);
+        if (!success) {
+          return NextResponse.json(
+            { error: 'Session not found' },
+            { status: 404 }
+          );
+        }
+
+        return NextResponse.json({ success: true });
+      }
+
+      case 'resize': {
+        if (!sessionId || !cols || !rows) {
+          return NextResponse.json(
+            { error: 'sessionId, cols, and rows are required' },
+            { status: 400 }
+          );
+        }
+
+        const success = ptyManager.resize(sessionId, cols, rows);
+        if (!success) {
+          return NextResponse.json(
+            { error: 'Session not found' },
+            { status: 404 }
+          );
+        }
+
+        return NextResponse.json({ success: true });
+      }
+
+      case 'destroy': {
+        if (!sessionId) {
+          return NextResponse.json(
+            { error: 'sessionId is required' },
+            { status: 400 }
+          );
+        }
+
+        ptyManager.destroySession(sessionId);
+        return NextResponse.json({ success: true });
+      }
+
+      default:
+        return NextResponse.json(
+          { error: 'Invalid action' },
+          { status: 400 }
+        );
+    }
+  } catch (error) {
+    console.error('Terminal API error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+
+// GET - Stream output via SSE
+export async function GET(request: NextRequest) {
+  const { searchParams } = new URL(request.url);
+  const sessionId = searchParams.get('sessionId');
+
+  if (!sessionId) {
+    return NextResponse.json(
+      { error: 'sessionId is required' },
+      { status: 400 }
+    );
+  }
+
+  const session = ptyManager.getSession(sessionId);
+  if (!session) {
+    return NextResponse.json(
+      { error: 'Session not found' },
+      { status: 404 }
+    );
+  }
+
+  // Create SSE stream
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    start(controller) {
+      // Send any buffered output first
+      const buffer = ptyManager.getOutputBuffer(sessionId);
+      if (buffer.length > 0) {
+        const initialData = buffer.join('');
+        controller.enqueue(
+          encoder.encode(`data: ${JSON.stringify({ type: 'data', data: initialData })}\n\n`)
+        );
+        ptyManager.clearOutputBuffer(sessionId);
+      }
+
+      // Listen for new data
+      const dataHandler = ({ sessionId: sid, data }: { sessionId: string; data: string }) => {
+        if (sid === sessionId) {
+          try {
+            controller.enqueue(
+              encoder.encode(`data: ${JSON.stringify({ type: 'data', data })}\n\n`)
+            );
+          } catch {
+            // Stream closed
+          }
+        }
+      };
+
+      // Listen for exit
+      const exitHandler = ({ sessionId: sid, exitCode }: { sessionId: string; exitCode: number }) => {
+        if (sid === sessionId) {
+          try {
+            controller.enqueue(
+              encoder.encode(`data: ${JSON.stringify({ type: 'exit', exitCode })}\n\n`)
+            );
+            controller.close();
+          } catch {
+            // Stream already closed
+          }
+        }
+      };
+
+      // Listen for autopilot phase completion
+      const autopilotDoneHandler = ({ sessionId: sid, exitCode }: { sessionId: string; output: string; exitCode: number }) => {
+        if (sid === sessionId) {
+          try {
+            controller.enqueue(
+              encoder.encode(`data: ${JSON.stringify({ type: 'autopilot-phase-done', exitCode })}\n\n`)
+            );
+          } catch {
+            // Stream closed
+          }
+        }
+      };
+
+      ptyManager.on('data', dataHandler);
+      ptyManager.on('exit', exitHandler);
+      ptyManager.on('autopilot-phase-done', autopilotDoneHandler);
+
+      // Heartbeat to keep connection alive
+      const heartbeat = setInterval(() => {
+        try {
+          controller.enqueue(encoder.encode(': heartbeat\n\n'));
+        } catch {
+          clearInterval(heartbeat);
+        }
+      }, 30000);
+
+      // Cleanup on close
+      request.signal.addEventListener('abort', () => {
+        ptyManager.off('data', dataHandler);
+        ptyManager.off('exit', exitHandler);
+        ptyManager.off('autopilot-phase-done', autopilotDoneHandler);
+        clearInterval(heartbeat);
+      });
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive',
+    },
+  });
+}
+
+// DELETE - Destroy session
+export async function DELETE(request: NextRequest) {
+  const { searchParams } = new URL(request.url);
+  const sessionId = searchParams.get('sessionId');
+
+  if (!sessionId) {
+    return NextResponse.json(
+      { error: 'sessionId is required' },
+      { status: 400 }
+    );
+  }
+
+  ptyManager.destroySession(sessionId);
+  return NextResponse.json({ success: true });
+}