@evolve.labs/devflow 0.8.0

package/web/app/api/autopilot/execute/route.ts

@@ -0,0 +1,102 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { execSync } from 'child_process';
+import path from 'node:path';
+import {
+  type AgentName,
+  isValidAgent,
+  buildPrompt,
+  loadAgentDefinition,
+  AGENT_TIMEOUTS,
+  TASK_TRACKING_AGENTS,
+  autoUpdateSpecTasks,
+} from '@/lib/autopilotConstants';
+
+/**
+ * Autopilot Execute API - Executa uma única fase via Claude CLI --print (execSync fallback)
+ */
+
+interface ExecuteRequest {
+  agent: string;
+  specContent: string;
+  specFilePath?: string;
+  previousOutputs: string[];
+  projectPath: string;
+}
+
+export async function POST(req: NextRequest) {
+  let body: ExecuteRequest;
+
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const { agent, specContent, specFilePath, previousOutputs, projectPath } = body;
+
+  if (!agent || !specContent || !projectPath) {
+    return NextResponse.json({ error: 'Missing required fields' }, { status: 400 });
+  }
+
+  if (!isValidAgent(agent)) {
+    return NextResponse.json({ error: `Unknown agent: ${agent}` }, { status: 400 });
+  }
+
+  // Validate projectPath - must be absolute and not escape via traversal
+  const resolved = path.resolve(projectPath);
+  if (resolved !== projectPath || projectPath.includes('..')) {
+    return NextResponse.json({ error: 'Invalid project path' }, { status: 400 });
+  }
+
+  // Load the full agent definition from the project's .claude/commands/agents/
+  const agentDefinition = await loadAgentDefinition(resolved, agent);
+  const fullPrompt = buildPrompt(agent, specContent, previousOutputs || [], agentDefinition);
+  const timeout = AGENT_TIMEOUTS[agent];
+
+  try {
+    const output = execSync('claude --print', {
+      cwd: resolved,
+      input: fullPrompt,
+      encoding: 'utf-8',
+      timeout: timeout * 1000,
+      maxBuffer: 2 * 1024 * 1024,
+    });
+
+    const trimmedOutput = output.trim();
+
+    // Auto-update spec tasks if this agent produces trackable output
+    let tasksCompleted: string[] = [];
+    if (
+      specFilePath &&
+      TASK_TRACKING_AGENTS.includes(agent) &&
+      trimmedOutput.length > 0
+    ) {
+      const resolvedSpec = path.resolve(specFilePath);
+      if (resolvedSpec === specFilePath && !specFilePath.includes('..')) {
+        tasksCompleted = await autoUpdateSpecTasks(resolvedSpec, trimmedOutput);
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      output: trimmedOutput,
+      agent,
+      tasksCompleted,
+    });
+  } catch (error) {
+    console.error(`Autopilot ${agent} error:`, error);
+
+    let errorMessage = 'Execution failed';
+    if (error instanceof Error) {
+      if (error.message.includes('ETIMEDOUT') || error.message.includes('timeout')) {
+        errorMessage = `Timeout: ${agent} exceeded ${timeout}s`;
+      } else if (error.message.includes('ENOENT')) {
+        errorMessage = 'Claude CLI not found. Install with: npm i -g @anthropic-ai/claude-code';
+      } else {
+        errorMessage = error.message.slice(0, 500);
+      }
+    }
+
+    return NextResponse.json({ error: errorMessage }, { status: 500 });
+  }
+}

package/web/app/api/autopilot/terminal-execute/route.ts

