From 3568453103f4e9696b4e691cb31dce22a9756e8c Mon Sep 17 00:00:00 2001 From: Eduard Sommer Date: Fri, 12 Dec 2025 14:47:36 +0100 Subject: [PATCH] some changes --- .gitignore | 98 ++++ README-FULLSTACK.md | 189 ++++++ TRUENAS_DEPLOYMENT.md | 99 ++++ backend/Dockerfile | 15 + backend/pom.xml | 101 ++++ .../StockAnalyzerApplication.java | 14 + .../com/stockanalyzer/config/CorsConfig.java | 21 + .../controller/AnalysisController.java | 171 ++++++ .../controller/WatchlistController.java | 97 ++++ .../com/stockanalyzer/model/AnalysisJob.java | 53 ++ .../stockanalyzer/model/AnalysisResult.java | 66 +++ .../java/com/stockanalyzer/model/Stock.java | 26 + .../repository/AnalysisJobRepository.java | 10 + .../repository/AnalysisResultRepository.java | 22 + .../repository/StockRepository.java | 16 + .../service/AnalysisService.java | 206 +++++++ .../stockanalyzer/service/JobProcessor.java | 45 ++ .../com/stockanalyzer/service/JobService.java | 76 +++ .../com/stockanalyzer/service/LLMService.java | 238 ++++++++ .../stockanalyzer/service/NewsService.java | 68 +++ .../service/SentimentService.java | 73 +++ .../service/StockDataService.java | 368 ++++++++++++ backend/src/main/resources/application.yml | 31 + build-and-push.sh | 45 ++ docker-compose-fullstack.yml | 51 ++ env.example | 6 + frontend/.dockerignore | 2 + frontend/Dockerfile | 16 + frontend/index.html | 16 + frontend/nginx.conf | 20 + frontend/package.json | 26 + frontend/src/App.vue | 91 +++ frontend/src/components/AnalysisCard.vue | 307 ++++++++++ frontend/src/components/WatchlistSidebar.vue | 228 ++++++++ frontend/src/main.ts | 12 + frontend/src/router/index.ts | 15 + frontend/src/store/index.ts | 278 +++++++++ frontend/src/style.css | 394 +++++++++++++ frontend/src/views/Dashboard.vue | 231 ++++++++ frontend/src/views/History.vue | 543 ++++++++++++++++++ frontend/src/vite-env.d.ts | 7 + frontend/tsconfig.json | 43 ++ frontend/tsconfig.node.json | 15 + frontend/vite.config.ts | 21 + start.sh | 87 +++ 45 files changed, 4557 insertions(+) create mode 100644 .gitignore create mode 100644 README-FULLSTACK.md create mode 100644 TRUENAS_DEPLOYMENT.md create mode 100644 backend/Dockerfile create mode 100644 backend/pom.xml create mode 100644 backend/src/main/java/com/stockanalyzer/StockAnalyzerApplication.java create mode 100644 backend/src/main/java/com/stockanalyzer/config/CorsConfig.java create mode 100644 backend/src/main/java/com/stockanalyzer/controller/AnalysisController.java create mode 100644 backend/src/main/java/com/stockanalyzer/controller/WatchlistController.java create mode 100644 backend/src/main/java/com/stockanalyzer/model/AnalysisJob.java create mode 100644 backend/src/main/java/com/stockanalyzer/model/AnalysisResult.java create mode 100644 backend/src/main/java/com/stockanalyzer/model/Stock.java create mode 100644 backend/src/main/java/com/stockanalyzer/repository/AnalysisJobRepository.java create mode 100644 backend/src/main/java/com/stockanalyzer/repository/AnalysisResultRepository.java create mode 100644 backend/src/main/java/com/stockanalyzer/repository/StockRepository.java create mode 100644 backend/src/main/java/com/stockanalyzer/service/AnalysisService.java create mode 100644 backend/src/main/java/com/stockanalyzer/service/JobProcessor.java create mode 100644 backend/src/main/java/com/stockanalyzer/service/JobService.java create mode 100644 backend/src/main/java/com/stockanalyzer/service/LLMService.java create mode 100644 backend/src/main/java/com/stockanalyzer/service/NewsService.java create mode 100644 backend/src/main/java/com/stockanalyzer/service/SentimentService.java create mode 100644 backend/src/main/java/com/stockanalyzer/service/StockDataService.java create mode 100644 backend/src/main/resources/application.yml create mode 100755 build-and-push.sh create mode 100644 docker-compose-fullstack.yml create mode 100644 env.example create mode 100644 frontend/.dockerignore create mode 100644 frontend/Dockerfile create mode 100644 frontend/index.html create mode 100644 frontend/nginx.conf create mode 100644 frontend/package.json create mode 100644 frontend/src/App.vue create mode 100644 frontend/src/components/AnalysisCard.vue create mode 100644 frontend/src/components/WatchlistSidebar.vue create mode 100644 frontend/src/main.ts create mode 100644 frontend/src/router/index.ts create mode 100644 frontend/src/store/index.ts create mode 100644 frontend/src/style.css create mode 100644 frontend/src/views/Dashboard.vue create mode 100644 frontend/src/views/History.vue create mode 100644 frontend/src/vite-env.d.ts create mode 100644 frontend/tsconfig.json create mode 100644 frontend/tsconfig.node.json create mode 100644 frontend/vite.config.ts create mode 100755 start.sh diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..8894cd2 --- /dev/null +++ b/.gitignore @@ -0,0 +1,98 @@ +# Java +*.class +*.log +*.ctxt +.mtj.tmp/ +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# Maven +target/ +pom.xml.tag +pom.xml.releaseBackup +pom.xml.versionsBackup +pom.xml.next +release.properties +dependency-reduced-pom.xml +buildNumber +.mvn/timing.properties +.mvn/wrapper/maven-wrapper.properties + +# Spring Boot +help.md +.mvn/ + +# IDEs - IntelliJ IDEA +.idea/ +*.iws +*.iml +*.ipr +out/ +!**/src/main/**/out/ +!**/src/test/**/out/ + +# IDEs - Eclipse +.classpath +.project +.settings/ +bin/ + +# IDEs - VS Code +.vscode/ +*.code-workspace + +# IDEs - NetBeans +nbproject/private/ +build/ +nbbuild/ +dist/ +nbdist/ +.nb-gradle/ + +# Frontend - Node/Vue +node_modules/ +frontend/node_modules/ +frontend/dist/ +frontend/.vite/ +frontend/.DS_Store +npm-debug.log* +yarn-debug.log* +yarn-error.log* +pnpm-debug.log* +.npm/ + +# OS +.DS_Store +.DS_Store? +._* +.Spotlight-V100 +.Trashes +ehthumbs.db +Thumbs.db + +# Environment Variables +.env +.env.local +.env.development.local +.env.test.local +.env.production.local +*.env +env/ +venv/ + +# Python (Legacy/Scripts) +__pycache__/ +*.py[cod] +*$py.class +.Python + +# Logs +logs/ +*.log + +backend/target diff --git a/README-FULLSTACK.md b/README-FULLSTACK.md new file mode 100644 index 0000000..d459897 --- /dev/null +++ b/README-FULLSTACK.md @@ -0,0 +1,189 @@ +# Stock Analyzer - Full Stack Application + +A modern stock analysis application built with **Spring Boot (Java)** backend and **Vue.js** frontend. + +## Features + +- 📊 Real-time stock data analysis using Yahoo Finance +- 🤖 AI-powered predictions using OpenAI GPT and Anthropic Claude +- 📰 News sentiment analysis via NewsAPI +- 🌐 Web sentiment analysis via DuckDuckGo +- 📈 Technical indicators (RSI, SMA) +- 📉 Fundamental analysis (P/E ratio, Market Cap, etc.) +- 📜 Historical analysis tracking with accuracy metrics +- đŸŽ¯ Watchlist management + +## Tech Stack + +### Backend +- **Spring Boot 3.2.1** with Java +- **MongoDB** for data persistence +- **OkHttp** for HTTP requests +- **Jsoup** for web scraping +- **Gradle** for build management + +### Frontend +- **Vue 3** with Composition API +- **TypeScript** for type safety +- **Vite** for fast development +- **Pinia** for state management +- **Axios** for API calls +- **Premium CSS** with dark theme and glassmorphism + +## Prerequisites + +- **Java 17+** +- **Node.js 18+** (for frontend) +- **MongoDB** (local or Docker) +- **API Keys**: + - OpenAI API Key + - Anthropic API Key + - NewsAPI Key + +## Quick Start + +### 1. Start MongoDB + +```bash +docker run -d -p 27017:27017 --name mongodb mongo:latest +``` + +### 2. Configure Environment Variables + +Create a `.env` file or set environment variables: + +```bash +export MONGO_URI=mongodb://localhost:27017/stock_analyzer +export OPENAI_API_KEY=your_openai_key +export OPENAI_MODEL=gpt-4o +export ANTHROPIC_API_KEY=your_anthropic_key +export ANTHROPIC_MODEL=claude-sonnet-4-5 +export NEWS_API_KEY=your_newsapi_key +``` + +### 3. Start Backend + +```bash +cd backend +./gradlew bootRun +``` + +The backend will start on `http://localhost:8080` + +### 4. Start Frontend + +```bash +cd frontend +npm install +npm run dev +``` + +The frontend will start on `http://localhost:5173` + +## API Endpoints + +### Watchlist +- `GET /api/watchlist` - Get all watchlist stocks +- `POST /api/watchlist` - Add stock to watchlist +- `DELETE /api/watchlist/{isin}` - Remove stock from watchlist + +### Analysis +- `POST /api/analysis/run` - Analyze all watchlist stocks +- `GET /api/analysis/history` - Get historical results +- `GET /api/analysis/history/{isin}` - Get results for specific ISIN +- `DELETE /api/analysis/history` - Delete results by date range +- `GET /api/analysis/market-context` - Get S&P 500 market context +- `GET /api/analysis/historical-price/{symbol}/{date}` - Get historical price + +## Docker Deployment + +### Build and Run with Docker Compose + +```bash +docker-compose up --build +``` + +This will start: +- MongoDB on port 27017 +- Backend on port 8080 +- Frontend on port 80 + +## Development + +### Backend Development + +```bash +cd backend +./gradlew build +./gradlew test +``` + +### Frontend Development + +```bash +cd frontend +npm run dev # Development server +npm run build # Production build +npm run preview # Preview production build +``` + +## Project Structure + +``` +stock-analyzer/ +├── backend/ # Spring Boot backend +│ ├── src/ +│ │ └── main/ +│ │ ├── kotlin/ +│ │ │ └── com/stockanalyzer/ +│ │ │ ├── controller/ +│ │ │ ├── service/ +│ │ │ ├── model/ +│ │ │ ├── repository/ +│ │ │ └── config/ +│ │ └── resources/ +│ │ └── application.yml +│ └── build.gradle.kts +├── frontend/ # Vue.js frontend +│ ├── src/ +│ │ ├── components/ +│ │ ├── views/ +│ │ ├── store/ +│ │ ├── router/ +│ │ ├── App.vue +│ │ └── main.ts +│ ├── package.json +│ └── vite.config.ts +└── README-FULLSTACK.md +``` + +## Features in Detail + +### Stock Analysis +- Fetches real-time stock data from Yahoo Finance +- Calculates technical indicators (RSI, SMA) +- Retrieves fundamental data (P/E ratio, Market Cap, etc.) +- Gets analyst ratings and target prices + +### AI Predictions +- Uses both OpenAI GPT and Anthropic Claude for predictions +- Predicts stock movement for the next 24 hours +- Provides probability scores and reasoning + +### News & Sentiment +- Fetches recent news headlines via NewsAPI +- Scrapes web sentiment from Reddit and Yahoo Finance +- Analyzes overall market context (S&P 500) + +### Historical Tracking +- Stores all analysis results in MongoDB +- Tracks prediction accuracy over time +- Allows deletion of historical data by date range + +## License + +MIT + +## Contributing + +Contributions are welcome! Please feel free to submit a Pull Request. diff --git a/TRUENAS_DEPLOYMENT.md b/TRUENAS_DEPLOYMENT.md new file mode 100644 index 0000000..f93883b --- /dev/null +++ b/TRUENAS_DEPLOYMENT.md @@ -0,0 +1,99 @@ +# Deploying Stock Analyzer to TrueNAS Scale + +This guide explains how to deploy the Stock Analyzer application to TrueNAS Scale using the "Custom App" feature. + +## Prerequisites + +1. **TrueNAS Scale** installed and running. +2. **Docker Hub Account**: You need an account to host your container images. +3. **Terminal Access**: Access to a terminal where you have the project code and Docker installed (to run the build script). + +## Step 1: Build and Push Images + +Before deploying, you need to build the Docker images and push them to Docker Hub so TrueNAS can download them. + +1. Open your terminal in the project root. +2. Make the build script executable: + ```bash + chmod +x build-and-push.sh + ``` +3. Run the script with your Docker Hub username and optional version tag: + ```bash + ./build-and-push.sh your_dockerhub_username [version] + ``` + *Replace `your_dockerhub_username` with your actual Docker Hub username. If version is omitted, it defaults to `latest`.* + +Wait for the script to finish. It will build both backend and frontend images and push them to your account. + +## Step 2: Deploy MongoDB + +The application requires a MongoDB database. + +1. Log in to your TrueNAS Scale web interface. +2. Go to **Apps**. +3. Click **Discover Apps**. +4. Search for **MongoDB** (or use the "Custom App" button if you prefer a raw container). + * **Recommended**: Use the official TrueCharts or iXsystems MongoDB chart if available for easier management. + * **Alternative (Custom App)**: + * Application Name: `mongodb` + * Image repository: `mongo` + * Image Tag: `latest` + * Port Forwarding: Container Port `27017` -> Node Port `27017` (or any available port). + * Storage: Configure a Host Path or PVC to `/data/db` to persist data. + +## Step 3: Deploy Backend + +1. Go to **Apps** -> **Discover Apps** -> **Custom App**. +2. **Application Name**: `stock-analyzer-backend` +3. **Container Image**: + * Repository: `your_dockerhub_username/stock-analyzer-backend` + * Tag: `latest` +4. **Port Forwarding**: + * Container Port: `8080` + * Node Port: `8080` (or another available port, e.g., `9000`. If you change this, remember it for the frontend config). +5. **Environment Variables**: + Add the following name/value pairs: + * `MONGO_URI`: `mongodb://:27017/stock_analyzer` (Replace `` with your TrueNAS IP address). + * `OPENAI_API_KEY`: Your OpenAI API Key. + * `OPENAI_MODEL`: `gpt-4o` (or your preferred model). + * `ANTHROPIC_API_KEY`: Your Anthropic API Key. + * `ANTHROPIC_MODEL`: `claude-3-5-sonnet-20240620` (or your preferred model). + * `NEWS_API_KEY`: Your NewsAPI Key. +6. **Save/Install**. + +## Step 4: Deploy Frontend + +1. Go to **Apps** -> **Discover Apps** -> **Custom App**. +2. **Application Name**: `stock-analyzer-frontend` +3. **Container Image**: + * Repository: `your_dockerhub_username/stock-analyzer-frontend` + * Tag: `latest` +4. **Port Forwarding**: + * Container Port: `80` + * Node Port: `3000` (or any available port you want to access the app from). +5. **Networking**: + * The frontend is an SPA (Single Page Application). It runs in the user's browser. + * **Important**: The frontend needs to know where the backend is. + * By default, the nginx config in the frontend container proxies `/api` calls to `http://backend:8080`. + * **TrueNAS Specific**: Since Kubernetes/Docker networking in TrueNAS can be complex for simple service discovery without a proper chart, you might need to adjust the Nginx configuration or use a reverse proxy (like Traefik) if the internal DNS `backend` doesn't resolve. + * **Simple Fix**: If the default proxying doesn't work, you might need to expose the backend directly and update the frontend code to point to the full URL, OR ensure both apps are in the same namespace/network where `backend` resolves. + + *For a standard "Custom App" deployment where containers can't easily talk via DNS names like `backend`:* + You may need to update the `nginx.conf` in the source code to point to your TrueNAS IP and the Backend Node Port, then rebuild/push. + + *Edit `frontend/nginx.conf` before building:* + ```nginx + location /api { + proxy_pass http://:; + ... + } + ``` + +6. **Save/Install**. + +## Step 5: Access the Application + +Open your browser and navigate to: +`http://:` + +Example: `http://192.168.1.100:3000` diff --git a/backend/Dockerfile b/backend/Dockerfile new file mode 100644 index 0000000..b41e2f8 --- /dev/null +++ b/backend/Dockerfile @@ -0,0 +1,15 @@ +# Build stage +FROM maven:3.9-eclipse-temurin-21 AS build +WORKDIR /app +COPY pom.xml . +COPY src ./src +RUN mvn clean package -DskipTests + +# Run stage +FROM eclipse-temurin:21-jre-alpine +WORKDIR /app +COPY --from=build /app/target/*.jar app.jar + +EXPOSE 8080 + +ENTRYPOINT ["java", "-jar", "app.jar"] \ No newline at end of file diff --git a/backend/pom.xml b/backend/pom.xml new file mode 100644 index 0000000..e92c1f7 --- /dev/null +++ b/backend/pom.xml @@ -0,0 +1,101 @@ + + + 4.0.0 + + org.springframework.boot + spring-boot-starter-parent + 3.4.1 + + + com.stockanalyzer + backend + 0.0.1-SNAPSHOT + stock-analyzer-backend + Stock Analyzer Backend + + 21 + 1.18.38 + 3.13.0 + + + + org.springframework.boot + spring-boot-starter-web + + + org.springframework.boot + spring-boot-starter-data-mongodb + + + org.springframework.boot + spring-boot-starter-actuator + + + + com.fasterxml.jackson.core + jackson-databind + + + com.fasterxml.jackson.datatype + jackson-datatype-jsr310 + + + + com.squareup.okhttp3 + okhttp + 4.12.0 + + + + org.jsoup + jsoup + 1.17.2 + + + + org.projectlombok + lombok + true + + + org.springframework.boot + spring-boot-starter-test + test + + + + + + + org.apache.maven.plugins + maven-compiler-plugin + ${maven-compiler-plugin.version} + + ${java.version} + + + org.projectlombok + lombok + ${lombok.version} + + + + + + org.springframework.boot + spring-boot-maven-plugin + + com.stockanalyzer.StockAnalyzerApplication + + + org.projectlombok + lombok + + + + + + + + diff --git a/backend/src/main/java/com/stockanalyzer/StockAnalyzerApplication.java b/backend/src/main/java/com/stockanalyzer/StockAnalyzerApplication.java new file mode 100644 index 0000000..8ba6d43 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/StockAnalyzerApplication.java @@ -0,0 +1,14 @@ +package com.stockanalyzer; + +import org.springframework.boot.SpringApplication; +import org.springframework.boot.autoconfigure.SpringBootApplication; +import org.springframework.scheduling.annotation.EnableScheduling; + +@SpringBootApplication +@EnableScheduling +public class StockAnalyzerApplication { + + public static void main(String[] args) { + SpringApplication.run(StockAnalyzerApplication.class, args); + } +} diff --git a/backend/src/main/java/com/stockanalyzer/config/CorsConfig.java b/backend/src/main/java/com/stockanalyzer/config/CorsConfig.java new file mode 100644 index 0000000..ad72fca --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/config/CorsConfig.java @@ -0,0 +1,21 @@ +package com.stockanalyzer.config; + +import org.springframework.context.annotation.Configuration; +import org.springframework.web.servlet.config.annotation.CorsRegistry; +import org.springframework.web.servlet.config.annotation.WebMvcConfigurer; + +@Configuration +public class CorsConfig implements WebMvcConfigurer { + + @org.springframework.beans.factory.annotation.Value("${cors.allowed-origins:http://localhost:5173}") + private String allowedOrigins; + + @Override + public void addCorsMappings(CorsRegistry registry) { + registry.addMapping("/api/**") + .allowedOrigins(allowedOrigins.split(",")) + .allowedMethods("GET", "POST", "PUT", "DELETE", "OPTIONS") + .allowedHeaders("*") + .allowCredentials(true); + } +} diff --git a/backend/src/main/java/com/stockanalyzer/controller/AnalysisController.java b/backend/src/main/java/com/stockanalyzer/controller/AnalysisController.java new file mode 100644 index 0000000..34c376a --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/controller/AnalysisController.java @@ -0,0 +1,171 @@ +package com.stockanalyzer.controller; + +import com.stockanalyzer.model.AnalysisJob; +import com.stockanalyzer.model.AnalysisResult; +import com.stockanalyzer.model.Stock; +import com.stockanalyzer.repository.AnalysisResultRepository; +import com.stockanalyzer.repository.StockRepository; +import com.stockanalyzer.service.AnalysisService; +import com.stockanalyzer.service.JobService; +import com.stockanalyzer.service.StockDataService; +import com.stockanalyzer.service.StockDataService.MarketContextData; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; + +@RestController +@RequestMapping("/api/analysis") +public class AnalysisController { + + private final AnalysisService analysisService; + private final AnalysisResultRepository analysisResultRepository; + private final StockRepository stockRepository; + private final StockDataService stockDataService; + private final JobService jobService; + + public AnalysisController( + AnalysisService analysisService, + AnalysisResultRepository analysisResultRepository, + StockRepository stockRepository, + StockDataService stockDataService, + JobService jobService) { + this.analysisService = analysisService; + this.analysisResultRepository = analysisResultRepository; + this.stockRepository = stockRepository; + this.stockDataService = stockDataService; + this.jobService = jobService; + } + + public record AnalysisProgress( + String isin, + String status, + AnalysisResult result, + String error) { + } + + public record DeleteByDateRangeRequest( + String startDate, + String endDate) { + } + + @PostMapping("/run") + public List runAnalysis() { + List watchlist = stockRepository.findAll(); + List jobs = new ArrayList<>(); + + // Clear old jobs optionally or just append new ones. + // For simplicity, we'll keep history but maybe UI only cares about recent ones. + // Let's clear strictly pending/processing ones? No, safer to just create new ones. + + // Actually, to avoid queueing up duplicates if user clicks twice, + // we might want to check if there is already a PENDING job for this ISIN. + // But for now, simple implementation: just enqueue. + + for (Stock stock : watchlist) { + if (!jobService.hasPendingOrProcessingJob(stock.getIsin())) { + AnalysisJob job = jobService.createJob(stock.getIsin(), stock.getSymbol()); + jobs.add(job); + } + } + + // Return all current jobs (including existing ones) so UI knows status + List allJobs = jobService.getAllJobs(); + // Filter to return only jobs relevant to the watchlist if needed, + // but returning all jobs is fine for the status view. + return allJobs; + } + + @PostMapping("/run/{isin}") + public List runSingleAnalysis(@PathVariable String isin) { + stockRepository.findByIsin(isin).ifPresent(stock -> { + if (!jobService.hasPendingOrProcessingJob(stock.getIsin())) { + jobService.createJob(stock.getIsin(), stock.getSymbol()); + } + }); + return jobService.getAllJobs(); + } + + @GetMapping("/jobs") + public List getJobStatus() { + return jobService.getAllJobs(); + } + + @PostMapping("/stop") + public ResponseEntity stopAnalysis() { + jobService.cancelAllJobs(); + return ResponseEntity.ok().build(); + } + + + + @GetMapping("/history") + public ResponseEntity> getHistory() { + List results = analysisResultRepository.findAll().stream() + .sorted((r1, r2) -> r2.getAnalyzedAt().compareTo(r1.getAnalyzedAt())) + .limit(50) + .toList(); + return ResponseEntity.ok(results); + } + + @GetMapping("/history/{isin}") + public ResponseEntity> getHistoryByIsin(@PathVariable String isin) { + List results = analysisResultRepository.findByIsinOrderByAnalyzedAtDesc(isin).stream() + .limit(30) + .toList(); + return ResponseEntity.ok(results); + } + + @DeleteMapping("/history") + public ResponseEntity> deleteByDateRange(@RequestBody DeleteByDateRangeRequest request) { + try { + long count = analysisResultRepository.deleteByDateBetween(request.startDate(), request.endDate()); + return ResponseEntity.ok(Map.of("deleted", count)); + } catch (Exception e) { + return ResponseEntity.badRequest() + .body(Map.of("error", e.getMessage() != null ? e.getMessage() : "Unknown error")); + } + } + + @GetMapping("/market-context") + public ResponseEntity> getMarketContext() { + MarketContextData context = stockDataService.getMarketContext(); + if (context != null) { + return ResponseEntity.ok( + Map.of( + "symbol", context.symbol(), + "changePercent", context.changePercent(), + "price", context.price())); + } else { + return ResponseEntity.ok(Map.of("error", "Unable to fetch market context")); + } + } + + @GetMapping("/historical-price/{symbol}/{date}") + public ResponseEntity> getHistoricalPrice( + @PathVariable String symbol, + @PathVariable String date) { + Double price = stockDataService.getHistoricalPrice(symbol, date); + if (price != null) { + return ResponseEntity.ok(Map.of("price", price)); + } else { + return ResponseEntity.ok(Map.of("error", "Price not available")); + } + } + + @PostMapping("/history/{id}/refresh-price") + public ResponseEntity refreshPrice(@PathVariable String id) { + return analysisResultRepository.findById(id) + .map(result -> { + Double price = stockDataService.getHistoricalPrice(result.getSymbol(), result.getTargetDate()); + if (price != null) { + result.setRealPrice(price); + return ResponseEntity.ok(analysisResultRepository.save(result)); + } + return ResponseEntity.ok(result); + }) + .orElse(ResponseEntity.notFound().build()); + } +} diff --git a/backend/src/main/java/com/stockanalyzer/controller/WatchlistController.java b/backend/src/main/java/com/stockanalyzer/controller/WatchlistController.java new file mode 100644 index 0000000..b230005 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/controller/WatchlistController.java @@ -0,0 +1,97 @@ +package com.stockanalyzer.controller; + +import com.stockanalyzer.model.Stock; +import com.stockanalyzer.repository.StockRepository; +import com.stockanalyzer.service.StockDataService; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.web.bind.annotation.*; + +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; + +@RestController +@RequestMapping("/api/watchlist") +public class WatchlistController { + + private final StockRepository stockRepository; + private final StockDataService stockDataService; + + public WatchlistController(StockRepository stockRepository, StockDataService stockDataService) { + this.stockRepository = stockRepository; + this.stockDataService = stockDataService; + } + + public record AddStockRequest(String isin) { + } + + public record StockResponse( + String isin, + String symbol, + String name, + String addedAt) { + } + + @GetMapping + public List getAllStocks() { + return stockRepository.findAll().stream() + .sorted((s1, s2) -> s2.getAddedAt().compareTo(s1.getAddedAt())) + .map(stock -> new StockResponse( + stock.getIsin(), + stock.getSymbol(), + stock.getName(), + stock.getAddedAt().toString())) + .collect(Collectors.toList()); + } + + @PostMapping + public ResponseEntity addStock(@RequestBody AddStockRequest request) { + String isin = request.isin() != null ? request.isin().trim().toUpperCase() : ""; + + if (isin.isBlank()) { + return ResponseEntity.badRequest().body(Map.of("error", "ISIN cannot be empty")); + } + + if (stockRepository.existsByIsin(isin)) { + return ResponseEntity.status(HttpStatus.CONFLICT) + .body(Map.of("error", "ISIN already exists in watchlist")); + } + + try { + // Resolve ISIN to Symbol + String symbol = stockDataService.getTickerFromIsin(isin); + + // For now, use symbol as name (could fetch from Yahoo Finance if needed) + String name = symbol; + + Stock stock = Stock.builder() + .isin(isin) + .symbol(symbol) + .name(name) + .build(); + + Stock saved = stockRepository.save(stock); + + return ResponseEntity.status(HttpStatus.CREATED).body( + new StockResponse( + saved.getIsin(), + saved.getSymbol(), + saved.getName(), + saved.getAddedAt().toString())); + } catch (Exception e) { + return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR) + .body(Map.of("error", "Error adding stock: " + e.getMessage())); + } + } + + @DeleteMapping("/{isin}") + public ResponseEntity deleteStock(@PathVariable String isin) { + if (stockRepository.existsByIsin(isin)) { + stockRepository.deleteByIsin(isin); + return ResponseEntity.noContent().build(); + } else { + return ResponseEntity.notFound().build(); + } + } +} diff --git a/backend/src/main/java/com/stockanalyzer/model/AnalysisJob.java b/backend/src/main/java/com/stockanalyzer/model/AnalysisJob.java new file mode 100644 index 0000000..3100306 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/model/AnalysisJob.java @@ -0,0 +1,53 @@ +package com.stockanalyzer.model; + +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; +import java.time.LocalDateTime; + +@Document(collection = "analysis_jobs") +public class AnalysisJob { + @Id + private String id; + private String isin; + private String symbol; + private JobStatus status; + private String error; + private LocalDateTime createdAt; + private LocalDateTime startedAt; + private LocalDateTime completedAt; + + public enum JobStatus { + PENDING, + PROCESSING, + COMPLETED, + FAILED, + CANCELLED + } + + public AnalysisJob() {} + + public AnalysisJob(String isin, String symbol) { + this.isin = isin; + this.symbol = symbol; + this.status = JobStatus.PENDING; + this.createdAt = LocalDateTime.now(); + } + + // Getters and Setters + public String getId() { return id; } + public void setId(String id) { this.id = id; } + public String getIsin() { return isin; } + public void setIsin(String isin) { this.isin = isin; } + public String getSymbol() { return symbol; } + public void setSymbol(String symbol) { this.symbol = symbol; } + public JobStatus getStatus() { return status; } + public void setStatus(JobStatus status) { this.status = status; } + public String getError() { return error; } + public void setError(String error) { this.error = error; } + public LocalDateTime getCreatedAt() { return createdAt; } + public void setCreatedAt(LocalDateTime createdAt) { this.createdAt = createdAt; } + public LocalDateTime getStartedAt() { return startedAt; } + public void setStartedAt(LocalDateTime startedAt) { this.startedAt = startedAt; } + public LocalDateTime getCompletedAt() { return completedAt; } + public void setCompletedAt(LocalDateTime completedAt) { this.completedAt = completedAt; } +} diff --git a/backend/src/main/java/com/stockanalyzer/model/AnalysisResult.java b/backend/src/main/java/com/stockanalyzer/model/AnalysisResult.java new file mode 100644 index 0000000..0b2386a --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/model/AnalysisResult.java @@ -0,0 +1,66 @@ +package com.stockanalyzer.model; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; + +import java.time.Instant; +import java.util.List; + +@Document(collection = "results") +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class AnalysisResult { + @Id + private String id; + private String isin; + private String symbol; + private Double price; + private Double realPrice; + private Double changePercent; + private Fundamentals fundamentals; + private Technicals technicals; + private MarketContext marketContext; + private List newsHeadlines; + private List socialPosts; + private LLMAnalysis llmAnalysisOpenai; + private LLMAnalysis llmAnalysisAnthropic; + + @Builder.Default + private Instant analyzedAt = Instant.now(); + + private String date; + private String targetDate; + + public record Fundamentals( + String peRatio, + String marketCap, + String high52w, + String low52w, + String targetMeanPrice, + String recommendationKey) { + } + + public record Technicals( + String sma20, + String rsi) { + } + + public record MarketContext( + String symbol, + Double changePercent, + Double price) { + } + + public record LLMAnalysis( + String prediction, + int probability, + String reasoning, + String error) { + } +} diff --git a/backend/src/main/java/com/stockanalyzer/model/Stock.java b/backend/src/main/java/com/stockanalyzer/model/Stock.java new file mode 100644 index 0000000..60e1101 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/model/Stock.java @@ -0,0 +1,26 @@ +package com.stockanalyzer.model; + +import lombok.AllArgsConstructor; +import lombok.Builder; +import lombok.Data; +import lombok.NoArgsConstructor; +import org.springframework.data.annotation.Id; +import org.springframework.data.mongodb.core.mapping.Document; + +import java.time.Instant; + +@Document(collection = "stocks") +@Data +@NoArgsConstructor +@AllArgsConstructor +@Builder +public class Stock { + @Id + private String id; + private String isin; + private String symbol; + private String name; + + @Builder.Default + private Instant addedAt = Instant.now(); +} diff --git a/backend/src/main/java/com/stockanalyzer/repository/AnalysisJobRepository.java b/backend/src/main/java/com/stockanalyzer/repository/AnalysisJobRepository.java new file mode 100644 index 0000000..6817c64 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/repository/AnalysisJobRepository.java @@ -0,0 +1,10 @@ +package com.stockanalyzer.repository; + +import com.stockanalyzer.model.AnalysisJob; +import org.springframework.data.mongodb.repository.MongoRepository; +import java.util.List; + +public interface AnalysisJobRepository extends MongoRepository { + List findByStatus(AnalysisJob.JobStatus status); + boolean existsByIsinAndStatus(String isin, AnalysisJob.JobStatus status); +} diff --git a/backend/src/main/java/com/stockanalyzer/repository/AnalysisResultRepository.java b/backend/src/main/java/com/stockanalyzer/repository/AnalysisResultRepository.java new file mode 100644 index 0000000..816c87c --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/repository/AnalysisResultRepository.java @@ -0,0 +1,22 @@ +package com.stockanalyzer.repository; + +import com.stockanalyzer.model.AnalysisResult; +import org.springframework.data.mongodb.repository.MongoRepository; +import org.springframework.data.mongodb.repository.Query; +import org.springframework.stereotype.Repository; + +import java.util.List; + +@Repository +public interface AnalysisResultRepository extends MongoRepository { + List findByIsinOrderByAnalyzedAtDesc(String isin); + + @Query("{ 'date': { '$gte': ?0, '$lte': ?1 } }") + List findByDateBetween(String startDate, String endDate); + + List findByRealPriceIsNullAndTargetDateLessThan(String date); + + List findByIsinAndRealPriceIsNullAndTargetDateLessThan(String isin, String date); + + long deleteByDateBetween(String startDate, String endDate); +} diff --git a/backend/src/main/java/com/stockanalyzer/repository/StockRepository.java b/backend/src/main/java/com/stockanalyzer/repository/StockRepository.java new file mode 100644 index 0000000..dcc6399 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/repository/StockRepository.java @@ -0,0 +1,16 @@ +package com.stockanalyzer.repository; + +import com.stockanalyzer.model.Stock; +import org.springframework.data.mongodb.repository.MongoRepository; +import org.springframework.stereotype.Repository; + +import java.util.Optional; + +@Repository +public interface StockRepository extends MongoRepository { + Optional findByIsin(String isin); + + boolean existsByIsin(String isin); + + void deleteByIsin(String isin); +} diff --git a/backend/src/main/java/com/stockanalyzer/service/AnalysisService.java b/backend/src/main/java/com/stockanalyzer/service/AnalysisService.java new file mode 100644 index 0000000..c0b8dc7 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/service/AnalysisService.java @@ -0,0 +1,206 @@ +package com.stockanalyzer.service; + +import com.stockanalyzer.model.AnalysisResult; +import com.stockanalyzer.model.AnalysisResult.Fundamentals; +import com.stockanalyzer.model.AnalysisResult.LLMAnalysis; +import com.stockanalyzer.model.AnalysisResult.MarketContext; +import com.stockanalyzer.model.AnalysisResult.Technicals; +import com.stockanalyzer.repository.AnalysisResultRepository; +import com.stockanalyzer.service.StockDataService.MarketContextData; +import com.stockanalyzer.service.StockDataService.StockData; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Service; + +import java.time.DayOfWeek; +import java.time.Instant; +import java.time.LocalDate; +import java.time.ZoneOffset; +import java.time.format.DateTimeFormatter; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; + +@Service +public class AnalysisService { + + private final StockDataService stockDataService; + private final NewsService newsService; + private final SentimentService sentimentService; + private final LLMService llmService; + private final AnalysisResultRepository analysisResultRepository; + + public AnalysisService( + StockDataService stockDataService, + NewsService newsService, + SentimentService sentimentService, + LLMService llmService, + AnalysisResultRepository analysisResultRepository) { + this.stockDataService = stockDataService; + this.newsService = newsService; + this.sentimentService = sentimentService; + this.llmService = llmService; + this.analysisResultRepository = analysisResultRepository; + } + + public AnalysisResult analyzeStock(String isin) { + // 1. Get Stock Data + StockData stockInfo = stockDataService.getStockPrice(isin); + if (stockInfo.error() != null) { + return null; + } + + String symbol = stockInfo.symbol(); + + // 1.5 Update past results for this stock (fill in missing real prices) + updatePastResults(isin, symbol); + + // 2. Get News + List news = newsService.getNews(symbol); + + // 3. Get Web Sentiment + List social = sentimentService.getWebSentiment(symbol); + + // 4. Get Market Context + MarketContextData marketContextData = stockDataService.getMarketContext(); + MarketContext marketContext = null; + if (marketContextData != null) { + marketContext = new MarketContext( + marketContextData.symbol(), + marketContextData.changePercent(), + marketContextData.price()); + } + + // 5. Prepare data for LLM + Map stockDataMap = new HashMap<>(); + stockDataMap.put("symbol", symbol); + stockDataMap.put("currentPrice", stockInfo.currentPrice()); + stockDataMap.put("changePercent", stockInfo.changePercent()); + stockDataMap.put("fundamentals", stockInfo.fundamentals()); + stockDataMap.put("technicals", stockInfo.technicals()); + + Map marketContextMap = null; + if (marketContextData != null) { + marketContextMap = new HashMap<>(); + marketContextMap.put("symbol", marketContextData.symbol()); + marketContextMap.put("changePercent", marketContextData.changePercent()); + marketContextMap.put("price", marketContextData.price()); + } + + // 6. LLM Analysis - Both providers + LLMAnalysis llmResultOpenai = llmService.analyzeWithLLM(stockDataMap, news, social, marketContextMap, "openai"); + LLMAnalysis llmResultAnthropic = llmService.analyzeWithLLM(stockDataMap, news, social, marketContextMap, + "anthropic"); + + // 7. Calculate dates + Instant now = Instant.now(); + String dateStr = now.atZone(ZoneOffset.UTC).toLocalDate().format(DateTimeFormatter.ISO_LOCAL_DATE); + String targetDate = calculateTargetDate(now); + + // 8. Build result + Map fundamentalsMap = stockInfo.fundamentals(); + Fundamentals fundamentals = new Fundamentals( + String.valueOf(fundamentalsMap.getOrDefault("pe_ratio", "N/A")), + String.valueOf(fundamentalsMap.getOrDefault("market_cap", "N/A")), + String.valueOf(fundamentalsMap.getOrDefault("high_52w", "N/A")), + String.valueOf(fundamentalsMap.getOrDefault("low_52w", "N/A")), + String.valueOf(fundamentalsMap.getOrDefault("target_mean_price", "N/A")), + String.valueOf(fundamentalsMap.getOrDefault("recommendation_key", "N/A"))); + + Map technicalsMap = stockInfo.technicals(); + Technicals technicals = new Technicals( + String.valueOf(technicalsMap.getOrDefault("sma_20", "N/A")), + String.valueOf(technicalsMap.getOrDefault("rsi", "N/A"))); + + return AnalysisResult.builder() + .isin(isin) + .symbol(symbol) + .price(stockInfo.currentPrice()) + .changePercent(stockInfo.changePercent()) + .fundamentals(fundamentals) + .technicals(technicals) + .marketContext(marketContext) + .newsHeadlines(news) + .socialPosts(social) + .llmAnalysisOpenai(llmResultOpenai) + .llmAnalysisAnthropic(llmResultAnthropic) + .analyzedAt(now) + .date(dateStr) + .targetDate(targetDate) + .build(); + } + + public void saveResult(AnalysisResult result) { + // Upsert: update if exists for this ISIN and date, insert otherwise + List existingList = analysisResultRepository.findByIsinOrderByAnalyzedAtDesc(result.getIsin()); + + Optional existing = existingList.stream() + .filter(r -> r.getDate().equals(result.getDate())) + .findFirst(); + + if (existing.isPresent()) { + result.setId(existing.get().getId()); + analysisResultRepository.save(result); + } else { + analysisResultRepository.save(result); + } + } + + private String calculateTargetDate(Instant instant) { + LocalDate date = instant.atZone(ZoneOffset.UTC).toLocalDate(); + DayOfWeek dayOfWeek = date.getDayOfWeek(); + + long daysToAdd; + switch (dayOfWeek) { + case FRIDAY: + daysToAdd = 3; + break; + case SATURDAY: + daysToAdd = 2; + break; + case SUNDAY: + daysToAdd = 1; + break; + default: + daysToAdd = 1; + break; + } + + return date.plusDays(daysToAdd).format(DateTimeFormatter.ISO_LOCAL_DATE); + } + + private void updatePastResults(String isin, String symbol) { + String today = LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE); + List pastResults = analysisResultRepository.findByIsinAndRealPriceIsNullAndTargetDateLessThan(isin, today); + + for (AnalysisResult result : pastResults) { + try { + Double price = stockDataService.getHistoricalPrice(symbol, result.getTargetDate()); + if (price != null) { + result.setRealPrice(price); + analysisResultRepository.save(result); + } + } catch (Exception e) { + System.err.println("Failed to update past result for " + symbol + ": " + e.getMessage()); + } + } + } + + @Scheduled(fixedDelay = 21600000) // 6 hours + public void updateMissingRealPrices() { + String today = LocalDate.now().format(DateTimeFormatter.ISO_LOCAL_DATE); + List pendingResults = analysisResultRepository.findByRealPriceIsNullAndTargetDateLessThan(today); + + for (AnalysisResult result : pendingResults) { + try { + Double price = stockDataService.getHistoricalPrice(result.getSymbol(), result.getTargetDate()); + if (price != null) { + result.setRealPrice(price); + analysisResultRepository.save(result); + } + } catch (Exception e) { + System.err.println("Failed to update real price for " + result.getSymbol() + ": " + e.getMessage()); + } + } + } +} diff --git a/backend/src/main/java/com/stockanalyzer/service/JobProcessor.java b/backend/src/main/java/com/stockanalyzer/service/JobProcessor.java new file mode 100644 index 0000000..77f0204 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/service/JobProcessor.java @@ -0,0 +1,45 @@ +package com.stockanalyzer.service; + +import com.stockanalyzer.model.AnalysisJob; +import com.stockanalyzer.model.AnalysisResult; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.scheduling.annotation.Scheduled; +import org.springframework.stereotype.Service; + +import java.util.List; + +@Service +public class JobProcessor { + + private static final Logger logger = LoggerFactory.getLogger(JobProcessor.class); + + private final JobService jobService; + private final AnalysisService analysisService; + + public JobProcessor(JobService jobService, AnalysisService analysisService) { + this.jobService = jobService; + this.analysisService = analysisService; + } + + @Scheduled(fixedDelay = 2000) // Poll every 2 seconds + public void processJobs() { + List pendingJobs = jobService.getPendingJobs(); + + for (AnalysisJob job : pendingJobs) { + try { + logger.info("Starting analysis for job: {} (Stock: {})", job.getId(), job.getSymbol()); + jobService.startJob(job); + + AnalysisResult result = analysisService.analyzeStock(job.getIsin()); + analysisService.saveResult(result); + + jobService.completeJob(job); + logger.info("Completed analysis for job: {}", job.getId()); + } catch (Exception e) { + logger.error("Failed to process job: " + job.getId(), e); + jobService.failJob(job, e.getMessage()); + } + } + } +} diff --git a/backend/src/main/java/com/stockanalyzer/service/JobService.java b/backend/src/main/java/com/stockanalyzer/service/JobService.java new file mode 100644 index 0000000..9120d2e --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/service/JobService.java @@ -0,0 +1,76 @@ +package com.stockanalyzer.service; + +import com.stockanalyzer.model.AnalysisJob; +import com.stockanalyzer.repository.AnalysisJobRepository; +import org.springframework.stereotype.Service; + +import java.time.LocalDateTime; +import java.util.List; + +@Service +public class JobService { + + private final AnalysisJobRepository jobRepository; + + public JobService(AnalysisJobRepository jobRepository) { + this.jobRepository = jobRepository; + } + + public AnalysisJob createJob(String isin, String symbol) { + AnalysisJob job = new AnalysisJob(isin, symbol); + return jobRepository.save(job); + } + + public List getAllJobs() { + return jobRepository.findAll(); + } + + public List getPendingJobs() { + return jobRepository.findByStatus(AnalysisJob.JobStatus.PENDING); + } + + public boolean hasPendingOrProcessingJob(String isin) { + return jobRepository.existsByIsinAndStatus(isin, AnalysisJob.JobStatus.PENDING) || + jobRepository.existsByIsinAndStatus(isin, AnalysisJob.JobStatus.PROCESSING); + } + + public void startJob(AnalysisJob job) { + job.setStatus(AnalysisJob.JobStatus.PROCESSING); + job.setStartedAt(LocalDateTime.now()); + jobRepository.save(job); + } + + public void completeJob(AnalysisJob job) { + job.setStatus(AnalysisJob.JobStatus.COMPLETED); + job.setCompletedAt(LocalDateTime.now()); + jobRepository.save(job); + } + + public void failJob(AnalysisJob job, String error) { + job.setStatus(AnalysisJob.JobStatus.FAILED); + job.setError(error); + job.setCompletedAt(LocalDateTime.now()); + jobRepository.save(job); + } + + public void deleteAllJobs() { + jobRepository.deleteAll(); + } + + public void cancelAllJobs() { + List pendingJobs = jobRepository.findByStatus(AnalysisJob.JobStatus.PENDING); + List processingJobs = jobRepository.findByStatus(AnalysisJob.JobStatus.PROCESSING); + + for (AnalysisJob job : pendingJobs) { + job.setStatus(AnalysisJob.JobStatus.CANCELLED); + job.setCompletedAt(LocalDateTime.now()); + jobRepository.save(job); + } + + for (AnalysisJob job : processingJobs) { + job.setStatus(AnalysisJob.JobStatus.CANCELLED); + job.setCompletedAt(LocalDateTime.now()); + jobRepository.save(job); + } + } +} diff --git a/backend/src/main/java/com/stockanalyzer/service/LLMService.java b/backend/src/main/java/com/stockanalyzer/service/LLMService.java new file mode 100644 index 0000000..11680e7 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/service/LLMService.java @@ -0,0 +1,238 @@ +package com.stockanalyzer.service; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import com.stockanalyzer.model.AnalysisResult.LLMAnalysis; +import okhttp3.MediaType; +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.RequestBody; +import okhttp3.Response; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; + +import java.util.Collections; +import java.util.List; +import java.util.Map; + +@Service +public class LLMService { + + @Value("${api.openai.key}") + private String openaiApiKey; + + @Value("${api.openai.model}") + private String openaiModel; + + @Value("${api.anthropic.key}") + private String anthropicApiKey; + + @Value("${api.anthropic.model}") + private String anthropicModel; + + private final OkHttpClient httpClient; + private final ObjectMapper objectMapper; + private final MediaType jsonMediaType = MediaType.parse("application/json"); + + public LLMService(ObjectMapper objectMapper) { + this.httpClient = new OkHttpClient(); + this.objectMapper = objectMapper; + } + + public LLMAnalysis analyzeWithLLM( + Map stockData, + List newsData, + List socialData, + Map marketContext, + String provider) { + String prompt = buildPrompt(stockData, newsData, socialData, marketContext); + + switch (provider.toLowerCase()) { + case "openai": + return analyzeWithOpenAI(prompt); + case "anthropic": + return analyzeWithAnthropic(prompt); + default: + return new LLMAnalysis("", 0, "", "Unknown provider: " + provider); + } + } + + private String buildPrompt( + Map stockData, + List newsData, + List socialData, + Map marketContext) { + String symbol = (String) stockData.getOrDefault("symbol", "Unknown"); + Object price = stockData.getOrDefault("currentPrice", "Unknown"); + Object change = stockData.getOrDefault("changePercent", 0.0); + + Map fundamentals = (Map) stockData.getOrDefault("fundamentals", Collections.emptyMap()); + Map technicals = (Map) stockData.getOrDefault("technicals", Collections.emptyMap()); + + String marketChange = "N/A"; + if (marketContext != null) { + marketChange = String.valueOf(marketContext.getOrDefault("changePercent", "N/A")); + } + + return """ + You are a financial analyst. Analyze the following data for stock %s: + + Current Price: %s + Recent Change: %s%% + + Fundamentals: + - P/E Ratio: %s + - Market Cap: %s + - 52W High: %s + - Analyst Target: %s + - Analyst Rating: %s + + Market Context (S&P 500): + - Change (24h): %s%% + + Technicals: + - RSI (14): %s + - SMA (20): %s + + Recent News Headlines: + %s + + Recent Web Discussions & Sentiment: + %s + + Task: + Predict the probability (0-100%%) of the stock rising in the next 24 hours. + Provide a concise reasoning (max 3 sentences). + + Output Format: + Return ONLY a JSON object with the following keys: + { + "prediction": "Rise" or "Fall", + "probability": , + "reasoning": "" + } + """.formatted( + symbol, + price, + change, + fundamentals.get("pe_ratio"), + fundamentals.get("market_cap"), + fundamentals.get("high_52w"), + fundamentals.get("target_mean_price"), + fundamentals.get("recommendation_key"), + marketChange, + technicals.get("rsi"), + technicals.get("sma_20"), + String.join("\n", newsData), + String.join("\n", socialData)); + } + + private LLMAnalysis analyzeWithOpenAI(String prompt) { + if (openaiApiKey == null || openaiApiKey.isBlank()) { + return new LLMAnalysis("", 0, "", "OpenAI API Key missing"); + } + + try { + Map requestMap = Map.of( + "model", openaiModel, + "messages", List.of( + Map.of("role", "system", "content", + "You are a helpful financial assistant. Always return valid JSON."), + Map.of("role", "user", "content", prompt)), + "response_format", Map.of("type", "json_object")); + + String requestBodyString = objectMapper.writeValueAsString(requestMap); + RequestBody requestBody = RequestBody.create(requestBodyString, jsonMediaType); + + Request request = new Request.Builder() + .url("https://api.openai.com/v1/chat/completions") + .header("Authorization", "Bearer " + openaiApiKey) + .header("Content-Type", "application/json") + .post(requestBody) + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (!response.isSuccessful() || response.body() == null) { + return new LLMAnalysis("", 0, "", "OpenAI API error: " + response.code()); + } + + JsonNode json = objectMapper.readTree(response.body().string()); + JsonNode choices = json.get("choices"); + if (choices != null && choices.size() > 0) { + JsonNode message = choices.get(0).get("message"); + if (message != null && message.has("content")) { + return parseLLMResponse(message.get("content").asText()); + } + } + return new LLMAnalysis("", 0, "", "No response from OpenAI"); + } + } catch (Exception e) { + return new LLMAnalysis("", 0, "", "Error during OpenAI analysis: " + e.getMessage()); + } + } + + private LLMAnalysis analyzeWithAnthropic(String prompt) { + if (anthropicApiKey == null || anthropicApiKey.isBlank()) { + return new LLMAnalysis("", 0, "", "Anthropic API Key missing"); + } + + try { + Map requestMap = Map.of( + "model", anthropicModel, + "max_tokens", 1024, + "messages", List.of( + Map.of("role", "user", "content", prompt))); + + String requestBodyString = objectMapper.writeValueAsString(requestMap); + RequestBody requestBody = RequestBody.create(requestBodyString, jsonMediaType); + + Request request = new Request.Builder() + .url("https://api.anthropic.com/v1/messages") + .header("x-api-key", anthropicApiKey) + .header("anthropic-version", "2023-06-01") + .header("Content-Type", "application/json") + .post(requestBody) + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (!response.isSuccessful() || response.body() == null) { + return new LLMAnalysis("", 0, "", "Anthropic API error: " + response.code()); + } + + JsonNode json = objectMapper.readTree(response.body().string()); + JsonNode contentNode = json.get("content"); + if (contentNode != null && contentNode.size() > 0) { + JsonNode textNode = contentNode.get(0).get("text"); + if (textNode != null) { + return parseLLMResponse(textNode.asText()); + } + } + return new LLMAnalysis("", 0, "", "No response from Anthropic"); + } + } catch (Exception e) { + return new LLMAnalysis("", 0, "", "Error during Anthropic analysis: " + e.getMessage()); + } + } + + private LLMAnalysis parseLLMResponse(String content) { + try { + String cleanContent = content.trim(); + + // Remove markdown code blocks if present + if (cleanContent.startsWith("```json")) { + cleanContent = cleanContent.replace("```json", "").replace("```", "").trim(); + } else if (cleanContent.startsWith("```")) { + cleanContent = cleanContent.replace("```", "").trim(); + } + + JsonNode json = objectMapper.readTree(cleanContent); + return new LLMAnalysis( + json.has("prediction") ? json.get("prediction").asText() : "", + json.has("probability") ? json.get("probability").asInt() : 0, + json.has("reasoning") ? json.get("reasoning").asText() : "", + null); + } catch (Exception e) { + return new LLMAnalysis("", 0, "", "Failed to parse LLM response: " + e.getMessage()); + } + } +} diff --git a/backend/src/main/java/com/stockanalyzer/service/NewsService.java b/backend/src/main/java/com/stockanalyzer/service/NewsService.java new file mode 100644 index 0000000..e702909 --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/service/NewsService.java @@ -0,0 +1,68 @@ +package com.stockanalyzer.service; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.Response; +import org.springframework.beans.factory.annotation.Value; +import org.springframework.stereotype.Service; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +@Service +public class NewsService { + + @Value("${api.news.key}") + private String newsApiKey; + + private final OkHttpClient httpClient; + private final ObjectMapper objectMapper; + + public NewsService(ObjectMapper objectMapper) { + this.httpClient = new OkHttpClient(); + this.objectMapper = objectMapper; + } + + public List getNews(String query) { + if (newsApiKey == null || newsApiKey.isBlank()) { + return Collections.singletonList("News API Key missing"); + } + + try { + String url = "https://newsapi.org/v2/everything?q=" + query + "&apiKey=" + newsApiKey + + "&language=en&sortBy=publishedAt&pageSize=5"; + Request request = new Request.Builder() + .url(url) + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (!response.isSuccessful() || response.body() == null) { + return Collections.singletonList("Error fetching news: " + response.code()); + } + + JsonNode json = objectMapper.readTree(response.body().string()); + JsonNode articles = json.get("articles"); + + if (articles != null && articles.size() > 0) { + List newsList = new ArrayList<>(); + for (JsonNode article : articles) { + String title = article.has("title") ? article.get("title").asText() : ""; + String source = ""; + if (article.has("source") && article.get("source").has("name")) { + source = article.get("source").get("name").asText(); + } + newsList.add(title + " - " + source); + } + return newsList; + } else { + return Collections.singletonList("No news found"); + } + } + } catch (Exception e) { + return Collections.singletonList("Error fetching news: " + e.getMessage()); + } + } +} diff --git a/backend/src/main/java/com/stockanalyzer/service/SentimentService.java b/backend/src/main/java/com/stockanalyzer/service/SentimentService.java new file mode 100644 index 0000000..577cb1c --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/service/SentimentService.java @@ -0,0 +1,73 @@ +package com.stockanalyzer.service; + +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.Response; +import org.jsoup.Jsoup; +import org.jsoup.nodes.Document; +import org.jsoup.nodes.Element; +import org.jsoup.select.Elements; +import org.springframework.stereotype.Service; + +import java.net.URLEncoder; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +@Service +public class SentimentService { + + private final OkHttpClient httpClient; + + public SentimentService() { + this.httpClient = new OkHttpClient(); + } + + public List getWebSentiment(String query) { + try { + // Use DuckDuckGo HTML search + String searchQuery = query + " stock sentiment news discussion site:reddit.com OR site:finance.yahoo.com"; + String encodedQuery = URLEncoder.encode(searchQuery, StandardCharsets.UTF_8); + String url = "https://html.duckduckgo.com/html/?q=" + encodedQuery; + + Request request = new Request.Builder() + .url(url) + .header("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36") + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (!response.isSuccessful() || response.body() == null) { + return Collections.singletonList("Error fetching web sentiment: " + response.code()); + } + + String html = response.body().string(); + Document doc = Jsoup.parse(html); + + // Extract search results + List results = new ArrayList<>(); + Elements resultElements = doc.select(".result__body"); + + for (Element element : resultElements.subList(0, Math.min(resultElements.size(), 10))) { + Element titleEl = element.selectFirst(".result__title"); + Element snippetEl = element.selectFirst(".result__snippet"); + + String title = titleEl != null ? titleEl.text() : ""; + String snippet = snippetEl != null ? snippetEl.text() : ""; + + if (!title.isBlank() && !snippet.isBlank()) { + results.add(title + ": " + snippet); + } + } + + if (results.isEmpty()) { + return Collections.singletonList("No recent web discussions found."); + } else { + return results; + } + } + } catch (Exception e) { + return Collections.singletonList("Error fetching web sentiment: " + e.getMessage()); + } + } +} diff --git a/backend/src/main/java/com/stockanalyzer/service/StockDataService.java b/backend/src/main/java/com/stockanalyzer/service/StockDataService.java new file mode 100644 index 0000000..974c24e --- /dev/null +++ b/backend/src/main/java/com/stockanalyzer/service/StockDataService.java @@ -0,0 +1,368 @@ +package com.stockanalyzer.service; + +import com.fasterxml.jackson.databind.JsonNode; +import com.fasterxml.jackson.databind.ObjectMapper; +import okhttp3.OkHttpClient; +import okhttp3.Request; +import okhttp3.Response; +import org.springframework.stereotype.Service; + +import java.time.LocalDate; +import java.time.format.DateTimeFormatter; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +@Service +public class StockDataService { + + private final OkHttpClient httpClient; + private final ObjectMapper objectMapper; + + public StockDataService(ObjectMapper objectMapper) { + this.httpClient = new OkHttpClient(); + this.objectMapper = objectMapper; + } + + public record StockData( + String symbol, + Double currentPrice, + Double changePercent, + Map fundamentals, + Map technicals, + String error) { + } + + public record MarketContextData( + String symbol, + Double changePercent, + Double price) { + } + + public String getTickerFromIsin(String isin) { + String url = "https://query2.finance.yahoo.com/v1/finance/search?q=" + isin; + Request request = new Request.Builder() + .url(url) + .header("User-Agent", "Mozilla/5.0") + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (response.isSuccessful() && response.body() != null) { + JsonNode json = objectMapper.readTree(response.body().string()); + JsonNode quotes = json.get("quotes"); + if (quotes != null && quotes.size() > 0) { + JsonNode symbolNode = quotes.get(0).get("symbol"); + return symbolNode != null ? symbolNode.asText() : isin; + } + } + } catch (Exception e) { + System.out.println("Error resolving ISIN " + isin + ": " + e.getMessage()); + } + return isin; + } + + public StockData getStockPrice(String isin) { + String tickerSymbol = getTickerFromIsin(isin); + System.out.println("Resolved " + isin + " to " + tickerSymbol); + + try { + String quoteUrl = "https://query1.finance.yahoo.com/v8/finance/chart/" + tickerSymbol + + "?interval=1d&range=1mo"; + Request request = new Request.Builder() + .url(quoteUrl) + .header("User-Agent", "Mozilla/5.0") + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (!response.isSuccessful() || response.body() == null) { + return new StockData("", 0.0, 0.0, Collections.emptyMap(), Collections.emptyMap(), + "Failed to fetch data"); + } + + JsonNode json = objectMapper.readTree(response.body().string()); + JsonNode chart = json.get("chart"); + if (chart == null) + return new StockData("", 0.0, 0.0, Collections.emptyMap(), Collections.emptyMap(), "No data found"); + + JsonNode resultNode = chart.get("result"); + if (resultNode == null || resultNode.size() == 0) { + return new StockData("", 0.0, 0.0, Collections.emptyMap(), Collections.emptyMap(), "No data found"); + } + + JsonNode result = resultNode.get(0); + JsonNode meta = result.get("meta"); + + double currentPrice = meta.has("regularMarketPrice") ? meta.get("regularMarketPrice").asDouble() : 0.0; + double previousClose = meta.has("chartPreviousClose") ? meta.get("chartPreviousClose").asDouble() + : currentPrice; + double changePercent = ((currentPrice - previousClose) / previousClose) * 100; + + // Technicals + JsonNode indicators = result.get("indicators"); + JsonNode quote = indicators != null ? indicators.get("quote") : null; + JsonNode closes = (quote != null && quote.size() > 0) ? quote.get(0).get("close") : null; + + Map technicals; + if (closes != null && closes.size() > 0) { + technicals = calculateTechnicals(closes); + } else { + technicals = Map.of("sma_20", "N/A", "rsi", "N/A"); + } + + // Fundamentals + Map fundamentals = getFundamentals(tickerSymbol); + + return new StockData( + tickerSymbol, + currentPrice, + changePercent, + fundamentals, + technicals, + null); + } + } catch (Exception e) { + return new StockData("", 0.0, 0.0, Collections.emptyMap(), Collections.emptyMap(), e.getMessage()); + } + } + + private Map getFundamentals(String symbol) { + try { + String url = "https://query1.finance.yahoo.com/v10/finance/quoteSummary/" + symbol + + "?modules=financialData,defaultKeyStatistics,price"; + Request request = new Request.Builder() + .url(url) + .header("User-Agent", "Mozilla/5.0") + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (!response.isSuccessful() || response.body() == null) { + return Collections.emptyMap(); + } + + JsonNode json = objectMapper.readTree(response.body().string()); + JsonNode quoteSummary = json.get("quoteSummary"); + if (quoteSummary == null) + return Collections.emptyMap(); + + JsonNode resultNode = quoteSummary.get("result"); + if (resultNode == null || resultNode.size() == 0) + return Collections.emptyMap(); + + JsonNode result = resultNode.get(0); + JsonNode financialData = result.get("financialData"); + JsonNode keyStats = result.get("defaultKeyStatistics"); + JsonNode price = result.get("price"); + + Map map = new HashMap<>(); + map.put("pe_ratio", safelyGet(keyStats, "trailingPE", "raw")); + map.put("market_cap", safelyGet(price, "marketCap", "raw")); + map.put("high_52w", safelyGet(keyStats, "fiftyTwoWeekHigh", "raw")); + map.put("low_52w", safelyGet(keyStats, "fiftyTwoWeekLow", "raw")); + map.put("target_mean_price", safelyGet(financialData, "targetMeanPrice", "raw")); + + String recommendationKey = "N/A"; + if (financialData != null && financialData.has("recommendationKey")) { + recommendationKey = financialData.get("recommendationKey").asText(); + } + map.put("recommendation_key", recommendationKey); + + return map; + } + } catch (Exception e) { + System.out.println("Error fetching fundamentals: " + e.getMessage()); + return Collections.emptyMap(); + } + } + + private String safelyGet(JsonNode node, String key, String subKey) { + if (node == null || !node.has(key)) + return "N/A"; + JsonNode subNode = node.get(key); + if (subNode == null || !subNode.has(subKey)) + return "N/A"; + return subNode.get(subKey).asText(); + } + + private Map calculateTechnicals(JsonNode closes) { + List closesList = new ArrayList<>(); + for (int i = 0; i < closes.size(); i++) { + JsonNode close = closes.get(i); + if (close != null && !close.isNull()) { + closesList.add(close.asDouble()); + } + } + + if (closesList.isEmpty()) { + return Map.of("sma_20", "N/A", "rsi", "N/A"); + } + + // SMA 20 + String sma20 = "N/A"; + if (closesList.size() >= 20) { + double sum = 0; + for (int i = closesList.size() - 20; i < closesList.size(); i++) { + sum += closesList.get(i); + } + sma20 = String.valueOf(sum / 20); + } + + // RSI 14 + String rsi = "N/A"; + if (closesList.size() >= 15) { + rsi = String.valueOf(calculateRSI(closesList, 14)); + } + + return Map.of("sma_20", sma20, "rsi", rsi); + } + + private double calculateRSI(List prices, int period) { + if (prices.size() < period + 1) + return 0.0; + + List changes = new ArrayList<>(); + for (int i = 1; i < prices.size(); i++) { + changes.add(prices.get(i) - prices.get(i - 1)); + } + + List gains = new ArrayList<>(); + List losses = new ArrayList<>(); + + for (Double change : changes) { + if (change > 0) { + gains.add(change); + losses.add(0.0); + } else { + gains.add(0.0); + losses.add(Math.abs(change)); + } + } + + // Initial average + double avgGain = 0; + double avgLoss = 0; + + // Use simple average for the first period (standard RSI calculation usually + // uses simple average for first step then smoothing) + // But the Kotlin code used takeLast(period).average() which is a simple moving + // average of the LAST period. + // I will replicate the Kotlin logic: "val avgGain = + // gains.takeLast(period).average()" + + int startIndex = gains.size() - period; + if (startIndex < 0) + startIndex = 0; // Should not happen due to check above + + double sumGain = 0; + double sumLoss = 0; + + for (int i = startIndex; i < gains.size(); i++) { + sumGain += gains.get(i); + sumLoss += losses.get(i); + } + + avgGain = sumGain / period; + avgLoss = sumLoss / period; + + if (avgLoss == 0.0) + return 100.0; + + double rs = avgGain / avgLoss; + return 100 - (100 / (1 + rs)); + } + + public MarketContextData getMarketContext() { + try { + String url = "https://query1.finance.yahoo.com/v8/finance/chart/%5EGSPC?interval=1d&range=5d"; + Request request = new Request.Builder() + .url(url) + .header("User-Agent", "Mozilla/5.0") + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (!response.isSuccessful() || response.body() == null) + return null; + + JsonNode json = objectMapper.readTree(response.body().string()); + JsonNode chart = json.get("chart"); + if (chart == null) + return null; + JsonNode resultNode = chart.get("result"); + if (resultNode == null || resultNode.size() == 0) + return null; + + JsonNode result = resultNode.get(0); + JsonNode indicators = result.get("indicators"); + JsonNode quote = indicators != null ? indicators.get("quote") : null; + JsonNode closes = (quote != null && quote.size() > 0) ? quote.get(0).get("close") : null; + + if (closes != null && closes.size() >= 2) { + double current = closes.get(closes.size() - 1).asDouble(); + double prev = closes.get(closes.size() - 2).asDouble(); + double change = ((current - prev) / prev) * 100; + + return new MarketContextData("^GSPC", change, current); + } + } + } catch (Exception e) { + System.out.println("Error fetching market context: " + e.getMessage()); + } + return null; + } + + public Double getHistoricalPrice(String symbol, String dateStr) { + try { + LocalDate date = LocalDate.parse(dateStr, DateTimeFormatter.ISO_LOCAL_DATE); + // Use UTC start of day for periods + long period1 = date.minusDays(5).atStartOfDay(java.time.ZoneOffset.UTC).toEpochSecond(); + long period2 = date.plusDays(5).atStartOfDay(java.time.ZoneOffset.UTC).toEpochSecond(); + + String url = "https://query1.finance.yahoo.com/v8/finance/chart/" + symbol + + "?interval=1d&period1=" + period1 + + "&period2=" + period2; + + Request request = new Request.Builder() + .url(url) + .header("User-Agent", "Mozilla/5.0") + .build(); + + try (Response response = httpClient.newCall(request).execute()) { + if (!response.isSuccessful() || response.body() == null) + return null; + + JsonNode json = objectMapper.readTree(response.body().string()); + JsonNode chart = json.get("chart"); + if (chart == null) + return null; + JsonNode resultNode = chart.get("result"); + if (resultNode == null || resultNode.size() == 0) + return null; + + JsonNode result = resultNode.get(0); + JsonNode timestamps = result.get("timestamp"); + JsonNode indicators = result.get("indicators"); + JsonNode quote = indicators != null ? indicators.get("quote") : null; + JsonNode closes = (quote != null && quote.size() > 0) ? quote.get(0).get("close") : null; + + if (timestamps != null && closes != null) { + for (int i = 0; i < timestamps.size(); i++) { + long ts = timestamps.get(i).asLong(); + // Convert timestamp to LocalDate in UTC to match targetDate logic + LocalDate tsDate = java.time.Instant.ofEpochSecond(ts).atZone(java.time.ZoneOffset.UTC).toLocalDate(); + + if (tsDate.equals(date)) { + JsonNode closeNode = closes.get(i); + if (closeNode != null && !closeNode.isNull()) { + return closeNode.asDouble(); + } + } + } + } + } + } catch (Exception e) { + System.out.println("Error fetching historical price: " + e.getMessage()); + } + return null; + } +} diff --git a/backend/src/main/resources/application.yml b/backend/src/main/resources/application.yml new file mode 100644 index 0000000..9a2de92 --- /dev/null +++ b/backend/src/main/resources/application.yml @@ -0,0 +1,31 @@ +spring: + application: + name: stock-analyzer + data: + mongodb: + uri: ${MONGO_URI:mongodb://localhost:27017/stock_analyzer} + database: stock_analyzer + +server: + port: 8080 + +# API Keys (from environment variables) +api: + openai: + key: ${OPENAI_API_KEY:} + model: ${OPENAI_MODEL:gpt-4o} + anthropic: + key: ${ANTHROPIC_API_KEY:} + model: ${ANTHROPIC_MODEL:claude-sonnet-4-5} + news: + key: ${NEWS_API_KEY:} + +# CORS Configuration +cors: + allowed-origins: ${CORS_ORIGINS:http://localhost:5173,http://localhost:3000,http://localhost,http://127.0.0.1,http://192.168.178.42:3000} + +# Logging +logging: + level: + com.stockanalyzer: INFO + org.springframework.data.mongodb: DEBUG diff --git a/build-and-push.sh b/build-and-push.sh new file mode 100755 index 0000000..782f6be --- /dev/null +++ b/build-and-push.sh @@ -0,0 +1,45 @@ +#!/bin/bash + +# Exit on error +set -e + +# Check if username is provided + +if [ -z "$1" ]; then + echo "Usage: ./build-and-push.sh [version]" + exit 1 +fi + +USERNAME=$1 +VERSION=${2:-latest} + +echo "Building and pushing for Docker Hub user: $USERNAME" + +# Build Backend +echo "==========================================" +echo "Building Backend..." +echo "==========================================" +cd backend +docker build -t $USERNAME/stock-analyzer-backend:$VERSION . +cd .. + +# Build Frontend +echo "==========================================" +echo "Building Frontend..." +echo "==========================================" +cd frontend +docker build -t $USERNAME/stock-analyzer-frontend:$VERSION . +cd .. + +# Push Images +echo "==========================================" +echo "Pushing Images to Docker Hub..." +echo "==========================================" +docker push $USERNAME/stock-analyzer-backend:$VERSION +docker push $USERNAME/stock-analyzer-frontend:$VERSION + +echo "==========================================" +echo "Done! Images pushed:" +echo " - $USERNAME/stock-analyzer-backend:$VERSION" +echo " - $USERNAME/stock-analyzer-frontend:$VERSION" +echo "==========================================" diff --git a/docker-compose-fullstack.yml b/docker-compose-fullstack.yml new file mode 100644 index 0000000..dd19373 --- /dev/null +++ b/docker-compose-fullstack.yml @@ -0,0 +1,51 @@ +version: '3.8' + +services: + mongodb: + image: mongo:latest + container_name: stock-analyzer-mongodb + ports: + - "27017:27017" + volumes: + - mongodb_data:/data/db + networks: + - stock-analyzer-network + + backend: + build: + context: ./backend + dockerfile: Dockerfile + container_name: stock-analyzer-backend + ports: + - "8080:8080" + environment: + - MONGO_URI=mongodb://mongodb:27017/stock_analyzer + - OPENAI_API_KEY=${OPENAI_API_KEY} + - OPENAI_MODEL=${OPENAI_MODEL:-gpt-4o} + - ANTHROPIC_API_KEY=${ANTHROPIC_API_KEY} + - ANTHROPIC_MODEL=${ANTHROPIC_MODEL:-claude-sonnet-4-5} + - NEWS_API_KEY=${NEWS_API_KEY} + depends_on: + - mongodb + networks: + - stock-analyzer-network + + frontend: + build: + context: ./frontend + dockerfile: Dockerfile + container_name: stock-analyzer-frontend + ports: + - "80:80" + depends_on: + - backend + networks: + - stock-analyzer-network + +volumes: + mongodb_data: + + +networks: + stock-analyzer-network: + driver: bridge diff --git a/env.example b/env.example new file mode 100644 index 0000000..66ce129 --- /dev/null +++ b/env.example @@ -0,0 +1,6 @@ +OPENAI_API_KEY=your_openai_key +ANTHROPIC_API_KEY=your_anthropic_key +NEWS_API_KEY=your_newsapi_key +TWITTER_BEARER_TOKEN=your_twitter_token +OPENAI_MODEL=gpt-4o +ANTHROPIC_MODEL=claude-sonnet-4-5 diff --git a/frontend/.dockerignore b/frontend/.dockerignore new file mode 100644 index 0000000..f06235c --- /dev/null +++ b/frontend/.dockerignore @@ -0,0 +1,2 @@ +node_modules +dist diff --git a/frontend/Dockerfile b/frontend/Dockerfile new file mode 100644 index 0000000..c61728d --- /dev/null +++ b/frontend/Dockerfile @@ -0,0 +1,16 @@ +# Build stage +FROM node:18-alpine AS build +WORKDIR /app +COPY package*.json ./ +RUN npm install +COPY . . +RUN npm run build + +# Production stage +FROM nginx:alpine +COPY --from=build /app/dist /usr/share/nginx/html +COPY nginx.conf /etc/nginx/conf.d/default.conf + +EXPOSE 80 + +CMD ["nginx", "-g", "daemon off;"] diff --git a/frontend/index.html b/frontend/index.html new file mode 100644 index 0000000..2fcdf53 --- /dev/null +++ b/frontend/index.html @@ -0,0 +1,16 @@ + + + + + + + Stock Sentiment Analyzer + + + + + +
+ + + diff --git a/frontend/nginx.conf b/frontend/nginx.conf new file mode 100644 index 0000000..8bf4be0 --- /dev/null +++ b/frontend/nginx.conf @@ -0,0 +1,20 @@ +server { + listen 80; + server_name localhost; + root /usr/share/nginx/html; + index index.html; + + location / { + try_files $uri $uri/ /index.html; + } + + location /api { + proxy_pass http://192.168.178.42:9000; + proxy_http_version 1.1; + proxy_set_header Upgrade $http_upgrade; + proxy_set_header Connection 'upgrade'; + proxy_set_header Host $host; + proxy_cache_bypass $http_upgrade; + proxy_read_timeout 300; + } +} diff --git a/frontend/package.json b/frontend/package.json new file mode 100644 index 0000000..8941cd4 --- /dev/null +++ b/frontend/package.json @@ -0,0 +1,26 @@ +{ + "name": "stock-analyzer-frontend", + "private": true, + "version": "0.0.1", + "type": "module", + "scripts": { + "dev": "vite", + "build": "vue-tsc && vite build", + "preview": "vite preview" + }, + "dependencies": { + "axios": "^1.6.7", + "chart.js": "^4.4.1", + "pinia": "^2.1.7", + "vue": "^3.4.21", + "vue-chartjs": "^5.3.0", + "vue-router": "^4.3.0" + }, + "devDependencies": { + "@types/node": "^24.10.1", + "@vitejs/plugin-vue": "^5.0.4", + "typescript": "~5.2.2", + "vite": "^5.1.6", + "vue-tsc": "^1.8.27" + } +} diff --git a/frontend/src/App.vue b/frontend/src/App.vue new file mode 100644 index 0000000..9d8f408 --- /dev/null +++ b/frontend/src/App.vue @@ -0,0 +1,91 @@ + + + + + diff --git a/frontend/src/components/AnalysisCard.vue b/frontend/src/components/AnalysisCard.vue new file mode 100644 index 0000000..441d0d5 --- /dev/null +++ b/frontend/src/components/AnalysisCard.vue @@ -0,0 +1,307 @@ + + + + + diff --git a/frontend/src/components/WatchlistSidebar.vue b/frontend/src/components/WatchlistSidebar.vue new file mode 100644 index 0000000..a645e02 --- /dev/null +++ b/frontend/src/components/WatchlistSidebar.vue @@ -0,0 +1,228 @@ + + + + + diff --git a/frontend/src/main.ts b/frontend/src/main.ts new file mode 100644 index 0000000..0224174 --- /dev/null +++ b/frontend/src/main.ts @@ -0,0 +1,12 @@ +import { createApp } from 'vue' +import { createPinia } from 'pinia' +import router from './router/index' +import App from './App.vue' +import './style.css' + +const app = createApp(App) + +app.use(createPinia()) +app.use(router) + +app.mount('#app') diff --git a/frontend/src/router/index.ts b/frontend/src/router/index.ts new file mode 100644 index 0000000..aeff306 --- /dev/null +++ b/frontend/src/router/index.ts @@ -0,0 +1,15 @@ +import { createRouter, createWebHistory } from 'vue-router' +import History from '../views/History.vue' + +const router = createRouter({ + history: createWebHistory(import.meta.env.BASE_URL), + routes: [ + { + path: '/', + name: 'history', + component: History + } + ] +}) + +export default router diff --git a/frontend/src/store/index.ts b/frontend/src/store/index.ts new file mode 100644 index 0000000..39ec721 --- /dev/null +++ b/frontend/src/store/index.ts @@ -0,0 +1,278 @@ +import { defineStore } from 'pinia' +import axios from 'axios' +import { ref } from 'vue' + +export interface Stock { + isin: string + symbol: string | null + name: string | null + addedAt: string +} + +export interface LLMAnalysis { + prediction: string + probability: number + reasoning: string + error?: string +} + +export interface Fundamentals { + peRatio: string + marketCap: string + high52w: string + low52w: string + targetMeanPrice: string + recommendationKey: string +} + +export interface Technicals { + sma20: string + rsi: string +} + +export interface MarketContext { + symbol: string + changePercent: number + price: number +} + +export interface AnalysisResult { + id?: string + isin: string + symbol: string + price: number + realPrice?: number + changePercent: number + fundamentals: Fundamentals + technicals: Technicals + marketContext: MarketContext | null + newsHeadlines: string[] + socialPosts: string[] + llmAnalysisOpenai: LLMAnalysis + llmAnalysisAnthropic: LLMAnalysis + analyzedAt: string + date: string + targetDate: string +} + +export interface AnalysisJob { + id: string + isin: string + symbol: string + status: 'PENDING' | 'PROCESSING' | 'COMPLETED' | 'FAILED' | 'CANCELLED' + error?: string + createdAt: string + startedAt?: string + completedAt?: string +} + +export const useStockStore = defineStore('stock', () => { + const watchlist = ref([]) + const analysisResults = ref([]) + const analysisJobs = ref([]) + const marketContext = ref(null) + const loading = ref(false) + const error = ref(null) + + const apiClient = axios.create({ + baseURL: '/api' + }) + + async function fetchWatchlist() { + try { + const response = await apiClient.get('/watchlist') + watchlist.value = response.data + } catch (e: any) { + error.value = e.message + throw e + } + } + + async function addToWatchlist(isin: string) { + try { + loading.value = true + await apiClient.post('/watchlist', { isin }) + await fetchWatchlist() + } catch (e: any) { + error.value = e.response?.data?.error || e.message + throw e + } finally { + loading.value = false + } + } + + async function removeFromWatchlist(isin: string) { + try { + await apiClient.delete(`/watchlist/${isin}`) + await fetchWatchlist() + } catch (e: any) { + error.value = e.message + throw e + } + } + + async function startAnalysis(isin?: string) { + try { + loading.value = true + error.value = null + + const url = isin ? `/analysis/run/${isin}` : '/analysis/run' + // This now returns a list of created jobs + const response = await apiClient.post(url) + analysisJobs.value = response.data + + // Start polling + pollJobs() + + return response.data + } catch (e: any) { + error.value = e.message + loading.value = false // Stop loading if start failed + throw e + } + } + + async function stopAnalysis() { + try { + await apiClient.post('/analysis/stop') + await fetchJobs() // Refresh status immediately + } catch (e: any) { + error.value = e.message + throw e + } + } + + async function fetchJobs() { + try { + const response = await apiClient.get('/analysis/jobs') + analysisJobs.value = response.data + + // If there are active jobs, set loading to true and start polling + const hasActiveJobs = analysisJobs.value.some(job => + job.status === 'PENDING' || job.status === 'PROCESSING' + ) + + if (hasActiveJobs) { + loading.value = true + pollJobs() + } + } catch (e) { + console.error("Failed to fetch jobs", e) + } + } + + let pollingInterval: any = null + + async function pollJobs() { + if (pollingInterval) return // Already polling + + pollingInterval = setInterval(async () => { + try { + const response = await apiClient.get('/analysis/jobs') + analysisJobs.value = response.data + + // Check if all jobs are done (COMPLETED or FAILED) + const hasActiveJobs = analysisJobs.value.some(job => + job.status === 'PENDING' || job.status === 'PROCESSING' + ) + + if (!hasActiveJobs) { + clearInterval(pollingInterval) + pollingInterval = null + loading.value = false + + // Fetch latest results to show them + const latestResults = await fetchHistory() + analysisResults.value = latestResults.filter(r => + analysisJobs.value.some(j => j.isin === r.isin && j.status === 'COMPLETED') + ) + } + } catch (e) { + console.error("Polling failed", e) + } + }, 2000) + } + + async function fetchMarketContext() { + try { + const response = await apiClient.get('/analysis/market-context') + if (!response.data.error) { + marketContext.value = response.data as MarketContext + } + } catch (e: any) { + console.error('Failed to fetch market context:', e) + } + } + + async function fetchHistory() { + try { + const response = await apiClient.get('/analysis/history') + return response.data + } catch (e: any) { + error.value = e.message + throw e + } + } + + + async function fetchHistoryByIsin(isin: string) { + try { + const response = await apiClient.get(`/analysis/history/${isin}`) + return response.data + } catch (e: any) { + error.value = e.message + throw e + } + } + + async function deleteHistoryByDateRange(startDate: string, endDate: string) { + try { + const response = await apiClient.delete('/analysis/history', { + data: { startDate, endDate } + }) + return response.data + } catch (e: any) { + error.value = e.message + throw e + } + } + + async function getHistoricalPrice(symbol: string, date: string) { + try { + const response = await apiClient.get(`/analysis/historical-price/${symbol}/${date}`) + return response.data.price || null + } catch (e: any) { + return null + } + } + + async function refreshRealPrice(id: string) { + try { + const response = await apiClient.post(`/analysis/history/${id}/refresh-price`) + return response.data + } catch (e: any) { + throw e + } + } + + return { + watchlist, + analysisResults, + analysisJobs, + marketContext, + loading, + error, + fetchWatchlist, + addToWatchlist, + removeFromWatchlist, + startAnalysis, + stopAnalysis, + fetchJobs, + fetchMarketContext, + fetchHistory, + fetchHistoryByIsin, + deleteHistoryByDateRange, + getHistoricalPrice, + refreshRealPrice + } +}) diff --git a/frontend/src/style.css b/frontend/src/style.css new file mode 100644 index 0000000..ad3a3bc --- /dev/null +++ b/frontend/src/style.css @@ -0,0 +1,394 @@ +:root { + /* Color Palette */ + --primary-gradient: linear-gradient(135deg, #667eea 0%, #764ba2 100%); + --secondary-gradient: linear-gradient(135deg, #f093fb 0%, #f5576c 100%); + --success-gradient: linear-gradient(135deg, #4facfe 0%, #00f2fe 100%); + --danger-gradient: linear-gradient(135deg, #fa709a 0%, #fee140 100%); + + --bg-primary: #0f0c29; + --bg-secondary: #302b63; + --bg-tertiary: #24243e; + + --text-primary: #ffffff; + --text-secondary: rgba(255, 255, 255, 0.7); + --text-muted: rgba(255, 255, 255, 0.5); + + --glass-bg: rgba(255, 255, 255, 0.05); + --glass-border: rgba(255, 255, 255, 0.1); + + /* Spacing */ + --spacing-xs: 0.25rem; + --spacing-sm: 0.5rem; + --spacing-md: 1rem; + --spacing-lg: 1.5rem; + --spacing-xl: 2rem; + + /* Border Radius */ + --radius-sm: 4px; + --radius-md: 8px; + --radius-lg: 12px; + --radius-xl: 16px; + + /* Shadows */ + --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.1); + --shadow-md: 0 4px 16px rgba(0, 0, 0, 0.2); + --shadow-lg: 0 8px 32px rgba(0, 0, 0, 0.3); + + /* Transitions */ + --transition-fast: 0.15s ease; + --transition-base: 0.3s ease; + --transition-slow: 0.5s ease; +} + +* { + margin: 0; + padding: 0; + box-sizing: border-box; +} + +body { + font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; + color: var(--text-primary); + background: linear-gradient(135deg, var(--bg-primary) 0%, var(--bg-secondary) 50%, var(--bg-tertiary) 100%); + min-height: 100vh; + line-height: 1.6; + -webkit-font-smoothing: antialiased; + -moz-osx-font-smoothing: grayscale; +} + +/* Glass Card */ +.glass-card { + background: var(--glass-bg); + backdrop-filter: blur(10px); + border: 1px solid var(--glass-border); + border-radius: var(--radius-lg); + padding: var(--spacing-lg); + box-shadow: var(--shadow-md); + transition: all var(--transition-base); +} + +.glass-card:hover { + transform: translateY(-2px); + box-shadow: var(--shadow-lg); + border-color: rgba(255, 255, 255, 0.2); +} + +/* Buttons */ +.btn { + padding: 0.75rem 1.5rem; + border: none; + border-radius: var(--radius-md); + font-weight: 600; + font-size: 0.95rem; + cursor: pointer; + transition: all var(--transition-base); + text-decoration: none; + display: inline-flex; + align-items: center; + justify-content: center; + gap: 0.5rem; +} + +.btn-primary { + background: var(--primary-gradient); + color: white; + box-shadow: 0 4px 15px rgba(102, 126, 234, 0.4); +} + +.btn-primary:hover { + transform: translateY(-2px); + box-shadow: 0 6px 20px rgba(102, 126, 234, 0.6); +} + +.btn-primary:active { + transform: translateY(0); +} + +.btn-secondary { + background: var(--glass-bg); + color: var(--text-primary); + border: 1px solid var(--glass-border); +} + +.btn-secondary:hover { + background: rgba(255, 255, 255, 0.1); + border-color: rgba(255, 255, 255, 0.2); +} + +.btn-danger { + background: var(--danger-gradient); + color: white; + box-shadow: 0 4px 15px rgba(250, 112, 154, 0.4); +} + +.btn-danger:hover { + transform: translateY(-2px); + box-shadow: 0 6px 20px rgba(250, 112, 154, 0.6); +} + +.btn-sm { + padding: 0.5rem 1rem; + font-size: 0.875rem; +} + +.btn:disabled { + opacity: 0.5; + cursor: not-allowed; + transform: none !important; +} + +/* Input Fields */ +.input { + width: 100%; + padding: 0.75rem 1rem; + background: var(--glass-bg); + border: 1px solid var(--glass-border); + border-radius: var(--radius-md); + color: var(--text-primary); + font-size: 0.95rem; + transition: all var(--transition-base); +} + +.input:focus { + outline: none; + border-color: #667eea; + box-shadow: 0 0 0 3px rgba(102, 126, 234, 0.1); +} + +.input::placeholder { + color: var(--text-muted); +} + +/* Metrics */ +.metric-card { + background: var(--glass-bg); + backdrop-filter: blur(10px); + border: 1px solid var(--glass-border); + border-radius: var(--radius-md); + padding: var(--spacing-md); + text-align: center; +} + +.metric-label { + font-size: 0.875rem; + color: var(--text-secondary); + margin-bottom: 0.5rem; +} + +.metric-value { + font-size: 1.5rem; + font-weight: 700; + color: var(--text-primary); +} + +.metric-change { + font-size: 0.875rem; + margin-top: 0.25rem; +} + +.metric-change.positive { + color: #4ade80; +} + +.metric-change.negative { + color: #f87171; +} + +/* Tables */ +.table-container { + overflow-x: auto; + border-radius: var(--radius-lg); + background: var(--glass-bg); + backdrop-filter: blur(10px); + border: 1px solid var(--glass-border); +} + +table { + width: 100%; + border-collapse: collapse; +} + +thead { + background: rgba(255, 255, 255, 0.05); +} + +th { + padding: 1rem; + text-align: left; + font-weight: 600; + color: var(--text-primary); + border-bottom: 1px solid var(--glass-border); +} + +td { + padding: 1rem; + color: var(--text-secondary); + border-bottom: 1px solid rgba(255, 255, 255, 0.05); +} + +tbody tr { + transition: background var(--transition-fast); +} + +tbody tr:hover { + background: rgba(255, 255, 255, 0.03); +} + +/* Badges */ +.badge { + display: inline-block; + padding: 0.25rem 0.75rem; + border-radius: var(--radius-sm); + font-size: 0.875rem; + font-weight: 600; +} + +.badge-success { + background: linear-gradient(135deg, #4ade80 0%, #22c55e 100%); + color: white; +} + +.badge-danger { + background: linear-gradient(135deg, #f87171 0%, #ef4444 100%); + color: white; +} + +.badge-warning { + background: linear-gradient(135deg, #fbbf24 0%, #f59e0b 100%); + color: white; +} + +.badge-info { + background: linear-gradient(135deg, #60a5fa 0%, #3b82f6 100%); + color: white; +} + +/* Loading Spinner */ +.spinner { + border: 3px solid var(--glass-border); + border-top: 3px solid #667eea; + border-radius: 50%; + width: 40px; + height: 40px; + animation: spin 1s linear infinite; +} + +@keyframes spin { + 0% { transform: rotate(0deg); } + 100% { transform: rotate(360deg); } +} + +/* Progress Bar */ +.progress-bar { + width: 100%; + height: 8px; + background: var(--glass-bg); + border-radius: var(--radius-sm); + overflow: hidden; +} + +.progress-fill { + height: 100%; + background: var(--primary-gradient); + transition: width var(--transition-base); + animation: shimmer 2s infinite; +} + +@keyframes shimmer { + 0% { opacity: 0.6; } + 50% { opacity: 1; } + 100% { opacity: 0.6; } +} + +/* Alerts */ +.alert { + padding: 1rem 1.5rem; + border-radius: var(--radius-md); + margin-bottom: var(--spacing-md); + display: flex; + align-items: center; + gap: 0.75rem; +} + +.alert-info { + background: rgba(59, 130, 246, 0.1); + border: 1px solid rgba(59, 130, 246, 0.3); + color: #60a5fa; +} + +.alert-success { + background: rgba(34, 197, 94, 0.1); + border: 1px solid rgba(34, 197, 94, 0.3); + color: #4ade80; +} + +.alert-warning { + background: rgba(245, 158, 11, 0.1); + border: 1px solid rgba(245, 158, 11, 0.3); + color: #fbbf24; +} + +.alert-error { + background: rgba(239, 68, 68, 0.1); + border: 1px solid rgba(239, 68, 68, 0.3); + color: #f87171; +} + +/* Utility Classes */ +.text-center { text-align: center; } +.text-right { text-align: right; } +.text-muted { color: var(--text-muted); } +.text-secondary { color: var(--text-secondary); } + +.mt-1 { margin-top: var(--spacing-sm); } +.mt-2 { margin-top: var(--spacing-md); } +.mt-3 { margin-top: var(--spacing-lg); } +.mt-4 { margin-top: var(--spacing-xl); } + +.mb-1 { margin-bottom: var(--spacing-sm); } +.mb-2 { margin-bottom: var(--spacing-md); } +.mb-3 { margin-bottom: var(--spacing-lg); } +.mb-4 { margin-bottom: var(--spacing-xl); } + +.flex { display: flex; } +.flex-col { flex-direction: column; } +.items-center { align-items: center; } +.justify-between { justify-content: space-between; } +.gap-1 { gap: var(--spacing-sm); } +.gap-2 { gap: var(--spacing-md); } +.gap-3 { gap: var(--spacing-lg); } + +/* Responsive Grid */ +.grid { + display: grid; + gap: var(--spacing-lg); +} + +.grid-cols-2 { + grid-template-columns: repeat(2, 1fr); +} + +.grid-cols-3 { + grid-template-columns: repeat(3, 1fr); +} + +.grid-cols-4 { + grid-template-columns: repeat(4, 1fr); +} + +@media (max-width: 1024px) { + .grid-cols-4 { + grid-template-columns: repeat(2, 1fr); + } + .grid-cols-3 { + grid-template-columns: repeat(2, 1fr); + } +} + +@media (max-width: 640px) { + .grid-cols-4, + .grid-cols-3, + .grid-cols-2 { + grid-template-columns: 1fr; + } +} diff --git a/frontend/src/views/Dashboard.vue b/frontend/src/views/Dashboard.vue new file mode 100644 index 0000000..2744a5a --- /dev/null +++ b/frontend/src/views/Dashboard.vue @@ -0,0 +1,231 @@ + + + + + diff --git a/frontend/src/views/History.vue b/frontend/src/views/History.vue new file mode 100644 index 0000000..8c08b30 --- /dev/null +++ b/frontend/src/views/History.vue @@ -0,0 +1,543 @@ + + + + + diff --git a/frontend/src/vite-env.d.ts b/frontend/src/vite-env.d.ts new file mode 100644 index 0000000..c71587c --- /dev/null +++ b/frontend/src/vite-env.d.ts @@ -0,0 +1,7 @@ +/// + +declare module '*.vue' { + import type { DefineComponent } from 'vue' + const component: DefineComponent<{}, {}, any> + export default component +} diff --git a/frontend/tsconfig.json b/frontend/tsconfig.json new file mode 100644 index 0000000..776817b --- /dev/null +++ b/frontend/tsconfig.json @@ -0,0 +1,43 @@ +{ + "compilerOptions": { + "target": "ES2020", + "useDefineForClassFields": true, + "module": "ESNext", + "lib": [ + "ES2020", + "DOM", + "DOM.Iterable" + ], + "skipLibCheck": true, + /* Bundler mode */ + "moduleResolution": "bundler", + "allowImportingTsExtensions": true, + "resolveJsonModule": true, + "isolatedModules": true, + "noEmit": true, + "jsx": "preserve", + /* Linting */ + "strict": true, + "noUnusedLocals": true, + "noUnusedParameters": true, + "noFallthroughCasesInSwitch": true, + /* Path mapping */ + "baseUrl": ".", + "paths": { + "@/*": [ + "./src/*" + ] + } + }, + "include": [ + "src/**/*.ts", + "src/**/*.d.ts", + "src/**/*.tsx", + "src/**/*.vue" + ], + "references": [ + { + "path": "./tsconfig.node.json" + } + ] +} \ No newline at end of file diff --git a/frontend/tsconfig.node.json b/frontend/tsconfig.node.json new file mode 100644 index 0000000..2d07d65 --- /dev/null +++ b/frontend/tsconfig.node.json @@ -0,0 +1,15 @@ +{ + "compilerOptions": { + "composite": true, + "skipLibCheck": true, + "module": "ESNext", + "moduleResolution": "bundler", + "allowSyntheticDefaultImports": true, + "types": [ + "node" + ] + }, + "include": [ + "vite.config.ts" + ] +} \ No newline at end of file diff --git a/frontend/vite.config.ts b/frontend/vite.config.ts new file mode 100644 index 0000000..59e1fa8 --- /dev/null +++ b/frontend/vite.config.ts @@ -0,0 +1,21 @@ +import { defineConfig } from 'vite' +import vue from '@vitejs/plugin-vue' +import { fileURLToPath, URL } from 'node:url' + +export default defineConfig({ + plugins: [vue()], + resolve: { + alias: { + '@': fileURLToPath(new URL('./src', import.meta.url)) + } + }, + server: { + port: 5173, + proxy: { + '/api': { + target: 'http://localhost:8080', + changeOrigin: true + } + } + } +}) diff --git a/start.sh b/start.sh new file mode 100755 index 0000000..c980996 --- /dev/null +++ b/start.sh @@ -0,0 +1,87 @@ +#!/bin/bash + +# Stock Analyzer - Quick Start Script + +set -e + +echo "🚀 Stock Analyzer - Quick Start" +echo "================================" +echo "" + +# Check if .env file exists +if [ ! -f .env ]; then + echo "âš ī¸ No .env file found. Creating from env.example..." + if [ -f env.example ]; then + cp env.example .env + echo "✅ Created .env file. Please edit it with your API keys." + echo "" + echo "Required API keys:" + echo " - OPENAI_API_KEY" + echo " - ANTHROPIC_API_KEY" + echo " - NEWS_API_KEY" + echo "" + read -p "Press Enter after you've configured your API keys..." + else + echo "❌ env.example not found. Please create a .env file manually." + exit 1 + fi +fi + +# Load environment variables +export $(cat .env | grep -v '^#' | xargs) + +echo "1ī¸âƒŖ Starting MongoDB..." +docker run -d -p 27017:27017 --name stock-analyzer-mongodb mongo:latest 2>/dev/null || docker start stock-analyzer-mongodb +echo "✅ MongoDB started" +echo "" + +echo "2ī¸âƒŖ Starting Backend (Spring Boot)..." +cd backend +./gradlew bootRun & +BACKEND_PID=$! +cd .. +echo "✅ Backend starting on http://localhost:8080" +echo "" + +# Wait for backend to be ready +echo "âŗ Waiting for backend to be ready..." +for i in {1..30}; do + if curl -s http://localhost:8080/actuator/health > /dev/null 2>&1; then + echo "✅ Backend is ready!" + break + fi + sleep 2 +done +echo "" + +echo "3ī¸âƒŖ Installing Frontend Dependencies..." +cd frontend +if [ ! -d "node_modules" ]; then + npm install +fi +echo "✅ Dependencies installed" +echo "" + +echo "4ī¸âƒŖ Starting Frontend (Vue.js)..." +npm run dev & +FRONTEND_PID=$! +cd .. +echo "✅ Frontend starting on http://localhost:5173" +echo "" + +echo "================================" +echo "✨ Stock Analyzer is running!" +echo "================================" +echo "" +echo "📊 Frontend: http://localhost:5173" +echo "🔧 Backend: http://localhost:8080" +echo "đŸ—„ī¸ MongoDB: mongodb://localhost:27017" +echo "" +echo "Press Ctrl+C to stop all services" +echo "" + +# Trap Ctrl+C and cleanup +trap "echo ''; echo '🛑 Stopping services...'; kill $BACKEND_PID $FRONTEND_PID 2>/dev/null; docker stop stock-analyzer-mongodb 2>/dev/null; echo '✅ All services stopped'; exit 0" INT + +# Wait for processes +wait