find ./src -type f \( -name "*.tsx" -o -name "*.jsx" -o -name "*.js" -o -name "*.ts" -o -name "*.css" -o -name "*.scss" -o -name "*.md" \) | xargs wc -l

/**
 * Analyzes code using the Ollama API and returns a description and suggestions.
 * If the analysis is valid JSON, it is inserted into the AiDescriptions table.
 * @param code The code snippet to analyze.
 * @param language The programming language of the code.
 * @param postId (optional) The ID of the post being analyzed.
 * @returns An object containing description and suggestions.
 */
async function analyzeCodeWithOllama(
  code: string,
  language: string,
  postId?: string
): Promise<CodeAnalysisResponse> {
  if (!code || !language) {
    throw new Error('Code and language are required');
  }
  try {
    const prompt = createPrompt(code, language);
    const response: AxiosResponse = await axios.post(OLLAMA_API_URL, {
      model: MODEL_NAME,
      prompt,
      stream: false,
      think: false,
    });
    console.log('Raw Ollama response:', JSON.stringify(response.data, null, 2));
    let analysis: CodeAnalysisResponse;
    try {
      const responseText = typeof response.data === 'string' ? response.data : response.data.response || JSON.stringify(response.data);
      const jsonMatch = responseText.match(/{[\s\S]*}/);
      if (jsonMatch) {
        analysis = JSON.parse(jsonMatch[0]);
        // If valid JSON and postId is provided, insert into DB
        if (postId && analysis.description) {
          try {
            await insertAiDescription(postId, analysis.description, analysis.suggestions, new Date().toISOString());
          } catch (dbErr: any) {
            console.error(`Failed to insert AI description for post ${postId}:`, dbErr.message);
          }
        }
      } else {
        throw new Error('No valid JSON found in response');
      }
    } catch (parseError) {
      console.error('Error parsing Ollama response:', parseError, 'Response:', response.data);
      throw new Error('Failed to parse model response');
    }
    if (!analysis.description || !Array.isArray(analysis.suggestions)) {
      console.error('Invalid response format:', analysis);
      throw new Error('Invalid response format from model');
    }
    return analysis;
  } catch (error: any) {
    console.error('Error communicating with Ollama:', error.message);
    throw new Error('Failed to analyze code: ' + error.message);
  }
}

// theme.ts
import { createTheme } from '@mui/material/styles';

const theme = createTheme({
  typography: {
    h1: {
      fontSize: '2rem',
      fontWeight: 700,
      lineHeight: 1.3
    },
    h2: {
      fontSize: '1.625rem',
      fontWeight: 700,
      lineHeight: 1.35
    },
    h3: {
      fontSize: '1.375rem',
      fontWeight: 700,
      lineHeight: 1.4
    },
    h4: {
      fontSize: '1.125rem',
      fontWeight: 700,
      lineHeight: 1.45
    },
    h5: {
      fontSize: '1rem',
      fontWeight: 700,
      lineHeight: 1.5
    },
    h6: {
      fontSize: '0.875rem',
      fontWeight: 700,
      lineHeight: 1.5
    },
  },
});

[*.cs]
indent_style = space
indent_size = 2
tab_width = 2
csharp_new_line_before_open_brace = none

fdsfdfdsfa


d
d
d
d
d
d
d
dfsfdsdddfffd

import React from 'react';

const HIDDEN_CELLS = [[1, 1], [1, 2]]
const GRID_SIZE = 4;

export default function App() {
    const [selected, setSelected] = React.useState([]);
    
    const grid = Array.from({ length: GRID_SIZE }).fill(Array.from({ length: GRID_SIZE }).fill(false))

    const handleCellClick = (i, j) => {
        const updatedSelected = [...selected, [i, j]];
        setSelected(updatedSelected);

        const allCellsSelected = updatedSelected.length === (GRID_SIZE ** 2) - HIDDEN_CELLS.length;
        if(allCellsSelected) {
            updatedSelected.forEach((_, index) => {
                setTimeout(() => {
                    setSelected(updatedSelected.slice(0, updatedSelected.length - index - 1))
                }, 500 * (index + 1))
            })
        }
    }
    
    return (
        <div
            style={{
                display: 'grid',
                gridTemplateColumns: `repeat(${GRID_SIZE}, 1fr)`,
                gap: '8px',
                width: 'fit-content'
            }}
        >
            {grid.map((row, i) => row.map((cell, j) => {
                const isHidden = !!HIDDEN_CELLS.find(cell => cell[0] === i && cell[1] === j);
                const isSelected = !!selected.find(cell => cell[0] === i && cell[1] === j);
                return (
                    <div
                        style={{
                            width: 50,
                            height: 50,
                            border: '1px solid black',
                            cursor: 'pointer',
                            visibility: isHidden ? 'hidden' : 'visible',
                            backgroundColor: isSelected ? 'green' : 'transparent'
                        }}
                        onClick={() => handleCellClick(i, j)}
                    />
                )
            }))}
        </div>
    )
}