@evolve.labs/devflow 0.8.0

package/web/lib/stores/gitStore.ts

@@ -0,0 +1,386 @@
+import { create } from 'zustand';
+import { toast } from 'sonner';
+import type { GitStatus, GitCommit, GitBranch } from '@/lib/git';
+
+interface GitState {
+  // State
+  status: GitStatus | null;
+  commits: GitCommit[];
+  branches: GitBranch[];
+  isLoading: boolean;
+  error: string | null;
+  selectedFiles: Set<string>;
+  diffContent: string | null;
+  diffFile: string | null;
+
+  // Actions
+  fetchStatus: (projectPath: string) => Promise<void>;
+  fetchLog: (projectPath: string, maxCount?: number) => Promise<void>;
+  fetchBranches: (projectPath: string) => Promise<void>;
+  fetchDiff: (projectPath: string, file?: string, staged?: boolean) => Promise<void>;
+  stageFiles: (projectPath: string, files: string[]) => Promise<boolean>;
+  unstageFiles: (projectPath: string, files: string[]) => Promise<boolean>;
+  stageAll: (projectPath: string) => Promise<boolean>;
+  unstageAll: (projectPath: string) => Promise<boolean>;
+  commit: (projectPath: string, message: string) => Promise<{ success: boolean; hash?: string; error?: string }>;
+  push: (projectPath: string) => Promise<{ success: boolean; error?: string }>;
+  pull: (projectPath: string) => Promise<{ success: boolean; error?: string }>;
+  checkout: (projectPath: string, branch: string) => Promise<{ success: boolean; error?: string }>;
+  createBranch: (projectPath: string, branch: string) => Promise<{ success: boolean; error?: string }>;
+  discardChanges: (projectPath: string, files: string[]) => Promise<boolean>;
+  initRepo: (projectPath: string) => Promise<{ success: boolean; error?: string }>;
+  toggleFileSelection: (file: string) => void;
+  selectAllFiles: (files: string[]) => void;
+  clearSelection: () => void;
+  clearDiff: () => void;
+  setError: (error: string | null) => void;
+}
+
+export const useGitStore = create<GitState>((set, get) => ({
+  // Initial state
+  status: null,
+  commits: [],
+  branches: [],
+  isLoading: false,
+  error: null,
+  selectedFiles: new Set(),
+  diffContent: null,
+  diffFile: null,
+
+  // Actions
+  fetchStatus: async (projectPath: string) => {
+    set({ isLoading: true, error: null });
+    try {
+      const response = await fetch(`/api/git?action=status&projectPath=${encodeURIComponent(projectPath)}`);
+      if (!response.ok) throw new Error('Failed to fetch status');
+      const status = await response.json();
+      set({ status, isLoading: false });
+    } catch (error) {
+      set({ error: error instanceof Error ? error.message : 'Failed to fetch status', isLoading: false });
+    }
+  },
+
+  fetchLog: async (projectPath: string, maxCount: number = 50) => {
+    try {
+      const response = await fetch(`/api/git?action=log&projectPath=${encodeURIComponent(projectPath)}&maxCount=${maxCount}`);
+      if (!response.ok) throw new Error('Failed to fetch log');
+      const { commits } = await response.json();
+      set({ commits });
+    } catch (error) {
+      set({ error: error instanceof Error ? error.message : 'Failed to fetch log' });
+    }
+  },
+
+  fetchBranches: async (projectPath: string) => {
+    try {
+      const response = await fetch(`/api/git?action=branches&projectPath=${encodeURIComponent(projectPath)}`);
+      if (!response.ok) throw new Error('Failed to fetch branches');
+      const { branches } = await response.json();
+      set({ branches });
+    } catch (error) {
+      set({ error: error instanceof Error ? error.message : 'Failed to fetch branches' });
+    }
+  },
+
+  fetchDiff: async (projectPath: string, file?: string, staged: boolean = false) => {
+    try {
+      let url = `/api/git?action=diff&projectPath=${encodeURIComponent(projectPath)}&staged=${staged}`;
+      if (file) {
+        url += `&file=${encodeURIComponent(file)}`;
+      }
+      const response = await fetch(url);
+      if (!response.ok) throw new Error('Failed to fetch diff');
+      const { diff } = await response.json();
+      set({ diffContent: diff, diffFile: file || null });
+    } catch (error) {
+      set({ error: error instanceof Error ? error.message : 'Failed to fetch diff' });
+    }
+  },
+
+  stageFiles: async (projectPath: string, files: string[]) => {
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'stage', projectPath, files }),
+      });
+      if (!response.ok) throw new Error('Failed to stage files');
+      const { success } = await response.json();
+      if (success) {
+        await get().fetchStatus(projectPath);
+      }
+      return success;
+    } catch (error) {
+      set({ error: error instanceof Error ? error.message : 'Failed to stage files' });
+      return false;
+    }
+  },
+
+  unstageFiles: async (projectPath: string, files: string[]) => {
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'unstage', projectPath, files }),
+      });
+      if (!response.ok) throw new Error('Failed to unstage files');
+      const { success } = await response.json();
+      if (success) {
+        await get().fetchStatus(projectPath);
+      }
+      return success;
+    } catch (error) {
+      set({ error: error instanceof Error ? error.message : 'Failed to unstage files' });
+      return false;
+    }
+  },
+
+  stageAll: async (projectPath: string) => {
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'stageAll', projectPath }),
+      });
+      if (!response.ok) throw new Error('Failed to stage all');
+      const { success } = await response.json();
+      if (success) {
+        await get().fetchStatus(projectPath);
+      }
+      return success;
+    } catch (error) {
+      set({ error: error instanceof Error ? error.message : 'Failed to stage all' });
+      return false;
+    }
+  },
+
+  unstageAll: async (projectPath: string) => {
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'unstageAll', projectPath }),
+      });
+      if (!response.ok) throw new Error('Failed to unstage all');
+      const { success } = await response.json();
+      if (success) {
+        await get().fetchStatus(projectPath);
+      }
+      return success;
+    } catch (error) {
+      set({ error: error instanceof Error ? error.message : 'Failed to unstage all' });
+      return false;
+    }
+  },
+
+  commit: async (projectPath: string, message: string) => {
+    set({ isLoading: true });
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'commit', projectPath, message }),
+      });
+      if (!response.ok) throw new Error('Failed to commit');
+      const result = await response.json();
+      if (result.success) {
+        await get().fetchStatus(projectPath);
+        await get().fetchLog(projectPath);
+        toast.success('Changes committed', {
+          description: message.substring(0, 50) + (message.length > 50 ? '...' : ''),
+        });
+      }
+      set({ isLoading: false });
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Failed to commit';
+      set({ error: errorMsg, isLoading: false });
+      toast.error('Commit failed', { description: errorMsg });
+      return { success: false, error: errorMsg };
+    }
+  },
+
+  push: async (projectPath: string) => {
+    set({ isLoading: true });
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'push', projectPath }),
+      });
+      if (!response.ok) throw new Error('Failed to push');
+      const result = await response.json();
+      if (result.success) {
+        await get().fetchStatus(projectPath);
+        toast.success('Pushed to remote', {
+          description: 'Changes uploaded successfully',
+        });
+      }
+      set({ isLoading: false });
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Failed to push';
+      set({ error: errorMsg, isLoading: false });
+      toast.error('Push failed', { description: errorMsg });
+      return { success: false, error: errorMsg };
+    }
+  },
+
+  pull: async (projectPath: string) => {
+    set({ isLoading: true });
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'pull', projectPath }),
+      });
+      if (!response.ok) throw new Error('Failed to pull');
+      const result = await response.json();
+      if (result.success) {
+        await get().fetchStatus(projectPath);
+        await get().fetchLog(projectPath);
+        toast.success('Pulled from remote', {
+          description: 'Changes downloaded successfully',
+        });
+      }
+      set({ isLoading: false });
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Failed to pull';
+      set({ error: errorMsg, isLoading: false });
+      toast.error('Pull failed', { description: errorMsg });
+      return { success: false, error: errorMsg };
+    }
+  },
+
+  checkout: async (projectPath: string, branch: string) => {
+    set({ isLoading: true });
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'checkout', projectPath, branch }),
+      });
+      if (!response.ok) throw new Error('Failed to checkout');
+      const result = await response.json();
+      if (result.success) {
+        await get().fetchStatus(projectPath);
+        await get().fetchBranches(projectPath);
+        toast.success('Branch switched', {
+          description: `Now on ${branch}`,
+        });
+      }
+      set({ isLoading: false });
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Failed to checkout';
+      set({ error: errorMsg, isLoading: false });
+      toast.error('Checkout failed', { description: errorMsg });
+      return { success: false, error: errorMsg };
+    }
+  },
+
+  createBranch: async (projectPath: string, branch: string) => {
+    set({ isLoading: true });
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'createBranch', projectPath, branch }),
+      });
+      if (!response.ok) throw new Error('Failed to create branch');
+      const result = await response.json();
+      if (result.success) {
+        await get().fetchStatus(projectPath);
+        await get().fetchBranches(projectPath);
+        toast.success('Branch created', {
+          description: branch,
+        });
+      }
+      set({ isLoading: false });
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Failed to create branch';
+      set({ error: errorMsg, isLoading: false });
+      toast.error('Create branch failed', { description: errorMsg });
+      return { success: false, error: errorMsg };
+    }
+  },
+
+  discardChanges: async (projectPath: string, files: string[]) => {
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'discard', projectPath, files }),
+      });
+      if (!response.ok) throw new Error('Failed to discard changes');
+      const { success } = await response.json();
+      if (success) {
+        await get().fetchStatus(projectPath);
+        toast.success('Changes discarded', {
+          description: `${files.length} file${files.length > 1 ? 's' : ''} reverted`,
+        });
+      }
+      return success;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Failed to discard changes';
+      set({ error: errorMsg });
+      toast.error('Discard failed', { description: errorMsg });
+      return false;
+    }
+  },
+
+  initRepo: async (projectPath: string) => {
+    set({ isLoading: true });
+    try {
+      const response = await fetch('/api/git', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ action: 'init', projectPath }),
+      });
+      if (!response.ok) throw new Error('Failed to init repo');
+      const result = await response.json();
+      if (result.success) {
+        await get().fetchStatus(projectPath);
+        toast.success('Repository initialized', {
+          description: 'Git repository created successfully',
+        });
+      }
+      set({ isLoading: false });
+      return result;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : 'Failed to init repo';
+      set({ error: errorMsg, isLoading: false });
+      toast.error('Init failed', { description: errorMsg });
+      return { success: false, error: errorMsg };
+    }
+  },
+
+  toggleFileSelection: (file: string) => {
+    const { selectedFiles } = get();
+    const newSelection = new Set(selectedFiles);
+    if (newSelection.has(file)) {
+      newSelection.delete(file);
+    } else {
+      newSelection.add(file);
+    }
+    set({ selectedFiles: newSelection });
+  },
+
+  selectAllFiles: (files: string[]) => {
+    set({ selectedFiles: new Set(files) });
+  },
+
+  clearSelection: () => {
+    set({ selectedFiles: new Set() });
+  },
+
+  clearDiff: () => {
+    set({ diffContent: null, diffFile: null });
+  },
+
+  setError: (error: string | null) => {
+    set({ error });
+  },
+}));

