--- a
+++ b/web/assets/js/api-client.js
@@ -0,0 +1,268 @@
+/**
+ * DNAnalyzer API Client
+ * 
+ * This module provides functions to interact with the DNAnalyzer API endpoints.
+ * It enables the website to access the core DNAnalyzer features through a unified interface.
+ * 
+ * @version 1.0.0
+ */
+
+const DNAnalyzerAPI = {
+    // Base URL for API requests - configurable for different environments
+    baseUrl: 'http://localhost:8080/api/v1',
+
+    /**
+     * Set the base URL for the API
+     * @param {string} url - The base URL for the API
+     */
+    setBaseUrl(url) {
+        this.baseUrl = url;
+    },
+
+    /**
+     * Check if the API is online
+     * @returns {Promise<Object>} - API status information
+     */
+    async checkStatus() {
+        try {
+            const response = await fetch(`${this.baseUrl}/status`);
+            if (!response.ok) {
+                throw new Error('API status check failed');
+            }
+            return await response.json();
+        } catch (error) {
+            console.error('API status check error:', error);
+            throw error;
+        }
+    },
+
+    /**
+     * Analyze a DNA file with various options
+     * @param {File} dnaFile - The DNA file to analyze
+     * @param {Object} options - Analysis options
+     * @returns {Promise<Object>} - Analysis results
+     */
+    async analyzeDNA(dnaFile, options = {}) {
+        try {
+            const formData = new FormData();
+            formData.append('dnaFile', dnaFile);
+            
+            // Add options to form data
+            if (options.amino) formData.append('amino', options.amino);
+            if (options.minCount) formData.append('minCount', options.minCount);
+            if (options.maxCount) formData.append('maxCount', options.maxCount);
+            if (options.reverse) formData.append('reverse', options.reverse);
+            if (options.rcomplement) formData.append('rcomplement', options.rcomplement);
+            if (options.codons) formData.append('codons', options.codons);
+            if (options.coverage) formData.append('coverage', options.coverage);
+            if (options.longest) formData.append('longest', options.longest);
+            if (options.format) formData.append('format', options.format);
+            
+            const response = await fetch(`${this.baseUrl}/analyze`, {
+                method: 'POST',
+                body: formData
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || 'DNA analysis failed');
+            }
+            
+            // Handle different response formats
+            const contentType = response.headers.get('content-type');
+            if (contentType && contentType.includes('application/json')) {
+                return await response.json();
+            } else {
+                return await response.text();
+            }
+        } catch (error) {
+            console.error('DNA analysis error:', error);
+            throw error;
+        }
+    },
+
+    /**
+     * Analyze base pair composition of a DNA sequence
+     * @param {string} sequence - The DNA sequence
+     * @returns {Promise<Object>} - Base pair analysis results
+     */
+    async analyzeBasePairs(sequence) {
+        try {
+            const response = await fetch(`${this.baseUrl}/base-pairs`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({ sequence })
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || 'Base pair analysis failed');
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('Base pair analysis error:', error);
+            throw error;
+        }
+    },
+
+    /**
+     * Find proteins in a DNA sequence
+     * @param {string} sequence - The DNA sequence
+     * @param {string} aminoAcid - The amino acid to start proteins with
+     * @returns {Promise<Object>} - Protein analysis results
+     */
+    async findProteins(sequence, aminoAcid = 'M') {
+        try {
+            const response = await fetch(`${this.baseUrl}/find-proteins`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    sequence,
+                    aminoAcid
+                })
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || 'Protein finding failed');
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('Protein finding error:', error);
+            throw error;
+        }
+    },
+
+    /**
+     * Analyze reading frames in a DNA sequence
+     * @param {string} sequence - The DNA sequence
+     * @param {number} minLength - Minimum length for potential genes
+     * @returns {Promise<Object>} - Reading frame analysis results
+     */
+    async analyzeReadingFrames(sequence, minLength = 300) {
+        try {
+            const response = await fetch(`${this.baseUrl}/reading-frames`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    sequence,
+                    minLength
+                })
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || 'Reading frame analysis failed');
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('Reading frame analysis error:', error);
+            throw error;
+        }
+    },
+
+    /**
+     * Analyze genetic testing data (23andMe, AncestryDNA, etc.)
+     * @param {File} geneticFile - The genetic data file
+     * @param {boolean} snpAnalysis - Whether to include detailed SNP analysis
+     * @returns {Promise<Object>} - Genetic analysis results
+     */
+    async analyzeGeneticData(geneticFile, snpAnalysis = false) {
+        try {
+            const formData = new FormData();
+            formData.append('geneticFile', geneticFile);
+            formData.append('snpAnalysis', snpAnalysis);
+            
+            const response = await fetch(`${this.baseUrl}/analyze-genetic`, {
+                method: 'POST',
+                body: formData
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || 'Genetic data analysis failed');
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('Genetic data analysis error:', error);
+            throw error;
+        }
+    },
+
+    /**
+     * Manipulate a DNA sequence (reverse, complement)
+     * @param {string} sequence - The DNA sequence
+     * @param {boolean} reverse - Whether to reverse the sequence
+     * @param {boolean} complement - Whether to get the complement
+     * @returns {Promise<Object>} - Manipulated sequence results
+     */
+    async manipulateDNA(sequence, reverse = false, complement = false) {
+        try {
+            const response = await fetch(`${this.baseUrl}/manipulate`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    sequence,
+                    reverse,
+                    complement
+                })
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || 'DNA manipulation failed');
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('DNA manipulation error:', error);
+            throw error;
+        }
+    },
+
+    /**
+     * Parse a DNA file (FASTA, FASTQ)
+     * @param {File} file - The file to parse
+     * @returns {Promise<Object>} - Parsed DNA sequence
+     */
+    async parseFile(file) {
+        try {
+            const formData = new FormData();
+            formData.append('file', file);
+            
+            const response = await fetch(`${this.baseUrl}/parse`, {
+                method: 'POST',
+                body: formData
+            });
+            
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error(errorData.message || 'File parsing failed');
+            }
+            
+            return await response.json();
+        } catch (error) {
+            console.error('File parsing error:', error);
+            throw error;
+        }
+    }
+};
+
+// Export the API client for use in other modules
+if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
+    module.exports = DNAnalyzerAPI;
+} else {
+    window.DNAnalyzerAPI = DNAnalyzerAPI;
+}
\ No newline at end of file