@@ -0,0 +1,124 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { promises as fs } from 'fs';
+import path from 'node:path';
+import os from 'node:os';
+import { ptyManager } from '@/lib/ptyManager';
+import {
+  isValidAgent,
+  buildPrompt,
+  loadAgentDefinition,
+  AGENT_TIMEOUTS,
+  TASK_TRACKING_AGENTS,
+  PHASE_DONE_MARKER,
+  autoUpdateSpecTasks,
+} from '@/lib/autopilotConstants';
+
+/**
+ * Autopilot Terminal Execute API
+ * Runs an agent phase through the terminal PTY (streaming output visible in xterm.js).
+ */
+
+interface TerminalExecuteRequest {
+  sessionId: string;
+  agent: string;
+  specContent: string;
+  specFilePath?: string;
+  previousOutputs: string[];
+  projectPath: string;
+}
+
+export async function POST(req: NextRequest) {
+  let body: TerminalExecuteRequest;
+
+  try {
+    body = await req.json();
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 });
+  }
+
+  const { sessionId, agent, specContent, specFilePath, previousOutputs, projectPath } = body;
+
+  if (!sessionId || !agent || !specContent || !projectPath) {
+    return NextResponse.json({ error: 'Missing required fields' }, { status: 400 });
+  }
+
+  if (!isValidAgent(agent)) {
+    return NextResponse.json({ error: `Unknown agent: ${agent}` }, { status: 400 });
+  }
+
+  // Validate projectPath
+  const resolved = path.resolve(projectPath);
+  if (resolved !== projectPath || projectPath.includes('..')) {
+    return NextResponse.json({ error: 'Invalid project path' }, { status: 400 });
+  }
+
+  // Verify terminal session exists
+  const session = ptyManager.getSession(sessionId);
+  if (!session) {
+    return NextResponse.json({ error: 'Terminal session not found' }, { status: 404 });
+  }
+
+  // Load full agent definition from the project's .claude/commands/agents/
+  const agentDefinition = await loadAgentDefinition(resolved, agent);
+  const fullPrompt = buildPrompt(agent, specContent, previousOutputs || [], agentDefinition);
+  const timeoutSec = AGENT_TIMEOUTS[agent];
+  const timeoutMs = timeoutSec * 1000;
+
+  // Write prompt to temp file (avoid shell escaping issues)
+  const tmpDir = os.tmpdir();
+  const tmpFile = path.join(tmpDir, `devflow-autopilot-${sessionId}-${agent}-${Date.now()}.md`);
+
+  try {
+    await fs.writeFile(tmpFile, fullPrompt, 'utf-8');
+
+    // Arm the collector before writing the command
+    const collectorPromise = ptyManager.armAutopilotCollector(sessionId, timeoutMs + 5000);
+
+    // Write the command to the PTY
+    // Uses: claude --print < tmpfile ; echo marker
+    // The marker includes $? to capture the exit code of claude
+    const command = `cd ${JSON.stringify(resolved)} && claude --print < ${JSON.stringify(tmpFile)}; echo "${PHASE_DONE_MARKER}$?___"\n`;
+    ptyManager.write(sessionId, command);
+
+    // Wait for the collector to detect the marker
+    const result = await collectorPromise;
+
+    // Clean up temp file
+    await fs.unlink(tmpFile).catch(() => {});
+
+    const trimmedOutput = result.output.trim();
+
+    // Auto-update spec tasks
+    let tasksCompleted: string[] = [];
+    if (
+      specFilePath &&
+      TASK_TRACKING_AGENTS.includes(agent) &&
+      trimmedOutput.length > 0
+    ) {
+      const resolvedSpec = path.resolve(specFilePath);
+      if (resolvedSpec === specFilePath && !specFilePath.includes('..')) {
+        tasksCompleted = await autoUpdateSpecTasks(resolvedSpec, trimmedOutput);
+      }
+    }
+
+    return NextResponse.json({
+      success: result.exitCode === 0,
+      output: trimmedOutput,
+      exitCode: result.exitCode,
+      agent,
+      tasksCompleted,
+      error: result.exitCode !== 0 ? `Agent ${agent} exited with code ${result.exitCode}` : undefined,
+    });
+  } catch (error) {
+    // Clean up temp file on error
+    await fs.unlink(tmpFile).catch(() => {});
+
+    // Disarm collector if still active
+    ptyManager.disarmAutopilotCollector(sessionId);
+
+    console.error(`Autopilot terminal-execute ${agent} error:`, error);
+
+    const errorMessage = error instanceof Error ? error.message : 'Execution failed';
+    return NextResponse.json({ error: errorMessage, success: false }, { status: 500 });
+  }
+}

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

