@evolve.labs/devflow 0.8.0

package/web/lib/git.ts

@@ -0,0 +1,339 @@
+import simpleGit, { SimpleGit, StatusResult, DiffResult, LogResult } from 'simple-git';
+
+export interface GitStatus {
+  isRepo: boolean;
+  branch: string;
+  ahead: number;
+  behind: number;
+  staged: GitFileChange[];
+  unstaged: GitFileChange[];
+  untracked: string[];
+  conflicted: string[];
+}
+
+export interface GitFileChange {
+  path: string;
+  status: 'added' | 'modified' | 'deleted' | 'renamed' | 'copied';
+  oldPath?: string;
+}
+
+export interface GitCommit {
+  hash: string;
+  hashShort: string;
+  author: string;
+  email: string;
+  date: string;
+  message: string;
+}
+
+export interface GitBranch {
+  name: string;
+  current: boolean;
+  commit: string;
+  label: string;
+}
+
+export interface GitDiff {
+  file: string;
+  additions: number;
+  deletions: number;
+  chunks: GitDiffChunk[];
+}
+
+export interface GitDiffChunk {
+  header: string;
+  lines: GitDiffLine[];
+}
+
+export interface GitDiffLine {
+  type: 'add' | 'delete' | 'context';
+  content: string;
+  oldLineNo?: number;
+  newLineNo?: number;
+}
+
+function mapFileStatus(index: string, workingDir: string): 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' {
+  const status = index !== ' ' ? index : workingDir;
+  switch (status) {
+    case 'A': return 'added';
+    case 'M': return 'modified';
+    case 'D': return 'deleted';
+    case 'R': return 'renamed';
+    case 'C': return 'copied';
+    default: return 'modified';
+  }
+}
+
+export async function getGitStatus(cwd: string): Promise<GitStatus> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) {
+      return {
+        isRepo: false,
+        branch: '',
+        ahead: 0,
+        behind: 0,
+        staged: [],
+        unstaged: [],
+        untracked: [],
+        conflicted: [],
+      };
+    }
+
+    const status: StatusResult = await git.status();
+
+    const staged: GitFileChange[] = [];
+    const unstaged: GitFileChange[] = [];
+
+    // Process files
+    status.files.forEach((file) => {
+      // Staged changes (index)
+      if (file.index !== ' ' && file.index !== '?') {
+        staged.push({
+          path: file.path,
+          status: mapFileStatus(file.index, ' '),
+        });
+      }
+
+      // Unstaged changes (working directory)
+      if (file.working_dir !== ' ' && file.working_dir !== '?') {
+        unstaged.push({
+          path: file.path,
+          status: mapFileStatus(' ', file.working_dir),
+        });
+      }
+    });
+
+    return {
+      isRepo: true,
+      branch: status.current || 'HEAD',
+      ahead: status.ahead,
+      behind: status.behind,
+      staged,
+      unstaged,
+      untracked: status.not_added,
+      conflicted: status.conflicted,
+    };
+  } catch (error) {
+    console.error('Git status error:', error);
+    return {
+      isRepo: false,
+      branch: '',
+      ahead: 0,
+      behind: 0,
+      staged: [],
+      unstaged: [],
+      untracked: [],
+      conflicted: [],
+    };
+  }
+}
+
+export async function getGitLog(cwd: string, maxCount: number = 50): Promise<GitCommit[]> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    const log: LogResult = await git.log({ maxCount });
+
+    return log.all.map((commit) => ({
+      hash: commit.hash,
+      hashShort: commit.hash.substring(0, 7),
+      author: commit.author_name,
+      email: commit.author_email,
+      date: commit.date,
+      message: commit.message,
+    }));
+  } catch (error) {
+    console.error('Git log error:', error);
+    return [];
+  }
+}
+
+export async function getGitBranches(cwd: string): Promise<GitBranch[]> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    const branches = await git.branchLocal();
+
+    return branches.all.map((name) => ({
+      name,
+      current: name === branches.current,
+      commit: branches.branches[name]?.commit || '',
+      label: branches.branches[name]?.label || name,
+    }));
+  } catch (error) {
+    console.error('Git branches error:', error);
+    return [];
+  }
+}
+
+export async function getGitDiff(cwd: string, file?: string, staged: boolean = false): Promise<string> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    const args = staged ? ['--cached'] : [];
+    if (file) {
+      args.push('--', file);
+    }
+
+    const diff = await git.diff(args);
+    return diff;
+  } catch (error) {
+    console.error('Git diff error:', error);
+    return '';
+  }
+}
+
+export async function gitStage(cwd: string, files: string[]): Promise<boolean> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    await git.add(files);
+    return true;
+  } catch (error) {
+    console.error('Git stage error:', error);
+    return false;
+  }
+}
+
+export async function gitUnstage(cwd: string, files: string[]): Promise<boolean> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    await git.reset(['HEAD', '--', ...files]);
+    return true;
+  } catch (error) {
+    console.error('Git unstage error:', error);
+    return false;
+  }
+}
+
+export async function gitCommit(cwd: string, message: string): Promise<{ success: boolean; hash?: string; error?: string }> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    const result = await git.commit(message);
+    return {
+      success: true,
+      hash: result.commit,
+    };
+  } catch (error) {
+    console.error('Git commit error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Commit failed',
+    };
+  }
+}
+
+export async function gitPush(cwd: string, remote: string = 'origin', branch?: string): Promise<{ success: boolean; error?: string }> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    const status = await git.status();
+    const targetBranch = branch || status.current || 'main';
+    await git.push(remote, targetBranch);
+    return { success: true };
+  } catch (error) {
+    console.error('Git push error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Push failed',
+    };
+  }
+}
+
+export async function gitPull(cwd: string, remote: string = 'origin', branch?: string): Promise<{ success: boolean; error?: string }> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    const status = await git.status();
+    const targetBranch = branch || status.current || 'main';
+    await git.pull(remote, targetBranch);
+    return { success: true };
+  } catch (error) {
+    console.error('Git pull error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Pull failed',
+    };
+  }
+}
+
+export async function gitCheckout(cwd: string, branch: string): Promise<{ success: boolean; error?: string }> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    await git.checkout(branch);
+    return { success: true };
+  } catch (error) {
+    console.error('Git checkout error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Checkout failed',
+    };
+  }
+}
+
+export async function gitCreateBranch(cwd: string, branch: string, checkout: boolean = true): Promise<{ success: boolean; error?: string }> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    if (checkout) {
+      await git.checkoutLocalBranch(branch);
+    } else {
+      await git.branch([branch]);
+    }
+    return { success: true };
+  } catch (error) {
+    console.error('Git create branch error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Create branch failed',
+    };
+  }
+}
+
+export async function gitDiscard(cwd: string, files: string[]): Promise<boolean> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    await git.checkout(['--', ...files]);
+    return true;
+  } catch (error) {
+    console.error('Git discard error:', error);
+    return false;
+  }
+}
+
+export async function gitInit(cwd: string): Promise<{ success: boolean; error?: string }> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    await git.init();
+    return { success: true };
+  } catch (error) {
+    console.error('Git init error:', error);
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : 'Init failed',
+    };
+  }
+}
+
+export async function getRemotes(cwd: string): Promise<{ name: string; url: string }[]> {
+  const git: SimpleGit = simpleGit(cwd);
+
+  try {
+    const remotes = await git.getRemotes(true);
+    return remotes.map((r) => ({
+      name: r.name,
+      url: r.refs.fetch || r.refs.push || '',
+    }));
+  } catch (error) {
+    console.error('Git remotes error:', error);
+    return [];
+  }
+}

