@evolve.labs/devflow 0.8.0

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

@@ -0,0 +1,201 @@
+import { NextRequest, NextResponse } from 'next/server';
+import {
+  getGitStatus,
+  getGitLog,
+  getGitBranches,
+  getGitDiff,
+  gitStage,
+  gitUnstage,
+  gitCommit,
+  gitPush,
+  gitPull,
+  gitCheckout,
+  gitCreateBranch,
+  gitDiscard,
+  gitInit,
+  getRemotes,
+} from '@/lib/git';
+
+// GET - Get git status, log, branches, or diff
+export async function GET(request: NextRequest) {
+  const { searchParams } = new URL(request.url);
+  const action = searchParams.get('action') || 'status';
+  const projectPath = searchParams.get('projectPath');
+  const file = searchParams.get('file');
+  const staged = searchParams.get('staged') === 'true';
+
+  if (!projectPath) {
+    return NextResponse.json(
+      { error: 'projectPath is required' },
+      { status: 400 }
+    );
+  }
+
+  try {
+    switch (action) {
+      case 'status': {
+        const status = await getGitStatus(projectPath);
+        return NextResponse.json(status);
+      }
+
+      case 'log': {
+        const maxCount = parseInt(searchParams.get('maxCount') || '50', 10);
+        const log = await getGitLog(projectPath, maxCount);
+        return NextResponse.json({ commits: log });
+      }
+
+      case 'branches': {
+        const branches = await getGitBranches(projectPath);
+        return NextResponse.json({ branches });
+      }
+
+      case 'diff': {
+        const diff = await getGitDiff(projectPath, file || undefined, staged);
+        return NextResponse.json({ diff });
+      }
+
+      case 'remotes': {
+        const remotes = await getRemotes(projectPath);
+        return NextResponse.json({ remotes });
+      }
+
+      default:
+        return NextResponse.json(
+          { error: 'Invalid action' },
+          { status: 400 }
+        );
+    }
+  } catch (error) {
+    console.error('Git API error:', error);
+    return NextResponse.json(
+      { error: 'Git operation failed' },
+      { status: 500 }
+    );
+  }
+}
+
+// POST - Perform git operations
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const { action, projectPath, files, message, remote, branch } = body;
+
+    if (!projectPath) {
+      return NextResponse.json(
+        { error: 'projectPath is required' },
+        { status: 400 }
+      );
+    }
+
+    switch (action) {
+      case 'stage': {
+        if (!files || !Array.isArray(files) || files.length === 0) {
+          return NextResponse.json(
+            { error: 'files array is required' },
+            { status: 400 }
+          );
+        }
+        const success = await gitStage(projectPath, files);
+        return NextResponse.json({ success });
+      }
+
+      case 'unstage': {
+        if (!files || !Array.isArray(files) || files.length === 0) {
+          return NextResponse.json(
+            { error: 'files array is required' },
+            { status: 400 }
+          );
+        }
+        const success = await gitUnstage(projectPath, files);
+        return NextResponse.json({ success });
+      }
+
+      case 'commit': {
+        if (!message) {
+          return NextResponse.json(
+            { error: 'message is required' },
+            { status: 400 }
+          );
+        }
+        const result = await gitCommit(projectPath, message);
+        return NextResponse.json(result);
+      }
+
+      case 'push': {
+        const result = await gitPush(projectPath, remote || 'origin', branch);
+        return NextResponse.json(result);
+      }
+
+      case 'pull': {
+        const result = await gitPull(projectPath, remote || 'origin', branch);
+        return NextResponse.json(result);
+      }
+
+      case 'checkout': {
+        if (!branch) {
+          return NextResponse.json(
+            { error: 'branch is required' },
+            { status: 400 }
+          );
+        }
+        const result = await gitCheckout(projectPath, branch);
+        return NextResponse.json(result);
+      }
+
+      case 'createBranch': {
+        if (!branch) {
+          return NextResponse.json(
+            { error: 'branch is required' },
+            { status: 400 }
+          );
+        }
+        const checkout = body.checkout !== false;
+        const result = await gitCreateBranch(projectPath, branch, checkout);
+        return NextResponse.json(result);
+      }
+
+      case 'discard': {
+        if (!files || !Array.isArray(files) || files.length === 0) {
+          return NextResponse.json(
+            { error: 'files array is required' },
+            { status: 400 }
+          );
+        }
+        const success = await gitDiscard(projectPath, files);
+        return NextResponse.json({ success });
+      }
+
+      case 'init': {
+        const result = await gitInit(projectPath);
+        return NextResponse.json(result);
+      }
+
+      case 'stageAll': {
+        const success = await gitStage(projectPath, ['.']);
+        return NextResponse.json({ success });
+      }
+
+      case 'unstageAll': {
+        const status = await getGitStatus(projectPath);
+        const stagedFiles = status.staged.map(f => f.path);
+        if (stagedFiles.length > 0) {
+          const success = await gitUnstage(projectPath, stagedFiles);
+          return NextResponse.json({ success });
+        }
+        return NextResponse.json({ success: true });
+      }
+
+      default:
+        return NextResponse.json(
+          { error: 'Invalid action' },
+          { status: 400 }
+        );
+    }
+  } catch (error) {
+    console.error('Git API error:', error);
+    return NextResponse.json(
+      { error: 'Git operation failed' },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,94 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import path from 'path';
+
+const execAsync = promisify(exec);
+
+interface HealthStatus {
+  claudeCli: {
+    installed: boolean;
+    authenticated: boolean;
+    version?: string;
+    error?: string;
+  };
+  project: {
+    valid: boolean;
+    hasDevflow: boolean;
+    hasClaudeProject: boolean;
+  };
+  system: {
+    platform: string;
+    nodeVersion: string;
+  };
+}
+
+/**
+ * GET /api/health?projectPath=/path
+ * Check system health status
+ */
+export async function GET(req: NextRequest) {
+  const { searchParams } = new URL(req.url);
+  const projectPath = searchParams.get('projectPath');
+
+  const status: HealthStatus = {
+    claudeCli: {
+      installed: false,
+      authenticated: false,
+    },
+    project: {
+      valid: false,
+      hasDevflow: false,
+      hasClaudeProject: false,
+    },
+    system: {
+      platform: process.platform,
+      nodeVersion: process.version,
+    },
+  };
+
+  // Check Claude CLI (skip whoami to avoid slowness)
+  try {
+    const { stdout } = await execAsync('claude --version', { timeout: 5000 });
+    status.claudeCli.installed = true;
+    status.claudeCli.version = stdout.trim();
+    status.claudeCli.authenticated = true; // Assume authenticated if CLI is installed
+  } catch (error) {
+    status.claudeCli.error = 'Claude CLI not found. Install from https://claude.ai/cli';
+  }
+
+  // Check project if path provided
+  if (projectPath && !projectPath.includes('..')) {
+    try {
+      await fs.access(projectPath);
+      status.project.valid = true;
+
+      // Check .devflow in current path or parent directory
+      try {
+        await fs.access(path.join(projectPath, '.devflow'));
+        status.project.hasDevflow = true;
+      } catch {
+        // Try parent directory
+        try {
+          await fs.access(path.join(projectPath, '..', '.devflow'));
+          status.project.hasDevflow = true;
+        } catch {}
+      }
+
+      // Check .claude_project in current path or parent directory
+      try {
+        await fs.access(path.join(projectPath, '.claude_project'));
+        status.project.hasClaudeProject = true;
+      } catch {
+        // Try parent directory
+        try {
+          await fs.access(path.join(projectPath, '..', '.claude_project'));
+          status.project.hasClaudeProject = true;
+        } catch {}
+      }
+    } catch {}
+  }
+
+  return NextResponse.json(status);
+}

package/web/app/api/project/open/route.ts

@@ -0,0 +1,134 @@
+import { NextRequest, NextResponse } from 'next/server';
+import fs from 'fs/promises';
+import path from 'path';
+
+interface ProjectInfo {
+  path: string;
+  name: string;
+  isValid: boolean;
+  hasDevflow: boolean;
+  hasClaudeProject: boolean;
+  stats: {
+    specs: number;
+    stories: number;
+    adrs: number;
+    agents: number;
+  };
+}
+
+/**
+ * POST /api/project/open
+ * Opens a DevFlow project and returns its metadata
+ */
+export async function POST(req: NextRequest) {
+  try {
+    const { path: projectPath } = await req.json();
+
+    // Validate path
+    if (!projectPath || typeof projectPath !== 'string') {
+      return NextResponse.json(
+        { error: 'Project path is required' },
+        { status: 400 }
+      );
+    }
+
+    // Security: Check for path traversal
+    if (projectPath.includes('..')) {
+      return NextResponse.json(
+        { error: 'Invalid path' },
+        { status: 400 }
+      );
+    }
+
+    // Check if path exists
+    try {
+      await fs.access(projectPath);
+    } catch {
+      return NextResponse.json(
+        { error: 'Path does not exist' },
+        { status: 404 }
+      );
+    }
+
+    // Check if it's a directory
+    const stat = await fs.stat(projectPath);
+    if (!stat.isDirectory()) {
+      return NextResponse.json(
+        { error: 'Path is not a directory' },
+        { status: 400 }
+      );
+    }
+
+    // Check for DevFlow markers
+    let hasDevflow = false;
+    let hasClaudeProject = false;
+
+    try {
+      await fs.access(path.join(projectPath, '.devflow'));
+      hasDevflow = true;
+    } catch {}
+
+    try {
+      await fs.access(path.join(projectPath, '.claude_project'));
+      hasClaudeProject = true;
+    } catch {}
+
+    // Get stats
+    const stats = {
+      specs: 0,
+      stories: 0,
+      adrs: 0,
+      agents: 0,
+    };
+
+    // Count stories
+    try {
+      const storiesPath = path.join(projectPath, 'docs', 'planning', 'stories');
+      const stories = await fs.readdir(storiesPath);
+      stats.stories = stories.filter(f => f.endsWith('.md') && f !== '.gitkeep').length;
+    } catch {}
+
+    // Count ADRs
+    try {
+      const adrsPath = path.join(projectPath, 'docs', 'decisions');
+      const adrs = await fs.readdir(adrsPath);
+      stats.adrs = adrs.filter(f => f.endsWith('.md') && !f.startsWith('000-')).length;
+    } catch {}
+
+    // Count agents
+    try {
+      const agentsPath = path.join(projectPath, '.devflow', 'agents');
+      const agents = await fs.readdir(agentsPath);
+      stats.agents = agents.filter(f => f.endsWith('.md')).length;
+    } catch {}
+
+    // Count specs (planning/*.md)
+    try {
+      const planningPath = path.join(projectPath, 'docs', 'planning');
+      const files = await fs.readdir(planningPath);
+      stats.specs = files.filter(f => f.endsWith('.md')).length;
+    } catch {}
+
+    const projectName = path.basename(projectPath);
+
+    const project: ProjectInfo = {
+      path: projectPath,
+      name: projectName,
+      isValid: hasDevflow || hasClaudeProject,
+      hasDevflow,
+      hasClaudeProject,
+      stats,
+    };
+
+    return NextResponse.json({
+      success: true,
+      project,
+    });
+  } catch (error) {
+    console.error('Error opening project:', error);
+    return NextResponse.json(
+      { error: 'Failed to open project' },
+      { status: 500 }
+    );
+  }
+}

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

@@ -0,0 +1,247 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { promises as fs } from 'fs';
+import path from 'path';
+
+interface SearchResult {
+  filePath: string;
+  relativePath: string;
+  fileName: string;
+  matches: {
+    line: number;
+    content: string;
+    matchStart: number;
+    matchEnd: number;
+  }[];
+}
+
+interface FileResult {
+  filePath: string;
+  relativePath: string;
+  fileName: string;
+  extension: string;
+}
+
+// Directories to ignore
+const IGNORE_DIRS = [
+  'node_modules',
+  '.git',
+  '.next',
+  'dist',
+  'build',
+  '.turbo',
+  'coverage',
+  '__pycache__',
+  '.cache',
+];
+
+// File extensions to search
+const SEARCHABLE_EXTENSIONS = [
+  '.md',
+  '.txt',
+  '.ts',
+  '.tsx',
+  '.js',
+  '.jsx',
+  '.json',
+  '.yaml',
+  '.yml',
+  '.css',
+  '.scss',
+  '.html',
+  '.py',
+  '.go',
+  '.rs',
+  '.java',
+  '.c',
+  '.cpp',
+  '.h',
+  '.sh',
+  '.env',
+  '.toml',
+];
+
+async function getAllFiles(
+  dir: string,
+  basePath: string,
+  files: FileResult[] = []
+): Promise<FileResult[]> {
+  try {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      const relativePath = path.relative(basePath, fullPath);
+
+      if (entry.isDirectory()) {
+        if (!IGNORE_DIRS.includes(entry.name) && !entry.name.startsWith('.')) {
+          await getAllFiles(fullPath, basePath, files);
+        }
+      } else {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (SEARCHABLE_EXTENSIONS.includes(ext) || entry.name.startsWith('.')) {
+          files.push({
+            filePath: fullPath,
+            relativePath,
+            fileName: entry.name,
+            extension: ext,
+          });
+        }
+      }
+    }
+  } catch {
+    // Ignore permission errors
+  }
+
+  return files;
+}
+
+async function searchInFile(
+  file: FileResult,
+  query: string,
+  caseSensitive: boolean,
+  isRegex: boolean
+): Promise<SearchResult | null> {
+  try {
+    const content = await fs.readFile(file.filePath, 'utf-8');
+    const lines = content.split('\n');
+    const matches: SearchResult['matches'] = [];
+
+    let searchPattern: RegExp;
+    try {
+      if (isRegex) {
+        searchPattern = new RegExp(query, caseSensitive ? 'g' : 'gi');
+      } else {
+        const escapedQuery = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        searchPattern = new RegExp(escapedQuery, caseSensitive ? 'g' : 'gi');
+      }
+    } catch {
+      // Invalid regex, return null
+      return null;
+    }
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      let match: RegExpExecArray | null;
+      searchPattern.lastIndex = 0;
+
+      while ((match = searchPattern.exec(line)) !== null) {
+        matches.push({
+          line: i + 1,
+          content: line.slice(0, 200), // Limit line length
+          matchStart: match.index,
+          matchEnd: match.index + match[0].length,
+        });
+
+        // Prevent infinite loop for zero-length matches
+        if (match[0].length === 0) break;
+      }
+    }
+
+    if (matches.length > 0) {
+      return {
+        filePath: file.filePath,
+        relativePath: file.relativePath,
+        fileName: file.fileName,
+        matches: matches.slice(0, 50), // Limit matches per file
+      };
+    }
+
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * GET /api/search - Search for files or content
+ */
+export async function GET(req: NextRequest) {
+  try {
+    const searchParams = req.nextUrl.searchParams;
+    const projectPath = searchParams.get('projectPath');
+    const query = searchParams.get('query');
+    const type = searchParams.get('type') || 'files'; // 'files' or 'content'
+    const caseSensitive = searchParams.get('caseSensitive') === 'true';
+    const isRegex = searchParams.get('regex') === 'true';
+    const limit = parseInt(searchParams.get('limit') || '100', 10);
+
+    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 });
+    }
+
+    // Get all files
+    const allFiles = await getAllFiles(projectPath, projectPath);
+
+    if (type === 'files') {
+      // Quick Open - search file names
+      let results = allFiles;
+
+      if (query && query.trim()) {
+        const lowerQuery = query.toLowerCase();
+        results = allFiles
+          .filter((file) => {
+            const lowerPath = file.relativePath.toLowerCase();
+            const lowerName = file.fileName.toLowerCase();
+            return lowerPath.includes(lowerQuery) || lowerName.includes(lowerQuery);
+          })
+          .sort((a, b) => {
+            // Prioritize exact filename matches
+            const aNameMatch = a.fileName.toLowerCase().includes(lowerQuery);
+            const bNameMatch = b.fileName.toLowerCase().includes(lowerQuery);
+            if (aNameMatch && !bNameMatch) return -1;
+            if (!aNameMatch && bNameMatch) return 1;
+
+            // Then by path length (shorter = better)
+            return a.relativePath.length - b.relativePath.length;
+          });
+      }
+
+      return NextResponse.json({
+        type: 'files',
+        results: results.slice(0, limit),
+        total: results.length,
+      });
+    } else if (type === 'content') {
+      // Global Search - search file contents
+      if (!query || !query.trim()) {
+        return NextResponse.json({
+          type: 'content',
+          results: [],
+          total: 0,
+        });
+      }
+
+      const searchPromises = allFiles.map((file) =>
+        searchInFile(file, query, caseSensitive, isRegex)
+      );
+
+      const searchResults = await Promise.all(searchPromises);
+      const validResults = searchResults.filter(
+        (result): result is SearchResult => result !== null
+      );
+
+      // Sort by number of matches
+      validResults.sort((a, b) => b.matches.length - a.matches.length);
+
+      return NextResponse.json({
+        type: 'content',
+        results: validResults.slice(0, limit),
+        total: validResults.length,
+        totalMatches: validResults.reduce((sum, r) => sum + r.matches.length, 0),
+      });
+    }
+
+    return NextResponse.json({ error: 'Invalid type' }, { status: 400 });
+  } catch (error) {
+    console.error('Search error:', error);
+    return NextResponse.json({ error: 'Search failed' }, { status: 500 });
+  }
+}