package/web/lib/stores/projectStore.ts

@@ -0,0 +1,196 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import type { ProjectInfo, HealthStatus } from '@/lib/types';
+
+interface RecentProject {
+  path: string;
+  name: string;
+  lastOpened: Date;
+}
+
+interface ProjectState {
+  // State
+  projects: ProjectInfo[];
+  activeProjectPath: string | null;
+  currentProject: ProjectInfo | null; // Derived from projects + activeProjectPath
+  recentProjects: RecentProject[];
+  health: HealthStatus | null;
+  isLoading: boolean;
+  error: string | null;
+
+  // Actions
+  addProject: (path: string) => Promise<void>;
+  removeProject: (path: string) => void;
+  setActiveProject: (path: string) => void;
+  openProject: (path: string) => Promise<void>;
+  restoreProjects: () => Promise<void>;
+  closeProject: () => void;
+  refreshHealth: () => Promise<void>;
+  setError: (error: string | null) => void;
+}
+
+function deriveCurrentProject(projects: ProjectInfo[], activeProjectPath: string | null): ProjectInfo | null {
+  if (!activeProjectPath) return projects[0] || null;
+  return projects.find(p => p.path === activeProjectPath) || projects[0] || null;
+}
+
+export const useProjectStore = create<ProjectState>()(
+  persist(
+    (set, get) => ({
+      projects: [],
+      activeProjectPath: null,
+      currentProject: null,
+      recentProjects: [],
+      health: null,
+      isLoading: false,
+      error: null,
+
+      addProject: async (projectPath: string) => {
+        const existing = get().projects;
+        // If already added, just activate it
+        if (existing.some(p => p.path === projectPath)) {
+          set({
+            activeProjectPath: projectPath,
+            currentProject: deriveCurrentProject(existing, projectPath),
+          });
+          return;
+        }
+
+        set({ isLoading: true, error: null });
+
+        try {
+          const response = await fetch('/api/project/open', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ path: projectPath }),
+          });
+
+          const data = await response.json();
+
+          if (!response.ok) {
+            throw new Error(data.error || 'Failed to open project');
+          }
+
+          const project = data.project as ProjectInfo;
+
+          // Update recent projects
+          const recentProjects = get().recentProjects.filter(
+            (p) => p.path !== projectPath
+          );
+          recentProjects.unshift({
+            path: projectPath,
+            name: project.name,
+            lastOpened: new Date(),
+          });
+          if (recentProjects.length > 10) {
+            recentProjects.pop();
+          }
+
+          const newProjects = [...get().projects, project];
+
+          set({
+            projects: newProjects,
+            activeProjectPath: projectPath,
+            currentProject: deriveCurrentProject(newProjects, projectPath),
+            recentProjects,
+            isLoading: false,
+          });
+
+          get().refreshHealth();
+        } catch (error) {
+          set({
+            error: error instanceof Error ? error.message : 'Unknown error',
+            isLoading: false,
+          });
+        }
+      },
+
+      removeProject: (projectPath: string) => {
+        const newProjects = get().projects.filter(p => p.path !== projectPath);
+        const newActive = get().activeProjectPath === projectPath
+          ? (newProjects[0]?.path || null)
+          : get().activeProjectPath;
+
+        set({
+          projects: newProjects,
+          activeProjectPath: newActive,
+          currentProject: deriveCurrentProject(newProjects, newActive),
+        });
+      },
+
+      setActiveProject: (projectPath: string) => {
+        set({
+          activeProjectPath: projectPath,
+          currentProject: deriveCurrentProject(get().projects, projectPath),
+        });
+      },
+
+      // Backward-compatible alias
+      openProject: async (path: string) => {
+        await get().addProject(path);
+      },
+
+      restoreProjects: async () => {
+        // Read persisted paths from localStorage (saved by partialize)
+        try {
+          const raw = localStorage.getItem('devflow-project-store');
+          if (!raw) return;
+          const stored = JSON.parse(raw);
+          const paths: string[] = stored.state?.projectPaths || [];
+          const savedActive: string | null = stored.state?.activeProjectPath || null;
+
+          if (paths.length === 0) return;
+
+          // Restore each project sequentially to avoid race conditions
+          for (const p of paths) {
+            await get().addProject(p);
+          }
+
+          // Restore the active project (addProject sets it to the last added)
+          if (savedActive && get().projects.some(proj => proj.path === savedActive)) {
+            get().setActiveProject(savedActive);
+          }
+        } catch {
+          // Ignore restoration errors
+        }
+      },
+
+      closeProject: () => {
+        set({
+          projects: [],
+          activeProjectPath: null,
+          currentProject: null,
+          health: null,
+          error: null,
+        });
+      },
+
+      refreshHealth: async () => {
+        const project = get().currentProject;
+        if (!project) return;
+
+        try {
+          const response = await fetch(
+            `/api/health?projectPath=${encodeURIComponent(project.path)}`
+          );
+          const health = await response.json();
+          set({ health });
+        } catch (error) {
+          console.error('Failed to fetch health:', error);
+        }
+      },
+
+      setError: (error) => {
+        set({ error });
+      },
+    }),
+    {
+      name: 'devflow-project-store',
+      partialize: (state) => ({
+        recentProjects: state.recentProjects,
+        projectPaths: state.projects.map(p => p.path),
+        activeProjectPath: state.activeProjectPath,
+      }),
+    }
+  )
+);