package/web/lib/ptyManager.ts

@@ -0,0 +1,191 @@
+import * as pty from 'node-pty';
+import { EventEmitter } from 'events';
+import { PHASE_DONE_REGEX } from '@/lib/autopilotConstants';
+
+interface TerminalSession {
+  id: string;
+  pty: pty.IPty;
+  cwd: string;
+  createdAt: Date;
+}
+
+interface AutopilotCollector {
+  buffer: string;
+  resolve: (result: { output: string; exitCode: number }) => void;
+  reject: (error: Error) => void;
+  timeout: NodeJS.Timeout;
+}
+
+class PtyManager extends EventEmitter {
+  private sessions: Map<string, TerminalSession> = new Map();
+  private outputBuffers: Map<string, string[]> = new Map();
+  private autopilotCollectors: Map<string, AutopilotCollector> = new Map();
+
+  createSession(id: string, cwd: string, cols: number = 80, rows: number = 24): TerminalSession {
+    // Determine shell based on platform
+    const shell = process.platform === 'win32' ? 'powershell.exe' : process.env.SHELL || '/bin/zsh';
+    const shellArgs = process.platform === 'win32' ? [] : ['-l'];
+
+    const ptyProcess = pty.spawn(shell, shellArgs, {
+      name: 'xterm-256color',
+      cols,
+      rows,
+      cwd,
+      env: {
+        ...process.env,
+        TERM: 'xterm-256color',
+        COLORTERM: 'truecolor',
+      },
+    });
+
+    const session: TerminalSession = {
+      id,
+      pty: ptyProcess,
+      cwd,
+      createdAt: new Date(),
+    };
+
+    this.sessions.set(id, session);
+    this.outputBuffers.set(id, []);
+
+    // Handle data from PTY
+    ptyProcess.onData((data) => {
+      const buffer = this.outputBuffers.get(id);
+      if (buffer) {
+        buffer.push(data);
+        // Keep buffer size manageable
+        if (buffer.length > 1000) {
+          buffer.shift();
+        }
+      }
+
+      // Check autopilot collector for completion marker
+      const collector = this.autopilotCollectors.get(id);
+      if (collector) {
+        collector.buffer += data;
+        const markerMatch = collector.buffer.match(PHASE_DONE_REGEX);
+        if (markerMatch) {
+          const exitCode = parseInt(markerMatch[1], 10);
+          // Extract output before the marker
+          const output = collector.buffer.split(PHASE_DONE_REGEX)[0];
+          clearTimeout(collector.timeout);
+          this.autopilotCollectors.delete(id);
+          this.emit('autopilot-phase-done', { sessionId: id, output, exitCode });
+          collector.resolve({ output, exitCode });
+        }
+      }
+
+      this.emit('data', { sessionId: id, data });
+    });
+
+    // Handle PTY exit
+    ptyProcess.onExit(({ exitCode }) => {
+      // If there's an active collector, reject it
+      const collector = this.autopilotCollectors.get(id);
+      if (collector) {
+        clearTimeout(collector.timeout);
+        this.autopilotCollectors.delete(id);
+        collector.reject(new Error(`Terminal exited with code ${exitCode} during autopilot phase`));
+      }
+
+      this.emit('exit', { sessionId: id, exitCode });
+      this.sessions.delete(id);
+      this.outputBuffers.delete(id);
+    });
+
+    return session;
+  }
+
+  getSession(id: string): TerminalSession | undefined {
+    return this.sessions.get(id);
+  }
+
+  write(id: string, data: string): boolean {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.pty.write(data);
+      return true;
+    }
+    return false;
+  }
+
+  resize(id: string, cols: number, rows: number): boolean {
+    const session = this.sessions.get(id);
+    if (session) {
+      session.pty.resize(cols, rows);
+      return true;
+    }
+    return false;
+  }
+
+  destroySession(id: string): boolean {
+    const session = this.sessions.get(id);
+    if (session) {
+      // Clean up any active collector
+      const collector = this.autopilotCollectors.get(id);
+      if (collector) {
+        clearTimeout(collector.timeout);
+        this.autopilotCollectors.delete(id);
+        collector.reject(new Error('Session destroyed'));
+      }
+
+      session.pty.kill();
+      this.sessions.delete(id);
+      this.outputBuffers.delete(id);
+      return true;
+    }
+    return false;
+  }
+
+  getOutputBuffer(id: string): string[] {
+    return this.outputBuffers.get(id) || [];
+  }
+
+  clearOutputBuffer(id: string): void {
+    const buffer = this.outputBuffers.get(id);
+    if (buffer) {
+      buffer.length = 0;
+    }
+  }
+
+  getActiveSessions(): string[] {
+    return Array.from(this.sessions.keys());
+  }
+
+  /**
+   * Arm an autopilot collector for a terminal session.
+   * Returns a Promise that resolves when the completion marker is detected in the output.
+   */
+  armAutopilotCollector(sessionId: string, timeoutMs: number): Promise<{ output: string; exitCode: number }> {
+    // Disarm any existing collector
+    this.disarmAutopilotCollector(sessionId);
+
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.autopilotCollectors.delete(sessionId);
+        reject(new Error(`Autopilot phase timed out after ${Math.round(timeoutMs / 1000)}s`));
+      }, timeoutMs);
+
+      this.autopilotCollectors.set(sessionId, {
+        buffer: '',
+        resolve,
+        reject,
+        timeout,
+      });
+    });
+  }
+
+  /**
+   * Disarm (cancel) an active autopilot collector for a session.
+   */
+  disarmAutopilotCollector(sessionId: string): void {
+    const collector = this.autopilotCollectors.get(sessionId);
+    if (collector) {
+      clearTimeout(collector.timeout);
+      this.autopilotCollectors.delete(sessionId);
+    }
+  }
+}
+
+// Singleton instance
+export const ptyManager = new PtyManager();