Codeium Configuration Setup: The Guide That Makes AI Code Suggestions Actually Useful

# docs/codeium-context.md
# Codeium AI Context Documentation

## Project Overview
**Name**: TaskFlow Management System  
**Tech Stack**: React 18 + TypeScript + Node.js + PostgreSQL  
**Architecture**: Modular monolith with microservice communication patterns  
**Deployment**: Docker containers on AWS ECS  

## Coding Standards
- **TypeScript**: Strict mode, explicit return types, no `any` types
- **React**: Functional components only, custom hooks for logic reuse
- **State Management**: Zustand for global state, React Query for server state
- **Styling**: Tailwind CSS with custom design system components
- **API**: RESTful endpoints with OpenAPI documentation
- **Testing**: Jest + React Testing Library, minimum 80% coverage

## Architecture Patterns
- Feature-based folder structure (not technology layers)
- Service layer pattern for business logic
- Repository pattern for data access
- Event-driven architecture for cross-feature communication
- Dependency injection through React Context

## Error Handling Conventions
- Custom error classes for different error types
- Centralized error logging with structured metadata
- User-friendly error messages with fallback defaults
- Graceful degradation for non-critical features

// docs/patterns/component-patterns.tsx
// Codeium Reference: Standard Component Patterns

import { FC, ReactNode } from 'react';
import { cn } from '@/utils/class-names';

// Standard props interface pattern
interface BaseComponentProps {
  className?: string;
  children?: ReactNode;
  testId?: string;
}

// Feature-specific props extend base props
interface ButtonProps extends BaseComponentProps {
  variant: 'primary' | 'secondary' | 'danger';
  size: 'sm' | 'md' | 'lg';
  disabled?: boolean;
  loading?: boolean;
  onClick?: () => void;
}

// Component implementation pattern
export const Button: FC = ({
  className,
  children,
  variant,
  size,
  disabled = false,
  loading = false,
  testId,
  onClick,
}) => {
  // Event handler pattern
  const handleClick = () => {
    if (disabled || loading) return;
    onClick?.();
  };

  return (
    
      {loading && }
      {children}
    
  );
};

// docs/patterns/api-patterns.ts
// Codeium Reference: API Integration Patterns

import { ApiResponse, PaginatedResponse } from '@/types/api';
import { apiClient } from '@/services/api-client';
import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';

// Query key factory pattern
export const taskQueries = {
  all: ['tasks'] as const,
  lists: () => [...taskQueries.all, 'list'] as const,
  list: (filters: TaskFilters) => [...taskQueries.lists(), filters] as const,
  details: () => [...taskQueries.all, 'detail'] as const,
  detail: (id: string) => [...taskQueries.details(), id] as const,
};

// Query hook pattern with error handling
export const useTasks = (filters: TaskFilters) => {
  return useQuery({
    queryKey: taskQueries.list(filters),
    queryFn: async (): Promise> => {
      try {
        const response = await apiClient.get('/api/tasks', {
          params: filters,
        });
        return response.data;
      } catch (error) {
        logger.error('Failed to fetch tasks', { error, filters });
        throw new ApiError('Failed to load tasks', error);
      }
    },
    staleTime: 5 * 60 * 1000, // 5 minutes
    gcTime: 10 * 60 * 1000, // 10 minutes
    retry: (failureCount, error) => {
      if (error instanceof ApiError && error.status === 404) {
        return false; // Don't retry on 404
      }
      return failureCount < 3;
    },
  });
};

// Mutation hook pattern with optimistic updates
export const useCreateTask = () => {
  const queryClient = useQueryClient();

  return useMutation({
    mutationFn: async (taskData: CreateTaskInput): Promise => {
      try {
        const response = await apiClient.post('/api/tasks', taskData);
        return response.data;
      } catch (error) {
        logger.error('Failed to create task', { error, taskData });
        throw new ApiError('Failed to create task', error);
      }
    },
    onMutate: async (newTask) => {
      // Cancel any outgoing refetches
      await queryClient.cancelQueries({ queryKey: taskQueries.lists() });

      // Optimistically update the cache
      const previousTasks = queryClient.getQueriesData({ 
        queryKey: taskQueries.lists() 
      });

      queryClient.setQueriesData(
        { queryKey: taskQueries.lists() },
        (old: PaginatedResponse | undefined) => {
          if (!old) return old;
          return {
            ...old,
            items: [
              { ...newTask, id: `temp-${Date.now()}`, ...newTask },
              ...old.items,
            ],
            total: old.total + 1,
          };
        }
      );

      return { previousTasks };
    },
    onError: (error, variables, context) => {
      // Rollback optimistic update
      if (context?.previousTasks) {
        context.previousTasks.forEach(([queryKey, data]) => {
          queryClient.setQueryData(queryKey, data);
        });
      }
      
      toast.error('Failed to create task');
    },
    onSuccess: (data) => {
      toast.success('Task created successfully');
      // Invalidate and refetch
      queryClient.invalidateQueries({ queryKey: taskQueries.lists() });
    },
  });
};

