@evolve.labs/devflow 0.8.0

package/web/lib/specsParser.ts

@@ -0,0 +1,299 @@
+/**
+ * Specs Parser - Extract structured data from markdown files
+ */
+
+import type { Spec, Requirement, DesignDecision, Task, SpecPhase } from './types';
+
+// Frontmatter regex
+const FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---/;
+
+// Task checkbox regex
+const TASK_REGEX = /^[\s]*[-*]\s*\[([ xX])\]\s*(.+)$/gm;
+
+// Section regex
+const SECTION_REGEX = /^##\s+(.+)$/gm;
+
+interface ParsedFrontmatter {
+  title?: string;
+  status?: string;
+  priority?: string;
+  type?: string;
+  agent?: string;
+  created?: string;
+  updated?: string;
+  [key: string]: string | undefined;
+}
+
+/**
+ * Parse frontmatter from markdown content
+ */
+export function parseFrontmatter(content: string): { frontmatter: ParsedFrontmatter; body: string } {
+  const match = content.match(FRONTMATTER_REGEX);
+
+  if (!match) {
+    return { frontmatter: {}, body: content };
+  }
+
+  const frontmatterStr = match[1];
+  const body = content.slice(match[0].length).trim();
+
+  const frontmatter: ParsedFrontmatter = {};
+
+  for (const line of frontmatterStr.split('\n')) {
+    const [key, ...valueParts] = line.split(':');
+    if (key && valueParts.length > 0) {
+      frontmatter[key.trim()] = valueParts.join(':').trim().replace(/^["']|["']$/g, '');
+    }
+  }
+
+  return { frontmatter, body };
+}
+
+/**
+ * Extract tasks from markdown content (checkbox items)
+ */
+export function extractTasks(content: string, specId: string, filePath?: string): Task[] {
+  const tasks: Task[] = [];
+  let match;
+  let index = 0;
+
+  const taskRegex = /^[\s]*[-*]\s*\[([ xX])\]\s*(.+)$/gm;
+
+  while ((match = taskRegex.exec(content)) !== null) {
+    const isCompleted = match[1].toLowerCase() === 'x';
+    const title = match[2].trim();
+
+    // Try to extract priority from title (e.g., [HIGH] or [P1])
+    const priorityMatch = title.match(/\[(HIGH|MEDIUM|LOW|CRITICAL|P[0-3])\]/i);
+    let priority: Task['priority'] = 'medium';
+    let cleanTitle = title;
+
+    if (priorityMatch) {
+      const p = priorityMatch[1].toUpperCase();
+      if (p === 'HIGH' || p === 'P1') priority = 'high';
+      else if (p === 'CRITICAL' || p === 'P0') priority = 'critical';
+      else if (p === 'LOW' || p === 'P3') priority = 'low';
+      cleanTitle = title.replace(priorityMatch[0], '').trim();
+    }
+
+    // Try to extract assigned agent from title (e.g., @Builder or @architect)
+    const agentMatch = cleanTitle.match(/@(strategist|architect|system-designer|builder|guardian|chronicler)/i);
+    let assignedAgent: string | undefined;
+
+    if (agentMatch) {
+      assignedAgent = agentMatch[1].toLowerCase();
+      cleanTitle = cleanTitle.replace(agentMatch[0], '').trim();
+    }
+
+    tasks.push({
+      id: `${specId}-task-${index++}`,
+      specId,
+      filePath,
+      title: cleanTitle,
+      description: '',
+      status: isCompleted ? 'completed' : 'pending',
+      priority,
+      dependencies: [],
+      assignedAgent,
+      createdAt: new Date(),
+      completedAt: isCompleted ? new Date() : undefined,
+    });
+  }
+
+  return tasks;
+}
+
+/**
+ * Extract sections from markdown
+ */
+export function extractSections(content: string): Map<string, string> {
+  const sections = new Map<string, string>();
+  const lines = content.split('\n');
+  let currentSection = 'intro';
+  let currentContent: string[] = [];
+
+  for (const line of lines) {
+    const sectionMatch = line.match(/^##\s+(.+)$/);
+    if (sectionMatch) {
+      // Save previous section
+      if (currentContent.length > 0) {
+        sections.set(currentSection, currentContent.join('\n').trim());
+      }
+      currentSection = sectionMatch[1].toLowerCase().replace(/\s+/g, '-');
+      currentContent = [];
+    } else {
+      currentContent.push(line);
+    }
+  }
+
+  // Save last section
+  if (currentContent.length > 0) {
+    sections.set(currentSection, currentContent.join('\n').trim());
+  }
+
+  return sections;
+}
+
+/**
+ * Parse a user story markdown file
+ */
+export function parseUserStory(
+  content: string,
+  filePath: string
+): { spec: Spec; requirement: Requirement; tasks: Task[] } {
+  const { frontmatter, body } = parseFrontmatter(content);
+  const sections = extractSections(body);
+
+  const id = filePath.split('/').pop()?.replace('.md', '') || `story-${Date.now()}`;
+
+  // Extract title from first H1 or frontmatter
+  const titleMatch = body.match(/^#\s+(.+)$/m);
+  const title = frontmatter.title || titleMatch?.[1] || id;
+
+  // Extract description (first paragraph after title)
+  const descMatch = body.match(/^#\s+.+\n\n([\s\S]*?)(?=\n##|\n\n##|$)/);
+  const description = descMatch?.[1]?.trim() || '';
+
+  // Extract acceptance criteria
+  const acSection = sections.get('acceptance-criteria') || sections.get('criterios-de-aceitacao') || '';
+  const acceptanceCriteria = acSection
+    .split('\n')
+    .filter(line => line.match(/^[-*]\s+/))
+    .map(line => line.replace(/^[-*]\s+/, '').trim());
+
+  // Map priority
+  const priorityMap: Record<string, Requirement['priority']> = {
+    'must': 'must',
+    'should': 'should',
+    'could': 'could',
+    'wont': 'wont',
+    'alta': 'must',
+    'media': 'should',
+    'baixa': 'could',
+  };
+
+  // Map status
+  const statusMap: Record<string, Requirement['status']> = {
+    'draft': 'draft',
+    'rascunho': 'draft',
+    'approved': 'approved',
+    'aprovado': 'approved',
+    'implemented': 'implemented',
+    'implementado': 'implemented',
+    'done': 'implemented',
+  };
+
+  const spec: Spec = {
+    id,
+    name: title,
+    description,
+    phase: 'requirements',
+    status: statusMap[frontmatter.status?.toLowerCase() || ''] || 'draft',
+    createdAt: frontmatter.created ? new Date(frontmatter.created) : new Date(),
+    updatedAt: frontmatter.updated ? new Date(frontmatter.updated) : new Date(),
+    filePath,
+  };
+
+  const requirement: Requirement = {
+    id: `req-${id}`,
+    specId: id,
+    title,
+    description,
+    type: 'functional',
+    priority: priorityMap[frontmatter.priority?.toLowerCase() || ''] || 'should',
+    acceptanceCriteria,
+    status: spec.status,
+    filePath,
+  };
+
+  const tasks = extractTasks(body, id, filePath);
+
+  return { spec, requirement, tasks };
+}
+
+/**
+ * Parse an ADR (Architecture Decision Record) markdown file
+ */
+export function parseADR(
+  content: string,
+  filePath: string
+): { spec: Spec; decision: DesignDecision } {
+  const { frontmatter, body } = parseFrontmatter(content);
+  const sections = extractSections(body);
+
+  const id = filePath.split('/').pop()?.replace('.md', '') || `adr-${Date.now()}`;
+
+  // Extract title
+  const titleMatch = body.match(/^#\s+(.+)$/m);
+  const title = frontmatter.title || titleMatch?.[1] || id;
+
+  // Extract sections
+  const context = sections.get('context') || sections.get('contexto') || '';
+  const decision = sections.get('decision') || sections.get('decisao') || sections.get('decisão') || '';
+  const consequencesSection = sections.get('consequences') || sections.get('consequencias') || sections.get('consequências') || '';
+  const alternativesSection = sections.get('alternatives') || sections.get('alternativas') || '';
+
+  const consequences = consequencesSection
+    .split('\n')
+    .filter(line => line.match(/^[-*]\s+/))
+    .map(line => line.replace(/^[-*]\s+/, '').trim());
+
+  const alternatives = alternativesSection
+    .split('\n')
+    .filter(line => line.match(/^[-*]\s+/))
+    .map(line => line.replace(/^[-*]\s+/, '').trim());
+
+  // Map status
+  const statusMap: Record<string, DesignDecision['status']> = {
+    'proposed': 'proposed',
+    'proposto': 'proposed',
+    'accepted': 'accepted',
+    'aceito': 'accepted',
+    'deprecated': 'deprecated',
+    'deprecado': 'deprecated',
+  };
+
+  const spec: Spec = {
+    id,
+    name: title,
+    description: context.slice(0, 200),
+    phase: 'design',
+    status: statusMap[frontmatter.status?.toLowerCase() || ''] === 'accepted' ? 'approved' : 'draft',
+    createdAt: frontmatter.created ? new Date(frontmatter.created) : new Date(),
+    updatedAt: frontmatter.updated ? new Date(frontmatter.updated) : new Date(),
+    filePath,
+  };
+
+  const designDecision: DesignDecision = {
+    id: `design-${id}`,
+    specId: id,
+    title,
+    context,
+    decision,
+    consequences,
+    alternatives: alternatives.length > 0 ? alternatives : undefined,
+    status: statusMap[frontmatter.status?.toLowerCase() || ''] || 'proposed',
+    filePath,
+  };
+
+  return { spec, decision: designDecision };
+}
+
+/**
+ * Determine spec type from file path
+ */
+export function getSpecType(filePath: string): 'story' | 'adr' | 'spec' | 'unknown' {
+  const lowerPath = filePath.toLowerCase();
+
+  if (lowerPath.includes('/stories/') || lowerPath.includes('us-')) {
+    return 'story';
+  }
+  if (lowerPath.includes('/decisions/') || lowerPath.includes('adr-') || lowerPath.includes('/adr/')) {
+    return 'adr';
+  }
+  if (lowerPath.includes('/specs/') || lowerPath.includes('/planning/')) {
+    return 'spec';
+  }
+
+  return 'unknown';
+}

package/web/lib/stores/autopilotStore.ts

@@ -0,0 +1,288 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+
+/**
+ * Autopilot Store - Terminal-based execution
+ * Agents run inside the terminal PTY with streaming output.
+ */
+
+export type AgentId = 'strategist' | 'architect' | 'system-designer' | 'builder' | 'guardian' | 'chronicler';
+export type PhaseStatus = 'pending' | 'running' | 'completed' | 'failed' | 'skipped';
+export type RunStatus = 'idle' | 'running' | 'completed' | 'failed';
+
+export interface PhaseResult {
+  agent: AgentId;
+  name: string;
+  status: PhaseStatus;
+  output?: string;
+  error?: string;
+  duration?: number;
+  tasksCompleted?: string[];
+}
+
+export interface AutopilotConfig {
+  phases: AgentId[];
+}
+
+// Default phases
+export const DEFAULT_PHASES: { id: AgentId; name: string }[] = [
+  { id: 'strategist', name: 'Planning' },
+  { id: 'architect', name: 'Design' },
+  { id: 'system-designer', name: 'System Design' },
+  { id: 'builder', name: 'Implementation' },
+  { id: 'guardian', name: 'Validation' },
+  { id: 'chronicler', name: 'Documentation' },
+];
+
+export const DEFAULT_CONFIG: AutopilotConfig = {
+  phases: ['strategist', 'architect', 'system-designer', 'builder', 'guardian', 'chronicler'],
+};
+
+interface AutopilotState {
+  // State
+  status: RunStatus;
+  currentPhaseIndex: number;
+  phases: PhaseResult[];
+  error: string | null;
+  specId: string | null;
+  specTitle: string | null;
+
+  // Terminal session for autopilot execution
+  terminalSessionId: string | null;
+
+  // Config modal
+  isConfigModalOpen: boolean;
+  selectedSpecId: string | null;
+  selectedSpecTitle: string | null;
+  selectedSpecContent: string | null;
+  selectedSpecFilePath: string | null;
+
+  // Actions
+  openConfigModal: (specId: string, specTitle: string, specContent: string, specFilePath?: string) => void;
+  closeConfigModal: () => void;
+  setTerminalSessionId: (sessionId: string) => void;
+  startRun: (config: AutopilotConfig, projectPath: string) => Promise<void>;
+  abortRun: () => Promise<void>;
+  reset: () => void;
+}
+
+export const useAutopilotStore = create<AutopilotState>()(
+  persist(
+    (set, get) => ({
+      status: 'idle',
+      currentPhaseIndex: -1,
+      phases: [],
+      error: null,
+      specId: null,
+      specTitle: null,
+      terminalSessionId: null,
+      isConfigModalOpen: false,
+      selectedSpecId: null,
+      selectedSpecTitle: null,
+      selectedSpecContent: null,
+      selectedSpecFilePath: null,
+
+      openConfigModal: (specId, specTitle, specContent, specFilePath) => {
+        set({
+          isConfigModalOpen: true,
+          selectedSpecId: specId,
+          selectedSpecTitle: specTitle,
+          selectedSpecContent: specContent,
+          selectedSpecFilePath: specFilePath || null,
+        });
+      },
+
+      closeConfigModal: () => {
+        set({
+          isConfigModalOpen: false,
+          selectedSpecId: null,
+          selectedSpecTitle: null,
+          selectedSpecContent: null,
+          selectedSpecFilePath: null,
+        });
+      },
+
+      setTerminalSessionId: (sessionId) => {
+        set({ terminalSessionId: sessionId });
+      },
+
+      startRun: async (config, projectPath) => {
+        const { selectedSpecId, selectedSpecTitle, selectedSpecContent, selectedSpecFilePath, terminalSessionId } = get();
+
+        if (!selectedSpecId || !selectedSpecTitle || !selectedSpecContent) {
+          throw new Error('No spec selected');
+        }
+
+        if (!terminalSessionId) {
+          throw new Error('No terminal session available. Open the terminal first.');
+        }
+
+        // Initialize phases
+        const initialPhases: PhaseResult[] = config.phases.map((agentId) => {
+          const phaseInfo = DEFAULT_PHASES.find((p) => p.id === agentId);
+          return {
+            agent: agentId,
+            name: phaseInfo?.name || agentId,
+            status: 'pending',
+          };
+        });
+
+        set({
+          status: 'running',
+          currentPhaseIndex: 0,
+          phases: initialPhases,
+          error: null,
+          specId: selectedSpecId,
+          specTitle: selectedSpecTitle,
+          isConfigModalOpen: false,
+        });
+
+        // Execute phases sequentially via terminal
+        let previousOutputs: string[] = [];
+
+        for (let i = 0; i < config.phases.length; i++) {
+          // Check if aborted
+          if (get().status !== 'running') return;
+
+          const agentId = config.phases[i];
+
+          // Update current phase to running
+          set((state) => ({
+            currentPhaseIndex: i,
+            phases: state.phases.map((p, idx) =>
+              idx === i ? { ...p, status: 'running' } : p
+            ),
+          }));
+
+          const startTime = Date.now();
+
+          try {
+            const response = await fetch('/api/autopilot/terminal-execute', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                sessionId: terminalSessionId,
+                agent: agentId,
+                specContent: selectedSpecContent,
+                specFilePath: selectedSpecFilePath,
+                previousOutputs,
+                projectPath,
+              }),
+            });
+
+            if (!response.ok) {
+              const errorData = await response.json().catch(() => ({ error: 'Unknown error' }));
+              throw new Error(errorData.error || `Phase ${agentId} failed`);
+            }
+
+            const result = await response.json();
+            const duration = Date.now() - startTime;
+
+            if (!result.success) {
+              throw new Error(result.error || `Phase ${agentId} failed`);
+            }
+
+            previousOutputs.push(result.output || '');
+
+            // Update phase as completed
+            set((state) => ({
+              phases: state.phases.map((p, idx) =>
+                idx === i
+                  ? {
+                      ...p,
+                      status: 'completed',
+                      output: result.output,
+                      duration,
+                      tasksCompleted: result.tasksCompleted || [],
+                    }
+                  : p
+              ),
+            }));
+
+          } catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+
+            // Update phase as failed
+            set((state) => ({
+              status: 'failed',
+              error: errorMessage,
+              phases: state.phases.map((p, idx) =>
+                idx === i
+                  ? { ...p, status: 'failed', error: errorMessage, duration }
+                  : idx > i
+                  ? { ...p, status: 'skipped' }
+                  : p
+              ),
+            }));
+
+            return; // Stop execution
+          }
+        }
+
+        // All phases completed
+        set({ status: 'completed' });
+      },
+
+      abortRun: async () => {
+        const { terminalSessionId, currentPhaseIndex } = get();
+
+        // Send Ctrl+C to the terminal to interrupt the current command
+        if (terminalSessionId) {
+          try {
+            await fetch('/api/terminal', {
+              method: 'POST',
+              headers: { 'Content-Type': 'application/json' },
+              body: JSON.stringify({
+                action: 'write',
+                sessionId: terminalSessionId,
+                data: '\x03', // Ctrl+C
+              }),
+            });
+          } catch {
+            // Ignore errors
+          }
+        }
+
+        // Mark current phase as failed, remaining as skipped
+        set((state) => ({
+          status: 'failed',
+          error: 'Aborted by user',
+          phases: state.phases.map((p, idx) =>
+            idx === currentPhaseIndex
+              ? { ...p, status: 'failed', error: 'Aborted' }
+              : idx > currentPhaseIndex
+              ? { ...p, status: 'skipped' }
+              : p
+          ),
+        }));
+      },
+
+      reset: () => {
+        set({
+          status: 'idle',
+          currentPhaseIndex: -1,
+          phases: [],
+          error: null,
+          specId: null,
+          specTitle: null,
+          terminalSessionId: null,
+          isConfigModalOpen: false,
+          selectedSpecId: null,
+          selectedSpecTitle: null,
+          selectedSpecContent: null,
+          selectedSpecFilePath: null,
+        });
+      },
+    }),
+    {
+      name: 'autopilot-storage',
+      partialize: (state) => ({
+        status: state.status,
+        phases: state.phases,
+        specId: state.specId,
+        specTitle: state.specTitle,
+      }),
+    }
+  )
+);