@@ -0,0 +1,280 @@
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs/promises';
+import path from 'path';
+
+/**
+ * GET /api/files?path=/path/to/file
+ * Read file content
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const { searchParams } = new URL(req.url);
+    const filePath = searchParams.get('path');
+
+    if (!filePath) {
+      return NextResponse.json(
+        { error: 'File path is required' },
+        { status: 400 }
+      );
+    }
+
+    // Security check
+    if (filePath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    try {
+      const stat = await fs.stat(filePath);
+
+      if (!stat.isFile()) {
+        return NextResponse.json(
+          { error: 'Path is not a file' },
+          { status: 400 }
+        );
+      }
+
+      // Check file size (limit to 5MB)
+      if (stat.size > 5 * 1024 * 1024) {
+        return NextResponse.json(
+          { error: 'File too large (max 5MB)' },
+          { status: 400 }
+        );
+      }
+
+      const content = await fs.readFile(filePath, 'utf-8');
+
+      return NextResponse.json({
+        path: filePath,
+        content,
+        size: stat.size,
+        modifiedAt: stat.mtime.toISOString(),
+      });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+        return NextResponse.json(
+          { error: 'File not found' },
+          { status: 404 }
+        );
+      }
+      throw error;
+    }
+  } catch (error) {
+    console.error('Error reading file:', error);
+    return NextResponse.json(
+      { error: 'Failed to read file' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * PUT /api/files
+ * Write file content
+ */
+export async function PUT(req: NextRequest) {
+  try {
+    const { path: filePath, content } = await req.json();
+
+    if (!filePath || typeof content !== 'string') {
+      return NextResponse.json(
+        { error: 'Path and content are required' },
+        { status: 400 }
+      );
+    }
+
+    // Security check
+    if (filePath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    await fs.writeFile(filePath, content, 'utf-8');
+
+    const stat = await fs.stat(filePath);
+
+    return NextResponse.json({
+      success: true,
+      path: filePath,
+      modifiedAt: stat.mtime.toISOString(),
+    });
+  } catch (error) {
+    console.error('Error writing file:', error);
+    return NextResponse.json(
+      { error: 'Failed to write file' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * POST /api/files
+ * Create new file or directory
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const { path: filePath, type, content = '' } = await req.json();
+
+    if (!filePath || !type) {
+      return NextResponse.json(
+        { error: 'Path and type are required' },
+        { status: 400 }
+      );
+    }
+
+    // Security check
+    if (filePath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    // Check if already exists
+    try {
+      await fs.access(filePath);
+      return NextResponse.json(
+        { error: 'Path already exists' },
+        { status: 409 }
+      );
+    } catch {
+      // Path doesn't exist, good to create
+    }
+
+    if (type === 'directory') {
+      await fs.mkdir(filePath, { recursive: true });
+    } else {
+      // Ensure parent directory exists
+      const parentDir = path.dirname(filePath);
+      await fs.mkdir(parentDir, { recursive: true });
+      await fs.writeFile(filePath, content, 'utf-8');
+    }
+
+    return NextResponse.json({
+      success: true,
+      path: filePath,
+      type,
+    });
+  } catch (error) {
+    console.error('Error creating file:', error);
+    return NextResponse.json(
+      { error: 'Failed to create file' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * PATCH /api/files
+ * Rename file or directory
+ */
+export async function PATCH(req: NextRequest) {
+  try {
+    const { oldPath, newPath } = await req.json();
+
+    if (!oldPath || !newPath) {
+      return NextResponse.json(
+        { error: 'Old path and new path are required' },
+        { status: 400 }
+      );
+    }
+
+    // Security check
+    if (oldPath.includes('..') || newPath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    // Check if old path exists
+    try {
+      await fs.access(oldPath);
+    } catch {
+      return NextResponse.json(
+        { error: 'Source path not found' },
+        { status: 404 }
+      );
+    }
+
+    // Check if new path already exists
+    try {
+      await fs.access(newPath);
+      return NextResponse.json(
+        { error: 'Destination path already exists' },
+        { status: 409 }
+      );
+    } catch {
+      // Path doesn't exist, good to rename
+    }
+
+    await fs.rename(oldPath, newPath);
+
+    return NextResponse.json({
+      success: true,
+      oldPath,
+      newPath,
+    });
+  } catch (error) {
+    console.error('Error renaming file:', error);
+    return NextResponse.json(
+      { error: 'Failed to rename file' },
+      { status: 500 }
+    );
+  }
+}
+
+/**
+ * DELETE /api/files
+ * Delete file or directory
+ */
+export async function DELETE(req: NextRequest) {
+  try {
+    const { path: filePath } = await req.json();
+
+    if (!filePath) {
+      return NextResponse.json(
+        { error: 'Path is required' },
+        { status: 400 }
+      );
+    }
+
+    // Security check
+    if (filePath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    const stat = await fs.stat(filePath);
+
+    if (stat.isDirectory()) {
+      await fs.rm(filePath, { recursive: true });
+    } else {
+      await fs.unlink(filePath);
+    }
+
+    return NextResponse.json({
+      success: true,
+      path: filePath,
+    });
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return NextResponse.json(
+        { error: 'Path not found' },
+        { status: 404 }
+      );
+    }
+
+    console.error('Error deleting file:', error);
+    return NextResponse.json(
+      { error: 'Failed to delete file' },
+      { status: 500 }
+    );
+  }
+}

package/web/app/api/files/tree/route.ts

@@ -0,0 +1,160 @@
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs/promises';
+import path from 'path';
+
+interface FileNode {
+  name: string;
+  path: string;
+  type: 'file' | 'directory';
+  extension?: string;
+  children?: FileNode[];
+}
+
+// Folders to prioritize (shown first)
+const PRIORITY_FOLDERS = ['.devflow', 'docs'];
+
+// Files/folders to exclude
+const EXCLUDED = [
+  'node_modules',
+  '.git',
+  '.DS_Store',
+  '.next',
+  'dist',
+  'build',
+  '__pycache__',
+  '.pytest_cache',
+  '.venv',
+  'venv',
+];
+
+/**
+ * GET /api/files/tree?path=/project/path
+ * Returns file tree for a project
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const { searchParams } = new URL(req.url);
+    const projectPath = searchParams.get('path');
+
+    if (!projectPath) {
+      return NextResponse.json(
+        { error: 'Project path is required' },
+        { status: 400 }
+      );
+    }
+
+    // Security check
+    if (projectPath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    const root = await buildFileTree(projectPath, projectPath);
+
+    return NextResponse.json({ root });
+  } catch (error) {
+    console.error('Error building file tree:', error);
+    return NextResponse.json(
+      { error: 'Failed to build file tree' },
+      { status: 500 }
+    );
+  }
+}
+
+async function buildFileTree(
+  basePath: string,
+  currentPath: string,
+  depth: number = 0
+): Promise<FileNode> {
+  const stat = await fs.stat(currentPath);
+  const name = path.basename(currentPath);
+  const relativePath = path.relative(basePath, currentPath) || '.';
+
+  if (stat.isFile()) {
+    const ext = path.extname(name).slice(1);
+    return {
+      name,
+      path: currentPath,
+      type: 'file',
+      extension: ext || undefined,
+    };
+  }
+
+  // Directory
+  let children: FileNode[] = [];
+
+  // Limit depth to prevent huge trees
+  if (depth < 10) {
+    try {
+      const entries = await fs.readdir(currentPath);
+
+      // Filter and sort entries
+      const filteredEntries = entries.filter(
+        (entry) => !EXCLUDED.includes(entry) && !entry.startsWith('.')
+      );
+
+      // Include priority hidden folders
+      const priorityHidden = entries.filter(
+        (entry) => PRIORITY_FOLDERS.includes(entry)
+      );
+
+      const allEntries = [...priorityHidden, ...filteredEntries];
+      const uniqueEntries = [...new Set(allEntries)];
+
+      // Sort: directories first, then priority folders, then alphabetically
+      const sorted = await sortEntries(currentPath, uniqueEntries);
+
+      children = await Promise.all(
+        sorted.map((entry) =>
+          buildFileTree(basePath, path.join(currentPath, entry), depth + 1)
+        )
+      );
+    } catch (error) {
+      console.error(`Error reading directory ${currentPath}:`, error);
+    }
+  }
+
+  return {
+    name,
+    path: currentPath,
+    type: 'directory',
+    children,
+  };
+}
+
+async function sortEntries(
+  dirPath: string,
+  entries: string[]
+): Promise<string[]> {
+  const withTypes = await Promise.all(
+    entries.map(async (entry) => {
+      try {
+        const stat = await fs.stat(path.join(dirPath, entry));
+        return {
+          name: entry,
+          isDirectory: stat.isDirectory(),
+          isPriority: PRIORITY_FOLDERS.includes(entry),
+        };
+      } catch {
+        return { name: entry, isDirectory: false, isPriority: false };
+      }
+    })
+  );
+
+  return withTypes
+    .sort((a, b) => {
+      // Priority folders first
+      if (a.isPriority && !b.isPriority) return -1;
+      if (!a.isPriority && b.isPriority) return 1;
+
+      // Directories before files
+      if (a.isDirectory && !b.isDirectory) return -1;
+      if (!a.isDirectory && b.isDirectory) return 1;
+
+      // Alphabetically
+      return a.name.localeCompare(b.name);
+    })
+    .map((e) => e.name);
+}