// .vscode/settings.json
{
  // Codeium-specific settings
  "codeium.enableCodeLens": true,
  "codeium.enableSearch": true,
  "codeium.enableChat": true,
  
  // File indexing configuration
  "codeium.indexing.enabled": true,
  "codeium.indexing.maxFileSize": 1048576, // 1MB
  "codeium.indexing.excludePatterns": [
    "**/node_modules/**",
    "**/dist/**",
    "**/build/**",
    "**/.git/**",
    "**/*.log",
    "**/coverage/**"
  ],
  
  // Suggestion behavior
  "codeium.suggest.enabled": true,
  "codeium.suggest.maxSuggestions": 3,
  "codeium.suggest.triggerCharacters": [
    ".", "(", "{", "[", "=", " ", "\n"
  ],
  
  // Language-specific enablement
  "codeium.enabledLanguages": [
    "typescript",
    "typescriptreact", 
    "javascript",
    "javascriptreact",
    "python",
    "go",
    "rust",
    "markdown"
  ],
  
  // Integration with other extensions
  "editor.inlineSuggest.enabled": true,
  "editor.inlineSuggest.showToolbar": "onHover",
  "editor.suggest.preview": true,
  "editor.suggest.showInlineDetails": true,
  
  // Performance optimizations
  "editor.suggest.maxVisibleSuggestions": 5,
  "editor.suggest.insertMode": "replace",
  "editor.quickSuggestionsDelay": 300
}

// docs/patterns/business-logic.ts
// Codeium Reference: Business Logic Patterns

// Domain entity validation pattern
export const validateTaskInput = (input: TaskInput): ValidationResult => {
  const errors: ValidationError[] = [];

  // Required field validation
  if (!input.title?.trim()) {
    errors.push({
      field: 'title',
      message: 'Task title is required',
    });
  }

  // Business rule validation
  if (input.priority === 'urgent' && !input.assigneeId) {
    errors.push({
      field: 'assigneeId',
      message: 'Urgent tasks must be assigned to someone',
    });
  }

  // Date validation
  if (input.dueDate && new Date(input.dueDate) < new Date()) {
    errors.push({
      field: 'dueDate',
      message: 'Due date cannot be in the past',
    });
  }

  return {
    isValid: errors.length === 0,
    errors,
  };
};

// Permission checking pattern
export const checkTaskPermission = (
  user: User,
  task: Task,
  action: TaskAction
): boolean => {
  // Admin can do everything
  if (user.role === 'admin') return true;

  // Task owner permissions
  if (task.createdBy === user.id) {
    return ['read', 'update', 'delete'].includes(action);
  }

  // Assignee permissions
  if (task.assigneeId === user.id) {
    return ['read', 'update', 'comment'].includes(action);
  }

  // Team member permissions
  if (task.teamId === user.teamId) {
    return ['read', 'comment'].includes(action);
  }

  return false;
};

// Audit logging pattern
export const auditTaskAction = async (
  userId: string,
  action: TaskAction,
  taskId: string,
  changes?: Record
): Promise => {
  try {
    await auditLogger.log({
      userId,
      action,
      resourceType: 'task',
      resourceId: taskId,
      timestamp: new Date().toISOString(),
      changes,
      userAgent: window.navigator.userAgent,
      ipAddress: await getUserIpAddress(),
    });
  } catch (error) {
    logger.error('Failed to log audit event', {
      error,
      userId,
      action,
      taskId,
    });
    // Don't throw - audit logging failures shouldn't break the main flow
  }
};

// .codeium/config.json
{
  "contextWindow": {
    "beforeCursor": {
      "lines": 50,
      "includeImports": true,
      "includeComments": false
    },
    "afterCursor": {
      "lines": 20,
      "includeFunction": true
    },
    "relatedFiles": {
      "maxFiles": 5,
      "preferSameDirectory": true,
      "includeTests": false,
      "weightByImports": true
    }
  },
  
  "filteringRules": {
    "excludePatterns": [
      "console\\.log\\(",
      "debugger;?",
      "TODO:",
      "FIXME:",
      "\\btest\\b.*\\("
    ],
    "preferPatterns": [
      "\\b(use[A-Z][a-zA-Z]*|[a-z]+Query|[a-z]+Mutation)\\b",
      "\\b(interface|type)\\s+[A-Z]",
      "\\bconst\\s+[a-zA-Z]+\\s*="
    ]
  },
  
  "suggestionRanking": {
    "prioritizeRecentEdits": true,
    "prioritizeFrequentPatterns": true,
    "prioritizeProjectSpecific": true,
    "penalizeGenericSuggestions": true
  }
}

# scripts/setup-codeium-team.sh
#!/bin/bash

echo "Setting up Codeium for team consistency..."

# Create shared configuration directories
mkdir -p .codeium/patterns
mkdir -p docs/codeium-context

# Copy team configurations
cp team-configs/codeium-config.json .codeium/
cp team-configs/vscode-settings.json .vscode/settings.json