package/web/lib/stores/settingsStore.ts

@@ -0,0 +1,126 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import { toast } from 'sonner';
+
+/**
+ * Settings Store - Gerencia todas as configurações do DevFlow IDE
+ * Persistido em localStorage para manter preferências entre sessões
+ */
+
+export type TabSize = 2 | 4 | 8;
+export type ChatModel = 'sonnet' | 'opus' | 'auto';
+export type PermissionMode = 'default' | 'acceptEdits' | 'bypassPermissions';
+
+interface SettingsState {
+  // Editor Settings
+  editorFontSize: number;
+  editorTabSize: TabSize;
+  editorWordWrap: boolean;
+  editorMinimap: boolean;
+  editorLineNumbers: boolean;
+
+  // Terminal Settings
+  terminalFontSize: number;
+
+  // Chat Settings
+  chatDefaultModel: ChatModel;
+  chatDefaultAgent: string | null;
+  chatPermissionMode: PermissionMode;
+
+  // General Settings
+  autoSave: boolean;
+  autoSaveDelay: number;
+
+  // Settings Panel State
+  isSettingsOpen: boolean;
+  activeSettingsTab: 'general' | 'editor' | 'terminal' | 'chat' | 'keyboard';
+
+  // Actions
+  setSetting: <K extends keyof SettingsValues>(key: K, value: SettingsValues[K]) => void;
+  resetToDefaults: () => void;
+  openSettings: () => void;
+  closeSettings: () => void;
+  setActiveSettingsTab: (tab: SettingsState['activeSettingsTab']) => void;
+}
+
+// Type helper for settings values only (excludes actions and UI state)
+type SettingsValues = Omit<SettingsState,
+  'setSetting' | 'resetToDefaults' | 'openSettings' | 'closeSettings' |
+  'setActiveSettingsTab' | 'isSettingsOpen' | 'activeSettingsTab'
+>;
+
+const DEFAULT_SETTINGS: SettingsValues = {
+  // Editor
+  editorFontSize: 14,
+  editorTabSize: 2,
+  editorWordWrap: true,
+  editorMinimap: false,
+  editorLineNumbers: true,
+
+  // Terminal
+  terminalFontSize: 13,
+
+  // Chat
+  chatDefaultModel: 'sonnet',
+  chatDefaultAgent: null,
+  chatPermissionMode: 'acceptEdits',
+
+  // General
+  autoSave: true,
+  autoSaveDelay: 1000,
+};
+
+export const useSettingsStore = create<SettingsState>()(
+  persist(
+    (set) => ({
+      ...DEFAULT_SETTINGS,
+
+      // UI State (não persistido)
+      isSettingsOpen: false,
+      activeSettingsTab: 'general',
+
+      setSetting: (key, value) => {
+        set({ [key]: value } as Partial<SettingsState>);
+      },
+
+      resetToDefaults: () => {
+        set(DEFAULT_SETTINGS);
+        toast.success('Settings reset', {
+          description: 'All settings restored to defaults',
+        });
+      },
+
+      openSettings: () => {
+        set({ isSettingsOpen: true });
+      },
+
+      closeSettings: () => {
+        set({ isSettingsOpen: false });
+      },
+
+      setActiveSettingsTab: (tab) => {
+        set({ activeSettingsTab: tab });
+      },
+    }),
+    {
+      name: 'devflow-settings',
+      // Não persistir estado da UI
+      partialize: (state) => ({
+        editorFontSize: state.editorFontSize,
+        editorTabSize: state.editorTabSize,
+        editorWordWrap: state.editorWordWrap,
+        editorMinimap: state.editorMinimap,
+        editorLineNumbers: state.editorLineNumbers,
+        terminalFontSize: state.terminalFontSize,
+        chatDefaultModel: state.chatDefaultModel,
+        chatDefaultAgent: state.chatDefaultAgent,
+        chatPermissionMode: state.chatPermissionMode,
+        autoSave: state.autoSave,
+        autoSaveDelay: state.autoSaveDelay,
+      }),
+    }
+  )
+);
+
+// Export default settings for reference
+export { DEFAULT_SETTINGS };