# Set up pattern files
cp -r team-configs/patterns/* .codeium/patterns/
cp -r team-configs/context-docs/* docs/codeium-context/

# Create gitignore entries for personal overrides
echo "
# Codeium personal settings
.codeium/user-config.json
.codeium/personal-patterns/
" >> .gitignore

# Set up pre-commit hook to validate patterns
cp team-configs/pre-commit-codeium.sh .git/hooks/pre-commit
chmod +x .git/hooks/pre-commit

echo "✅ Codeium team setup complete!"
echo "Restart VS Code to apply changes"

// docs/patterns/react-typescript-patterns.tsx
// Codeium Reference: React + TypeScript Patterns

// Hook pattern with proper typing
export const useAsyncData = (
  fetchFn: () => Promise,
  dependencies: unknown[] = []
): {
  data: T | null;
  loading: boolean;
  error: Error | null;
  refetch: () => void;
} => {
  const [state, setState] = useState<{
    data: T | null;
    loading: boolean;
    error: Error | null;
  }>({
    data: null,
    loading: true,
    error: null,
  });

  const fetchData = useCallback(async () => {
    try {
      setState((prev) => ({ ...prev, loading: true, error: null }));
      const result = await fetchFn();
      setState({ data: result, loading: false, error: null });
    } catch (error) {
      setState({
        data: null,
        loading: false,
        error: error instanceof Error ? error : new Error('Unknown error'),
      });
    }
  }, [fetchFn]);

  useEffect(() => {
    fetchData();
  }, [fetchData, ...dependencies]);

  return {
    ...state,
    refetch: fetchData,
  };
};

// Context provider pattern with proper typing
interface ThemeContextValue {
  theme: 'light' | 'dark';
  toggleTheme: () => void;
}

const ThemeContext = createContext(null);

export const ThemeProvider: FC<{ children: ReactNode }> = ({ children }) => {
  const [theme, setTheme] = useState<'light' | 'dark'>('light');

  const toggleTheme = useCallback(() => {
    setTheme((prev) => (prev === 'light' ? 'dark' : 'light'));
  }, []);

  const value = useMemo(
    () => ({
      theme,
      toggleTheme,
    }),
    [theme, toggleTheme]
  );

  return (
    {children}
  );
};

export const useTheme = (): ThemeContextValue => {
  const context = useContext(ThemeContext);
  if (!context) {
    throw new Error('useTheme must be used within a ThemeProvider');
  }
  return context;
};

// docs/patterns/backend-patterns.ts
// Codeium Reference: Backend Patterns

// Controller pattern with error handling
export const createTaskController = async (
  req: Request,
  res: Response,
  next: NextFunction
): Promise => {
  try {
    const userId = req.user?.id;
    if (!userId) {
      throw new UnauthorizedError('User not authenticated');
    }

    const validationResult = validateTaskInput(req.body);
    if (!validationResult.isValid) {
      throw new ValidationError('Invalid task data', validationResult.errors);
    }

    const task = await taskService.createTask({
      ...req.body,
      createdBy: userId,
    });

    await auditLogger.logAction({
      userId,
      action: 'task.create',
      resourceId: task.id,
      metadata: { taskTitle: task.title },
    });

    res.status(201).json({
      success: true,
      data: task,
    });
  } catch (error) {
    next(error);
  }
};

// Service layer pattern
class TaskService {
  constructor(
    private taskRepository: TaskRepository,
    private notificationService: NotificationService
  ) {}

  async createTask(input: CreateTaskInput): Promise {
    const task = await this.taskRepository.create(input);

    // Send notifications asynchronously
    this.notificationService
      .notifyTaskCreated(task)
      .catch((error) => {
        logger.error('Failed to send task creation notification', {
          error,
          taskId: task.id,
        });
      });

    return task;
  }

  async updateTask(
    id: string,
    updates: UpdateTaskInput,
    userId: string
  ): Promise {
    const existingTask = await this.taskRepository.findById(id);
    if (!existingTask) {
      throw new NotFoundError('Task not found');
    }

    if (!checkTaskPermission(userId, existingTask, 'update')) {
      throw new ForbiddenError('Insufficient permissions');
    }

    const updatedTask = await this.taskRepository.update(id, updates);

    await this.auditTaskChanges(existingTask, updatedTask, userId);

    return updatedTask;
  }
}

# Analytics script for Codeium usage
{
  "suggestionMetrics": {
    "acceptanceRate": 0.68,
    "partialAcceptanceRate": 0.24,
    "rejectionRate": 0.08,
    "averageSuggestionLength": 42,
    "timeToAccept": "1.2s"
  },
  "productivityMetrics": {
    "keystrokesSaved": 3241,
    "timesSaved": "18 minutes",
    "linesOfCodePerHour": 156,
    "completionSpeed": "+31%"
  },
  "qualityMetrics": {
    "bugIntroductionRate": 0.03,
    "codeReviewPassRate": 0.87,
    "testCoverageImpact": "+5%",
    "patternConsistency": 0.91
  }
}

// Create a React hook that fetches user data with caching and error handling
// Should return data, loading state, error state, and refetch function
// Use React Query for caching with 5-minute stale time
// Handle 401 errors by redirecting to login
export const useUserData = (userId: string) => {
  // Codeium will suggest implementation based on this context
};