Skip to content

FinceptTerminal is a modern finance application offering advanced market analytics, investment research, and economic data tools, designed for interactive exploration and data-driven decision-making in a user-friendly environment.

Add peer comparison analysis and fix technical indicators

Aviral26104db1835a3584
diff --git a/fincept-terminal-desktop/check-build.bat b/fincept-terminal-desktop/check-build.bat
new file mode 100644
index 000000000..b77b44b73
--- /dev/null
+++ b/fincept-terminal-desktop/check-build.bat
@@ -0,0 +1,5 @@
+@echo off
+set PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1
+cd src-tauri
+cargo check --message-format=short 2>&1 | findstr /V "cargo:rustc"
+pause
diff --git a/fincept-terminal-desktop/run-check.ps1 b/fincept-terminal-desktop/run-check.ps1
new file mode 100644
index 000000000..7d4504417
--- /dev/null
+++ b/fincept-terminal-desktop/run-check.ps1
@@ -0,0 +1,3 @@
+$env:PYO3_USE_ABI3_FORWARD_COMPATIBILITY = "1"
+Set-Location "C:\Users\avira\FinceptTerminal\fincept-terminal-desktop\src-tauri"
+cargo check 2>&1 | Tee-Object -FilePath "build-output.txt"
diff --git a/fincept-terminal-desktop/run-dev.bat b/fincept-terminal-desktop/run-dev.bat
new file mode 100644
index 000000000..2ad6d0580
--- /dev/null
+++ b/fincept-terminal-desktop/run-dev.bat
@@ -0,0 +1,5 @@
+@echo off
+set PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1
+set PATH=%USERPROFILE%\.cargo\bin;%PATH%
+cd /d C:\Users\avira\FinceptTerminal\fincept-terminal-desktop
+npm run tauri dev
diff --git a/fincept-terminal-desktop/run-dev.ps1 b/fincept-terminal-desktop/run-dev.ps1
new file mode 100644
index 000000000..c745352b6
--- /dev/null
+++ b/fincept-terminal-desktop/run-dev.ps1
@@ -0,0 +1,3 @@
+$env:PYO3_USE_ABI3_FORWARD_COMPATIBILITY = "1"
+Set-Location "C:\Users\avira\FinceptTerminal\fincept-terminal-desktop"
+& npm run tauri dev
diff --git a/fincept-terminal-desktop/src-tauri/.cargo/config.toml b/fincept-terminal-desktop/src-tauri/.cargo/config.toml
new file mode 100644
index 000000000..4c8e340c0
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/.cargo/config.toml
@@ -0,0 +1,2 @@
+[env]
+PYO3_USE_ABI3_FORWARD_COMPATIBILITY = "1"
diff --git a/fincept-terminal-desktop/src-tauri/build-output.txt b/fincept-terminal-desktop/src-tauri/build-output.txt
new file mode 100644
index 000000000..46d8bac30
Binary files /dev/null and b/fincept-terminal-desktop/src-tauri/build-output.txt differ
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/financial_analysis_cli.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/financial_analysis_cli.py
new file mode 100644
index 000000000..89881114c
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/financial_analysis_cli.py
@@ -0,0 +1,184 @@
+#!/usr/bin/env python3
+"""
+Financial Analysis CLI Wrapper
+==============================
+Command-line interface for the financial analysis module.
+Called by Tauri/Rust via PyO3.
+
+Usage:
+ python financial_analysis_cli.py <command> [args...]
+
+Commands:
+ analyze_income <json_data> - Income statement analysis
+ analyze_balance <json_data> - Balance sheet analysis
+ analyze_cashflow <json_data> - Cash flow analysis
+ analyze_comprehensive <json_data> - Full comprehensive analysis
+ get_key_metrics <json_data> - Quick key metrics summary
+"""
+import sys
+import json
+import os
+from datetime import date
+
+# Add parent directory to path for imports when running via PyO3
+script_dir = os.path.dirname(os.path.abspath(__file__)) if '__file__' in dir() else os.getcwd()
+if script_dir not in sys.path:
+ sys.path.insert(0, script_dir)
+
+from finanicalanalysis import (
+ DataProcessor, CompanyInfo, FinancialPeriod, ReportingStandard, DataSource,
+ IncomeStatementAnalyzer, BalanceSheetAnalyzer, CashFlowAnalyzer,
+ ComprehensiveAnalyzer, RiskLevel, AnalysisType
+)
+
+
+def parse_financial_data(json_str: str):
+ """Parse JSON input and create FinancialStatements object"""
+ data = json.loads(json_str)
+
+ # Extract company info
+ company_data = data.get("company", {})
+ company = CompanyInfo(
+ ticker=company_data.get("ticker", "UNKNOWN"),
+ name=company_data.get("name", "Unknown Company"),
+ sector=company_data.get("sector", "Unknown"),
+ industry=company_data.get("industry", "Unknown"),
+ country=company_data.get("country", "USA"),
+ reporting_standard=ReportingStandard.US_GAAP,
+ fiscal_year_end=company_data.get("fiscal_year_end", "December"),
+ presentation_currency=company_data.get("currency", "USD")
+ )
+
+ # Extract period info
+ period_data = data.get("period", {})
+ period = FinancialPeriod(
+ period_end=date.fromisoformat(period_data.get("period_end", "2024-12-31")),
+ period_type=period_data.get("period_type", "annual"),
+ fiscal_year=period_data.get("fiscal_year", 2024),
+ fiscal_period=period_data.get("fiscal_period", "FY"),
+ audit_status=period_data.get("audit_status", "unaudited")
+ )
+
+ # Extract financial data
+ financials = data.get("financials", {})
+
+ processor = DataProcessor()
+ return processor.process_data(financials, DataSource.MANUAL, company, period)
+
+
+def results_to_json(results: list) -> str:
+ """Convert analysis results to JSON"""
+ output = []
+ for r in results:
+ output.append({
+ "metric_name": r.metric_name,
+ "value": round(r.value, 6) if isinstance(r.value, float) else r.value,
+ "risk_level": r.risk_level.value,
+ "analysis_type": r.analysis_type.value,
+ "interpretation": r.interpretation,
+ "methodology": r.methodology if hasattr(r, "methodology") and r.methodology else None,
+ "benchmark_comparison": r.benchmark_comparison if hasattr(r, "benchmark_comparison") else None,
+ "limitations": r.limitations if hasattr(r, "limitations") and r.limitations else None,
+ })
+
+ # Create summary from first few results
+ summary = "Analysis complete. "
+ if output:
+ key_findings = [f"{r['metric_name']}: {r['interpretation'][:50]}..." for r in output[:3]]
+ summary += " | ".join(key_findings)
+
+ return json.dumps({"success": True, "results": output, "summary": summary}, indent=2)
+
+
+def analyze_income(json_data: str) -> str:
+ """Analyze income statement"""
+ statements = parse_financial_data(json_data)
+ analyzer = IncomeStatementAnalyzer(enable_logging=False)
+ results = analyzer.analyze(statements)
+ return results_to_json(results)
+
+
+def analyze_balance(json_data: str) -> str:
+ """Analyze balance sheet"""
+ statements = parse_financial_data(json_data)
+ analyzer = BalanceSheetAnalyzer(enable_logging=False)
+ results = analyzer.analyze(statements)
+ return results_to_json(results)
+
+
+def analyze_cashflow(json_data: str) -> str:
+ """Analyze cash flow statement"""
+ statements = parse_financial_data(json_data)
+ analyzer = CashFlowAnalyzer(enable_logging=False)
+ results = analyzer.analyze(statements)
+ return results_to_json(results)
+
+
+def analyze_comprehensive(json_data: str) -> str:
+ """Run comprehensive analysis across all statements"""
+ statements = parse_financial_data(json_data)
+ analyzer = ComprehensiveAnalyzer(enable_logging=False)
+ results = analyzer.analyze(statements)
+ return results_to_json(results)
+
+
+def get_key_metrics(json_data: str) -> str:
+ """Get quick key metrics summary"""
+ statements = parse_financial_data(json_data)
+
+ # Get key metrics from each analyzer
+ income_analyzer = IncomeStatementAnalyzer(enable_logging=False)
+ balance_analyzer = BalanceSheetAnalyzer(enable_logging=False)
+
+ income_metrics = income_analyzer.get_key_metrics(statements)
+ balance_metrics = balance_analyzer.get_key_metrics(statements)
+
+ # Combine metrics
+ all_metrics = {**income_metrics, **balance_metrics}
+
+ summary = f"Key metrics for {statements.company_info.ticker}: "
+ metric_strs = [f"{k}={v:.2f}" if isinstance(v, float) else f"{k}={v}" for k, v in list(all_metrics.items())[:5]]
+ summary += ", ".join(metric_strs)
+
+ return json.dumps({
+ "success": True,
+ "company": statements.company_info.ticker,
+ "period": str(statements.period_info.period_end),
+ "metrics": {k: round(v, 6) if isinstance(v, float) else v for k, v in all_metrics.items()},
+ "summary": summary
+ }, indent=2)
+
+
+def main(args: list) -> str:
+ """Main entry point for PyO3 execution"""
+ if len(args) < 2:
+ return json.dumps({
+ "success": False,
+ "error": "Usage: <command> <json_data>",
+ "commands": ["analyze_income", "analyze_balance", "analyze_cashflow", "analyze_comprehensive", "get_key_metrics"]
+ })
+
+ command = args[0]
+ json_data = args[1]
+
+ try:
+ if command == "analyze_income":
+ return analyze_income(json_data)
+ elif command == "analyze_balance":
+ return analyze_balance(json_data)
+ elif command == "analyze_cashflow":
+ return analyze_cashflow(json_data)
+ elif command == "analyze_comprehensive":
+ return analyze_comprehensive(json_data)
+ elif command == "get_key_metrics":
+ return get_key_metrics(json_data)
+ else:
+ return json.dumps({"success": False, "error": f"Unknown command: {command}"})
+ except Exception as e:
+ import traceback
+ return json.dumps({"success": False, "error": str(e), "traceback": traceback.format_exc()})
+
+
+if __name__ == "__main__":
+ result = main(sys.argv[1:])
+ print(result)
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/__init__.py
new file mode 100644
index 000000000..a685818a0
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/__init__.py
@@ -0,0 +1,12 @@
+"""Financial Analysis Package"""
+
+from .core.data_processor import DataProcessor, FinancialStatements, CompanyInfo, FinancialPeriod, ReportingStandard, DataSource
+from .core.base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, ComparativeAnalysis, QualityAssessment
+from .statement_analyzers.income_statement import IncomeStatementAnalyzer
+from .statement_analyzers.balance_sheet import BalanceSheetAnalyzer
+from .statement_analyzers.cash_flow import CashFlowAnalyzer
+from .statement_analyzers.comprehensive_analyzer import ComprehensiveAnalyzer
+
+__version__ = "1.0.0"
+__all__ = ["DataProcessor", "FinancialStatements", "CompanyInfo", "FinancialPeriod", "ReportingStandard", "DataSource", "BaseAnalyzer", "AnalysisResult", "AnalysisType", "RiskLevel", "TrendDirection", "ComparativeAnalysis", "QualityAssessment", "IncomeStatementAnalyzer", "BalanceSheetAnalyzer", "CashFlowAnalyzer", "ComprehensiveAnalyzer"]
+
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/__init__.py
new file mode 100644
index 000000000..3281d963c
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/core/__init__.py
@@ -0,0 +1,5 @@
+"""Core Module"""
+from .data_processor import DataProcessor, FinancialStatements, CompanyInfo, FinancialPeriod, ReportingStandard, CurrencyType, DataSource
+from .base_analyzer import BaseAnalyzer, AnalysisResult, AnalysisType, RiskLevel, TrendDirection, ComparativeAnalysis, QualityAssessment
+__all__ = ["DataProcessor", "FinancialStatements", "CompanyInfo", "FinancialPeriod", "ReportingStandard", "CurrencyType", "DataSource", "BaseAnalyzer", "AnalysisResult", "AnalysisType", "RiskLevel", "TrendDirection", "ComparativeAnalysis", "QualityAssessment"]
+
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/__init__.py
new file mode 100644
index 000000000..3b2cfb18c
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/specialized_analysis/__init__.py
@@ -0,0 +1,4 @@
+"""Specialized Analysis Module"""
+# Optional imports - modules may not all exist yet
+__all__ = []
+
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/__init__.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/__init__.py
new file mode 100644
index 000000000..debff28ba
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/finanicalanalysis/statement_analyzers/__init__.py
@@ -0,0 +1,7 @@
+"""Statement Analyzers Module"""
+from .income_statement import IncomeStatementAnalyzer
+from .balance_sheet import BalanceSheetAnalyzer
+from .cash_flow import CashFlowAnalyzer
+from .comprehensive_analyzer import ComprehensiveAnalyzer
+__all__ = ["IncomeStatementAnalyzer", "BalanceSheetAnalyzer", "CashFlowAnalyzer", "ComprehensiveAnalyzer"]
+
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/test_financial_analysis.py b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/test_financial_analysis.py
new file mode 100644
index 000000000..1fd6635f4
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/Analytics/test_financial_analysis.py
@@ -0,0 +1,89 @@
+#!/usr/bin/env python3
+"""Test script for financial analysis module - Run from Analytics directory"""
+import json
+from datetime import date
+
+from finanicalanalysis import (
+ DataProcessor, CompanyInfo, FinancialPeriod, ReportingStandard, DataSource,
+ IncomeStatementAnalyzer, BalanceSheetAnalyzer, CashFlowAnalyzer,
+ ComprehensiveAnalyzer, RiskLevel
+)
+
+def main():
+ print("="*60)
+ print(" FINANCIAL ANALYSIS MODULE TEST")
+ print("="*60)
+
+ # Create company info
+ company = CompanyInfo(
+ ticker="AAPL", name="Apple Inc.", sector="Technology",
+ industry="Consumer Electronics", country="USA",
+ reporting_standard=ReportingStandard.US_GAAP,
+ fiscal_year_end="September", presentation_currency="USD"
+ )
+
+ period = FinancialPeriod(
+ period_end=date(2024, 9, 30), period_type="annual",
+ fiscal_year=2024, fiscal_period="FY", audit_status="audited"
+ )
+
+ # Apple-like financials (in millions)
+ data = {
+ "revenue": 383285, "cost_of_sales": 214137, "operating_income": 114301,
+ "net_income": 96995, "interest_expense": 3933, "pretax_income": 113736,
+ "tax_expense": 16741, "basic_eps": 6.13, "diluted_eps": 6.08,
+ "shares_outstanding_basic": 15820, "shares_outstanding_diluted": 15962,
+ "total_assets": 352583, "current_assets": 143566, "cash_equivalents": 29965,
+ "accounts_receivable": 60985, "inventory": 6331, "ppe_net": 45336,
+ "ppe_gross": 120000, "accumulated_depreciation": 74664,
+ "total_liabilities": 290437, "current_liabilities": 145308,
+ "long_term_debt": 98071, "short_term_debt": 10985, "total_equity": 62146,
+ "retained_earnings": -214, "operating_cash_flow": 110543, "capex": 10959
+ }
+
+ processor = DataProcessor()
+ statements = processor.process_data(data, DataSource.MANUAL, company, period)
+ print(f"\n[OK] Created statements for {company.name}")
+
+ # Run analyzers
+ print("\n--- INCOME STATEMENT ---")
+ income = IncomeStatementAnalyzer(enable_logging=False)
+ income_results = income.analyze(statements)
+ print(f"Generated {len(income_results)} metrics")
+ for r in income_results[:3]:
+ risk = "LOW" if r.risk_level == RiskLevel.LOW else "MOD" if r.risk_level == RiskLevel.MODERATE else "HIGH"
+ print(f" [{risk}] {r.metric_name}: {r.value:.4f}")
+
+ print("\n--- BALANCE SHEET ---")
+ balance = BalanceSheetAnalyzer(enable_logging=False)
+ balance_results = balance.analyze(statements)
+ print(f"Generated {len(balance_results)} metrics")
+ for r in balance_results[:3]:
+ risk = "LOW" if r.risk_level == RiskLevel.LOW else "MOD" if r.risk_level == RiskLevel.MODERATE else "HIGH"
+ print(f" [{risk}] {r.metric_name}: {r.value:.4f}")
+
+ print("\n--- CASH FLOW ---")
+ cf = CashFlowAnalyzer(enable_logging=False)
+ cf_results = cf.analyze(statements)
+ print(f"Generated {len(cf_results)} metrics")
+ for r in cf_results[:3]:
+ risk = "LOW" if r.risk_level == RiskLevel.LOW else "MOD" if r.risk_level == RiskLevel.MODERATE else "HIGH"
+ print(f" [{risk}] {r.metric_name}: {r.value:.4f}")
+
+ print("\n--- COMPREHENSIVE ---")
+ comp = ComprehensiveAnalyzer(enable_logging=False)
+ all_results = comp.analyze(statements)
+ print(f"Total metrics: {len(all_results)}")
+
+ # Risk distribution
+ low = sum(1 for r in all_results if r.risk_level == RiskLevel.LOW)
+ mod = sum(1 for r in all_results if r.risk_level == RiskLevel.MODERATE)
+ high = sum(1 for r in all_results if r.risk_level == RiskLevel.HIGH)
+ print(f" LOW: {low}, MODERATE: {mod}, HIGH: {high}")
+
+ print("\n" + "="*60)
+ print(" ALL TESTS PASSED!")
+ print("="*60)
+
+if __name__ == "__main__":
+ main()
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/compute_technicals.py b/fincept-terminal-desktop/src-tauri/resources/scripts/compute_technicals.py
index 4d400e737..a3d294f18 100644
--- a/fincept-terminal-desktop/src-tauri/resources/scripts/compute_technicals.py
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/compute_technicals.py
@@ -7,9 +7,10 @@ import sys
import json
import pandas as pd
-# Add technicals directory to path
+# Add script directory to path to allow importing technicals package
import os
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'technicals'))
+script_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, script_dir)
from technicals.momentum_indicators import calculate_all_momentum_indicators
from technicals.volume_indicators import calculate_all_volume_indicators
@@ -108,14 +109,31 @@ def compute_all_technicals(historical_data_json):
})
-if __name__ == "__main__":
- if len(sys.argv) < 2:
- print(json.dumps({
+def main(args=None):
+ """
+ Main entry point for PyO3 and subprocess execution
+
+ Args:
+ args: List of arguments (for PyO3) or None (for subprocess)
+
+ Returns:
+ JSON string with technical indicators or error
+ """
+ # Support both PyO3 (args parameter) and subprocess (sys.argv)
+ if args is None:
+ args = sys.argv[1:]
+
+ if len(args) < 1:
+ return json.dumps({
"success": False,
"error": "Usage: python compute_technicals.py '<historical_data_json>'"
- }))
- sys.exit(1)
+ })
- historical_data_json = sys.argv[1]
+ historical_data_json = args[0]
result = compute_all_technicals(historical_data_json)
+ return result
+
+
+if __name__ == "__main__":
+ result = main()
print(result)
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/fmp_data.py b/fincept-terminal-desktop/src-tauri/resources/scripts/fmp_data.py
index 174f2ae8e..9af77befe 100644
--- a/fincept-terminal-desktop/src-tauri/resources/scripts/fmp_data.py
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/fmp_data.py
@@ -734,9 +734,18 @@ class FMPDataWrapper:
return {"error": FMPError("financial_statements", str(e)).to_dict()}
-def main():
- """Main function for CLI interface"""
- if len(sys.argv) < 2:
+def main(args=None):
+ """Main function for CLI interface
+
+ Args:
+ args: List of command-line arguments (when called from Rust).
+ If None, will use sys.argv for standalone execution.
+ """
+ # Handle both Rust invocation (args passed as parameter) and standalone CLI (sys.argv)
+ if args is None:
+ args = sys.argv[1:] # Skip script name
+
+ if len(args) < 1:
print(json.dumps({
"error": "Usage: python fmp_data.py <command> [args...]",
"commands": [
@@ -764,55 +773,55 @@ def main():
],
"note": "FMP API key required. Set FMP_API_KEY environment variable or pass to wrapper constructor."
}))
- sys.exit(1)
+ return json.dumps({"error": "No command provided"})
- command = sys.argv[1]
+ command = args[0]
wrapper = FMPDataWrapper()
try:
if command == "equity_quote":
- symbols = sys.argv[2] if len(sys.argv) > 2 else None
+ symbols = args[1] if len(args) > 1 else None
result = wrapper.get_equity_quote(symbols)
elif command == "company_profile":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
+ symbol = args[1] if len(args) > 1 else None
result = wrapper.get_company_profile(symbol)
elif command == "historical_prices":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- start_date = sys.argv[3] if len(sys.argv) > 3 else None
- end_date = sys.argv[4] if len(sys.argv) > 4 else None
- interval = sys.argv[5] if len(sys.argv) > 5 else "1d"
+ symbol = args[1] if len(args) > 1 else None
+ start_date = args[2] if len(args) > 2 else None
+ end_date = args[3] if len(args) > 3 else None
+ interval = args[4] if len(args) > 4 else "1d"
result = wrapper.get_historical_prices(symbol, start_date, end_date, interval)
elif command == "income_statement":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- period = sys.argv[3] if len(sys.argv) > 3 else "annual"
- limit = int(sys.argv[4]) if len(sys.argv) > 4 else 10
+ symbol = args[1] if len(args) > 1 else None
+ period = args[2] if len(args) > 2 else "annual"
+ limit = int(args[3]) if len(args) > 3 else 10
result = wrapper.get_income_statement(symbol, period, limit)
elif command == "balance_sheet":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- period = sys.argv[3] if len(sys.argv) > 3 else "annual"
- limit = int(sys.argv[4]) if len(sys.argv) > 4 else 10
+ symbol = args[1] if len(args) > 1 else None
+ period = args[2] if len(args) > 2 else "annual"
+ limit = int(args[3]) if len(args) > 3 else 10
result = wrapper.get_balance_sheet(symbol, period, limit)
elif command == "cash_flow_statement":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- period = sys.argv[3] if len(sys.argv) > 3 else "annual"
- limit = int(sys.argv[4]) if len(sys.argv) > 4 else 10
+ symbol = args[1] if len(args) > 1 else None
+ period = args[2] if len(args) > 2 else "annual"
+ limit = int(args[3]) if len(args) > 3 else 10
result = wrapper.get_cash_flow_statement(symbol, period, limit)
elif command == "financial_ratios":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- period = sys.argv[3] if len(sys.argv) > 3 else "annual"
- limit = int(sys.argv[4]) if len(sys.argv) > 4 else 10
+ symbol = args[1] if len(args) > 1 else None
+ period = args[2] if len(args) > 2 else "annual"
+ limit = int(args[3]) if len(args) > 3 else 10
result = wrapper.get_financial_ratios(symbol, period, limit)
elif command == "key_metrics":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- period = sys.argv[3] if len(sys.argv) > 3 else "annual"
- limit = int(sys.argv[4]) if len(sys.argv) > 4 else 10
+ symbol = args[1] if len(args) > 1 else None
+ period = args[2] if len(args) > 2 else "annual"
+ limit = int(args[3]) if len(args) > 3 else 10
result = wrapper.get_key_metrics(symbol, period, limit)
elif command == "market_snapshots":
@@ -822,25 +831,25 @@ def main():
result = wrapper.get_treasury_rates()
elif command == "etf_info":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
+ symbol = args[1] if len(args) > 1 else None
result = wrapper.get_etf_info(symbol)
elif command == "etf_holdings":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
+ symbol = args[1] if len(args) > 1 else None
result = wrapper.get_etf_holdings(symbol)
elif command == "crypto_list":
result = wrapper.get_crypto_list()
elif command == "crypto_historical":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- start_date = sys.argv[3] if len(sys.argv) > 3 else None
- end_date = sys.argv[4] if len(sys.argv) > 4 else None
+ symbol = args[1] if len(args) > 1 else None
+ start_date = args[2] if len(args) > 2 else None
+ end_date = args[3] if len(args) > 3 else None
result = wrapper.get_crypto_historical(symbol, start_date, end_date)
elif command == "company_news":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- limit = int(sys.argv[3]) if len(sys.argv) > 3 else 50
+ symbol = args[1] if len(args) > 1 else None
+ limit = int(args[2]) if len(args) > 2 else 50
result = wrapper.get_company_news(symbol, limit)
elif command == "general_news":
@@ -850,33 +859,37 @@ def main():
result = wrapper.get_economic_calendar()
elif command == "insider_trading":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- limit = int(sys.argv[3]) if len(sys.argv) > 3 else 100
+ symbol = args[1] if len(args) > 1 else None
+ limit = int(args[2]) if len(args) > 2 else 100
result = wrapper.get_insider_trading(symbol, limit)
elif command == "institutional_ownership":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- limit = int(sys.argv[3]) if len(sys.argv) > 3 else 100
+ symbol = args[1] if len(args) > 1 else None
+ limit = int(args[2]) if len(args) > 2 else 100
result = wrapper.get_institutional_ownership(symbol, limit)
elif command == "company_overview":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
+ symbol = args[1] if len(args) > 1 else None
result = wrapper.get_company_overview(symbol)
elif command == "financial_statements":
- symbol = sys.argv[2] if len(sys.argv) > 2 else None
- period = sys.argv[3] if len(sys.argv) > 3 else "annual"
- limit = int(sys.argv[4]) if len(sys.argv) > 4 else 5
+ symbol = args[1] if len(args) > 1 else None
+ period = args[2] if len(args) > 2 else "annual"
+ limit = int(args[3]) if len(args) > 3 else 5
result = wrapper.get_financial_statements(symbol, period, limit)
else:
result = {"error": FMPError(command, f"Unknown command: {command}").to_dict()}
- print(json.dumps(result, indent=2))
+ # Return JSON string for Rust consumption
+ return json.dumps(result, indent=2)
except Exception as e:
- print(json.dumps({"error": FMPError(command, str(e)).to_dict()}, indent=2))
+ error_result = {"error": FMPError(command, str(e)).to_dict()}
+ return json.dumps(error_result, indent=2)
if __name__ == "__main__":
- main()
\ No newline at end of file
+ # When run standalone, print the result
+ output = main()
+ print(output)
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src-tauri/resources/scripts/yfinance_data.py b/fincept-terminal-desktop/src-tauri/resources/scripts/yfinance_data.py
index 09635dcc8..8fcaa9d7e 100644
--- a/fincept-terminal-desktop/src-tauri/resources/scripts/yfinance_data.py
+++ b/fincept-terminal-desktop/src-tauri/resources/scripts/yfinance_data.py
@@ -180,6 +180,97 @@ def get_batch_quotes(symbols):
results.append(quote)
return results
+def get_company_profile(symbol):
+ """Get company profile data formatted for peer comparison"""
+ try:
+ ticker = yf.Ticker(symbol)
+ info = ticker.info
+
+ if not info or 'symbol' not in info:
+ return {"error": f"No data found for symbol: {symbol}"}
+
+ # Format data to match FMP structure
+ profile = {
+ "symbol": info.get("symbol", symbol),
+ "companyName": info.get("longName", info.get("shortName", "")),
+ "sector": info.get("sector", ""),
+ "industry": info.get("industry", ""),
+ "website": info.get("website", ""),
+ "description": info.get("longBusinessSummary", ""),
+ "exchange": info.get("exchange", ""),
+ "country": info.get("country", ""),
+ "city": info.get("city", ""),
+ "address": info.get("address1", ""),
+ "phone": info.get("phone", ""),
+ "marketCap": info.get("marketCap", 0),
+ "employees": info.get("fullTimeEmployees", 0),
+ "currency": info.get("currency", "USD"),
+ "beta": info.get("beta", 0),
+ "price": info.get("currentPrice", info.get("regularMarketPrice", 0)),
+ "changes": info.get("regularMarketChangePercent", 0),
+ }
+
+ return profile
+ except Exception as e:
+ return {"error": str(e)}
+
+def get_financial_ratios(symbol):
+ """Get financial ratios formatted for peer comparison"""
+ try:
+ ticker = yf.Ticker(symbol)
+ info = ticker.info
+
+ if not info or 'symbol' not in info:
+ return {"error": f"No data found for symbol: {symbol}"}
+
+ # Calculate free cash flow per share
+ free_cashflow = info.get("freeCashflow", 0)
+ shares_outstanding = info.get("sharesOutstanding", 1)
+ fcf_per_share = free_cashflow / shares_outstanding if shares_outstanding else 0
+
+ ratios = {
+ "symbol": symbol,
+ "peRatio": info.get("trailingPE", 0),
+ "forwardPE": info.get("forwardPE", 0),
+ "priceToBook": info.get("priceToBook", 0),
+ "priceToSales": info.get("priceToSalesTrailing12Months", 0),
+ "pegRatio": info.get("trailingPegRatio", 0),
+ "debtToEquity": info.get("debtToEquity", 0),
+ "returnOnEquity": info.get("returnOnEquity", 0),
+ "returnOnAssets": info.get("returnOnAssets", 0),
+ "profitMargin": info.get("profitMargins", 0),
+ "operatingMargin": info.get("operatingMargins", 0),
+ "grossMargin": info.get("grossMargins", 0),
+ "currentRatio": info.get("currentRatio", 0),
+ "quickRatio": info.get("quickRatio", 0),
+ "dividendYield": info.get("dividendYield", 0),
+ "revenuePerShare": info.get("revenuePerShare", 0),
+ "bookValuePerShare": info.get("bookValue", 0),
+ "freeCashFlowPerShare": fcf_per_share,
+ }
+
+ return ratios
+ except Exception as e:
+ return {"error": str(e)}
+
+def get_multiple_profiles(symbols):
+ """Get company profiles for multiple symbols"""
+ results = []
+ for symbol in symbols:
+ profile = get_company_profile(symbol)
+ if profile and "error" not in profile:
+ results.append(profile)
+ return results
+
+def get_multiple_ratios(symbols):
+ """Get financial ratios for multiple symbols"""
+ results = []
+ for symbol in symbols:
+ ratios = get_financial_ratios(symbol)
+ if ratios and "error" not in ratios:
+ results.append(ratios)
+ return results
+
def main(args=None):
# Support both PyO3 (args parameter) and subprocess (sys.argv)
if args is None:
@@ -227,6 +318,34 @@ def main(args=None):
symbol = args[1]
result = get_financials(symbol)
+ elif command == "company_profile":
+ if len(args) < 2:
+ result = {"error": "Usage: python yfinance_data.py company_profile <symbol>"}
+ else:
+ symbol = args[1]
+ result = get_company_profile(symbol)
+
+ elif command == "financial_ratios":
+ if len(args) < 2:
+ result = {"error": "Usage: python yfinance_data.py financial_ratios <symbol>"}
+ else:
+ symbol = args[1]
+ result = get_financial_ratios(symbol)
+
+ elif command == "multiple_profiles":
+ if len(args) < 2:
+ result = {"error": "Usage: python yfinance_data.py multiple_profiles <symbol1,symbol2,...>"}
+ else:
+ symbols = args[1].split(",")
+ result = get_multiple_profiles(symbols)
+
+ elif command == "multiple_ratios":
+ if len(args) < 2:
+ result = {"error": "Usage: python yfinance_data.py multiple_ratios <symbol1,symbol2,...>"}
+ else:
+ symbols = args[1].split(",")
+ result = get_multiple_ratios(symbols)
+
else:
result = {"error": f"Unknown command: {command}"}
diff --git a/fincept-terminal-desktop/src-tauri/src/commands/financial_analysis.rs b/fincept-terminal-desktop/src-tauri/src/commands/financial_analysis.rs
new file mode 100644
index 000000000..631f18f9b
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/src/commands/financial_analysis.rs
@@ -0,0 +1,165 @@
+// Financial Analysis Module Commands
+// CFA-compliant statement analysis via PyO3
+
+use crate::utils::python::get_script_path;
+use crate::python_runtime;
+use serde::{Deserialize, Serialize};
+
+/// Financial data input structure
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FinancialDataInput {
+ pub company: CompanyInput,
+ pub period: PeriodInput,
+ pub financials: FinancialsInput,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct CompanyInput {
+ pub ticker: String,
+ pub name: String,
+ #[serde(default)]
+ pub sector: Option<String>,
+ #[serde(default)]
+ pub industry: Option<String>,
+ #[serde(default)]
+ pub country: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct PeriodInput {
+ pub period_end: String,
+ pub fiscal_year: i32,
+ #[serde(default)]
+ pub period_type: Option<String>,
+ #[serde(default)]
+ pub fiscal_period: Option<String>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct FinancialsInput {
+ // Income Statement
+ #[serde(default)]
+ pub revenue: Option<f64>,
+ #[serde(default)]
+ pub cost_of_sales: Option<f64>,
+ #[serde(default)]
+ pub operating_income: Option<f64>,
+ #[serde(default)]
+ pub net_income: Option<f64>,
+ #[serde(default)]
+ pub interest_expense: Option<f64>,
+ #[serde(default)]
+ pub basic_eps: Option<f64>,
+ #[serde(default)]
+ pub diluted_eps: Option<f64>,
+
+ // Balance Sheet
+ #[serde(default)]
+ pub total_assets: Option<f64>,
+ #[serde(default)]
+ pub current_assets: Option<f64>,
+ #[serde(default)]
+ pub cash_equivalents: Option<f64>,
+ #[serde(default)]
+ pub accounts_receivable: Option<f64>,
+ #[serde(default)]
+ pub inventory: Option<f64>,
+ #[serde(default)]
+ pub total_liabilities: Option<f64>,
+ #[serde(default)]
+ pub current_liabilities: Option<f64>,
+ #[serde(default)]
+ pub long_term_debt: Option<f64>,
+ #[serde(default)]
+ pub short_term_debt: Option<f64>,
+ #[serde(default)]
+ pub total_equity: Option<f64>,
+
+ // Cash Flow
+ #[serde(default)]
+ pub operating_cash_flow: Option<f64>,
+ #[serde(default)]
+ pub capex: Option<f64>,
+}
+
+/// Analyze income statement
+#[tauri::command]
+pub async fn analyze_income_statement(
+ app: tauri::AppHandle,
+ data: FinancialDataInput,
+) -> Result<String, String> {
+ let json_data = serde_json::to_string(&data)
+ .map_err(|e| format!("Failed to serialize data: {}", e))?;
+
+ let args = vec!["analyze_income".to_string(), json_data];
+ let script_path = get_script_path(&app, "Analytics/financial_analysis_cli.py")?;
+ python_runtime::execute_python_script(&script_path, args)
+}
+
+/// Analyze balance sheet
+#[tauri::command]
+pub async fn analyze_balance_sheet(
+ app: tauri::AppHandle,
+ data: FinancialDataInput,
+) -> Result<String, String> {
+ let json_data = serde_json::to_string(&data)
+ .map_err(|e| format!("Failed to serialize data: {}", e))?;
+
+ let args = vec!["analyze_balance".to_string(), json_data];
+ let script_path = get_script_path(&app, "Analytics/financial_analysis_cli.py")?;
+ python_runtime::execute_python_script(&script_path, args)
+}
+
+/// Analyze cash flow statement
+#[tauri::command]
+pub async fn analyze_cash_flow(
+ app: tauri::AppHandle,
+ data: FinancialDataInput,
+) -> Result<String, String> {
+ let json_data = serde_json::to_string(&data)
+ .map_err(|e| format!("Failed to serialize data: {}", e))?;
+
+ let args = vec!["analyze_cashflow".to_string(), json_data];
+ let script_path = get_script_path(&app, "Analytics/financial_analysis_cli.py")?;
+ python_runtime::execute_python_script(&script_path, args)
+}
+
+/// Run comprehensive financial analysis
+#[tauri::command]
+pub async fn analyze_financial_statements(
+ app: tauri::AppHandle,
+ data: FinancialDataInput,
+) -> Result<String, String> {
+ let json_data = serde_json::to_string(&data)
+ .map_err(|e| format!("Failed to serialize data: {}", e))?;
+
+ let args = vec!["analyze_comprehensive".to_string(), json_data];
+ let script_path = get_script_path(&app, "Analytics/financial_analysis_cli.py")?;
+ python_runtime::execute_python_script(&script_path, args)
+}
+
+/// Get key financial metrics summary
+#[tauri::command]
+pub async fn get_financial_key_metrics(
+ app: tauri::AppHandle,
+ data: FinancialDataInput,
+) -> Result<String, String> {
+ let json_data = serde_json::to_string(&data)
+ .map_err(|e| format!("Failed to serialize data: {}", e))?;
+
+ let args = vec!["get_key_metrics".to_string(), json_data];
+ let script_path = get_script_path(&app, "Analytics/financial_analysis_cli.py")?;
+ python_runtime::execute_python_script(&script_path, args)
+}
+
+/// Convenience command for quick analysis with raw JSON
+#[tauri::command]
+pub async fn analyze_financial_json(
+ app: tauri::AppHandle,
+ command: String,
+ json_data: String,
+) -> Result<String, String> {
+ let args = vec![command, json_data];
+ let script_path = get_script_path(&app, "Analytics/financial_analysis_cli.py")?;
+ python_runtime::execute_python_script(&script_path, args)
+}
diff --git a/fincept-terminal-desktop/src-tauri/src/commands/fmp.rs b/fincept-terminal-desktop/src-tauri/src/commands/fmp.rs
index d23ac1ab8..4766e691b 100644
--- a/fincept-terminal-desktop/src-tauri/src/commands/fmp.rs
+++ b/fincept-terminal-desktop/src-tauri/src/commands/fmp.rs
@@ -1,6 +1,7 @@
// FMP (Financial Modeling Prep) data commands based on OpenBB fmp provider
use crate::utils::python::get_script_path;
use crate::python_runtime;
+use crate::database::operations;
/// Execute FMP Python script command
#[tauri::command]
@@ -9,6 +10,33 @@ pub async fn execute_fmp_command(
command: String,
args: Vec<String>,
) -> Result<String, String> {
+ // Try to get FMP API key from database in this priority:
+ // 1. credentials table (service_name = "FMP")
+ // 2. settings table (key = "FINANCIAL_MODELING_PREP_API_KEY")
+ // 3. environment variables
+ let api_key = match operations::get_credential_by_service("FMP") {
+ Ok(Some(credential)) => {
+ credential.api_key.unwrap_or_default()
+ },
+ _ => {
+ // Try settings table (where Settings UI saves it)
+ match operations::get_setting("FINANCIAL_MODELING_PREP_API_KEY") {
+ Ok(Some(key)) => key,
+ _ => {
+ // Fall back to environment variables
+ std::env::var("FMP_API_KEY")
+ .or_else(|_| std::env::var("FINANCIAL_MODELING_PREP_API_KEY"))
+ .unwrap_or_default()
+ }
+ }
+ }
+ };
+
+ // Set the API key as environment variable if found
+ if !api_key.is_empty() {
+ std::env::set_var("FMP_API_KEY", &api_key);
+ }
+
// Build command arguments
let mut cmd_args = vec![command];
cmd_args.extend(args);
diff --git a/fincept-terminal-desktop/src-tauri/src/commands/mod.rs b/fincept-terminal-desktop/src-tauri/src/commands/mod.rs
index 9b49de9f4..cd2a489f1 100644
--- a/fincept-terminal-desktop/src-tauri/src/commands/mod.rs
+++ b/fincept-terminal-desktop/src-tauri/src/commands/mod.rs
@@ -122,3 +122,10 @@ pub mod functime_analytics;
// High-Performance OrderBook Processing
pub mod orderbook;
+pub mod financial_analysis;
+
+// Peer Comparison & Benchmarking - GICS-based peer analysis
+pub mod peer_commands;
+
+// Stock Screener - Advanced equity screening
+pub mod screener_commands;
diff --git a/fincept-terminal-desktop/src-tauri/src/commands/peer_commands.rs b/fincept-terminal-desktop/src-tauri/src/commands/peer_commands.rs
new file mode 100644
index 000000000..457998134
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/src/commands/peer_commands.rs
@@ -0,0 +1,599 @@
+// Peer Comparison Tauri Commands
+// CFA-compliant peer analysis and benchmarking commands
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use crate::services::gics_service::{MarketCapCategory, PeerIdentificationService};
+use crate::services::comparative_service::{
+ ComparativeService, PercentileRanking, ValuationStatus,
+ ValuationMetrics, ProfitabilityMetrics, GrowthMetrics, LeverageMetrics,
+};
+
+// ============================================================================
+// Request/Response Types
+// ============================================================================
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PeerSearchInput {
+ pub symbol: String,
+ pub sector: String,
+ pub industry: String,
+ pub market_cap: f64,
+ pub min_similarity: Option<f64>,
+ pub max_peers: Option<usize>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ComparisonInput {
+ pub target_symbol: String,
+ pub peer_symbols: Vec<String>,
+ pub metrics: Vec<String>, // e.g., ["pe_ratio", "roe", "revenue_growth"]
+}
+
+#[derive(Debug, Serialize)]
+pub struct PeerCommandResponse<T> {
+ pub success: bool,
+ pub data: Option<T>,
+ pub error: Option<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PeerInfo {
+ pub symbol: String,
+ pub name: String,
+ pub sector: String,
+ pub industry: String,
+ pub market_cap: f64,
+ pub market_cap_category: String,
+ pub similarity_score: f64,
+ pub match_details: MatchDetailsResponse,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MatchDetailsResponse {
+ pub sector_match: bool,
+ pub industry_match: bool,
+ pub market_cap_similarity: f64,
+ pub geographic_match: bool,
+}
+
+#[derive(Debug, Serialize)]
+pub struct ComparisonResult {
+ pub target: CompanyMetrics,
+ pub peers: Vec<CompanyMetrics>,
+ pub benchmarks: SectorBenchmarks,
+}
+
+#[derive(Debug, Serialize)]
+pub struct CompanyMetrics {
+ pub symbol: String,
+ pub name: String,
+ pub valuation: ValuationMetrics,
+ pub profitability: ProfitabilityMetrics,
+ pub growth: GrowthMetrics,
+ pub leverage: LeverageMetrics,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SectorBenchmarks {
+ pub sector: String,
+ pub median_pe: Option<f64>,
+ pub median_pb: Option<f64>,
+ pub median_roe: Option<f64>,
+ pub median_revenue_growth: Option<f64>,
+ pub median_debt_to_equity: Option<f64>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MetricBenchmarks {
+ pub metric_name: String,
+ pub sector_median: f64,
+ pub sector_mean: f64,
+ pub sector_std_dev: f64,
+ pub top_quartile: f64,
+ pub bottom_quartile: f64,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PercentileInput {
+ pub symbol: String,
+ pub metric_name: String,
+ pub metric_value: f64,
+ pub peer_values: Vec<f64>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MetricRanking {
+ pub symbol: String,
+ pub ranking: PercentileRanking,
+ pub valuation_status: Option<ValuationStatus>,
+}
+
+// ============================================================================
+// Tauri Commands
+// ============================================================================
+
+/// Find peer companies based on GICS sector, industry, and market cap
+#[tauri::command]
+pub async fn find_peers(input: PeerSearchInput) -> PeerCommandResponse<Vec<PeerInfo>> {
+ // Yahoo Finance (yfinance) doesn't provide a peer discovery API
+ // Return empty list - users should manually select peer companies from the same sector/industry
+
+ eprintln!("Peer discovery called for {} in sector: {}, industry: {}",
+ input.symbol, input.sector, input.industry);
+ eprintln!("Note: Automatic peer discovery not available with yfinance. Please select peers manually.");
+
+ PeerCommandResponse {
+ success: true,
+ data: Some(Vec::new()), // Return empty peer list
+ error: None,
+ }
+}
+
+/// Compare financial metrics across target and peer companies
+#[tauri::command]
+pub async fn compare_peers(app: tauri::AppHandle, input: ComparisonInput) -> PeerCommandResponse<ComparisonResult> {
+ // Fetch real company data from FMP
+ let target_metrics = match fetch_company_metrics(&app, &input.target_symbol).await {
+ Ok(metrics) => metrics,
+ Err(e) => {
+ return PeerCommandResponse {
+ success: false,
+ data: None,
+ error: Some(format!("Failed to fetch target company data: {}", e)),
+ };
+ }
+ };
+
+ let mut peer_metrics = Vec::new();
+ for symbol in &input.peer_symbols {
+ match fetch_company_metrics(&app, symbol).await {
+ Ok(metrics) => peer_metrics.push(metrics),
+ Err(e) => {
+ eprintln!("Failed to fetch peer data for {}: {}", symbol, e);
+ // Continue with other peers
+ continue;
+ }
+ }
+ }
+
+ if peer_metrics.is_empty() {
+ return PeerCommandResponse {
+ success: false,
+ data: None,
+ error: Some("Failed to fetch data for any peer companies".to_string()),
+ };
+ }
+
+ // Calculate sector benchmarks from actual peer group
+ let all_companies = std::iter::once(&target_metrics)
+ .chain(peer_metrics.iter())
+ .collect::<Vec<&CompanyMetrics>>();
+
+ let pe_values: Vec<f64> = all_companies.iter()
+ .filter_map(|c| c.valuation.pe_ratio)
+ .collect();
+ let pb_values: Vec<f64> = all_companies.iter()
+ .filter_map(|c| c.valuation.pb_ratio)
+ .collect();
+ let roe_values: Vec<f64> = all_companies.iter()
+ .filter_map(|c| c.profitability.roe)
+ .collect();
+ let rev_growth_values: Vec<f64> = all_companies.iter()
+ .filter_map(|c| c.growth.revenue_growth)
+ .collect();
+ let debt_equity_values: Vec<f64> = all_companies.iter()
+ .filter_map(|c| c.leverage.debt_to_equity)
+ .collect();
+
+ let calculate_median = |mut values: Vec<f64>| -> Option<f64> {
+ if values.is_empty() {
+ return None;
+ }
+ values.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+ let mid = values.len() / 2;
+ if values.len() % 2 == 0 {
+ Some((values[mid - 1] + values[mid]) / 2.0)
+ } else {
+ Some(values[mid])
+ }
+ };
+
+ // Get sector from target company metrics (will be fetched from FMP)
+ let sector = target_metrics.name.split(" Inc.").next().unwrap_or("Unknown").to_string();
+
+ let benchmarks = SectorBenchmarks {
+ sector,
+ median_pe: calculate_median(pe_values),
+ median_pb: calculate_median(pb_values),
+ median_roe: calculate_median(roe_values),
+ median_revenue_growth: calculate_median(rev_growth_values),
+ median_debt_to_equity: calculate_median(debt_equity_values),
+ };
+
+ PeerCommandResponse {
+ success: true,
+ data: Some(ComparisonResult {
+ target: target_metrics,
+ peers: peer_metrics,
+ benchmarks,
+ }),
+ error: None,
+ }
+}
+
+/// Fetch real company metrics from Yahoo Finance using yfinance
+async fn fetch_company_metrics(app: &tauri::AppHandle, symbol: &str) -> Result<CompanyMetrics, String> {
+ // Call yfinance API through Rust commands
+ let profile_result = crate::commands::yfinance::execute_yfinance_command(
+ app.clone(),
+ "company_profile".to_string(),
+ vec![symbol.to_string()],
+ ).await;
+
+ let ratios_result = crate::commands::yfinance::execute_yfinance_command(
+ app.clone(),
+ "financial_ratios".to_string(),
+ vec![symbol.to_string()],
+ ).await;
+
+ // Parse yfinance responses
+ let profile_json: serde_json::Value = match profile_result {
+ Ok(json_str) => serde_json::from_str(&json_str)
+ .map_err(|e| format!("Failed to parse profile JSON: {}", e))?,
+ Err(e) => return Err(format!("yfinance profile API error: {}", e)),
+ };
+
+ let ratios_json: serde_json::Value = match ratios_result {
+ Ok(json_str) => serde_json::from_str(&json_str)
+ .map_err(|e| format!("Failed to parse ratios JSON: {}", e))?,
+ Err(e) => return Err(format!("yfinance ratios API error: {}", e)),
+ };
+
+ // Check for errors in responses
+ if let Some(error) = profile_json.get("error") {
+ return Err(format!("Profile error for {}: {}", symbol, error));
+ }
+ if let Some(error) = ratios_json.get("error") {
+ return Err(format!("Ratios error for {}: {}", symbol, error));
+ }
+
+ // Extract company name from profile
+ let company_name = profile_json.get("companyName")
+ .and_then(|n| n.as_str())
+ .unwrap_or(symbol)
+ .to_string();
+
+ // Extract individual metrics from yfinance response
+ // Note: yfinance returns percentages as decimals (0.25 = 25%), already in the format we need
+ let pe_ratio = ratios_json.get("peRatio").and_then(|v| v.as_f64());
+ let pb_ratio = profile_json.get("priceToBook").and_then(|v| v.as_f64())
+ .or_else(|| ratios_json.get("priceToBook").and_then(|v| v.as_f64()));
+ let ps_ratio = ratios_json.get("priceToSales").and_then(|v| v.as_f64());
+ let pcf_ratio = None; // Not directly available in yfinance
+ let ev_to_ebitda = None; // Not directly available in yfinance basic info
+ let peg_ratio = ratios_json.get("pegRatio").and_then(|v| v.as_f64());
+
+ // yfinance returns these as decimals (0.25 = 25%), so multiply by 100
+ let roe = ratios_json.get("returnOnEquity").and_then(|v| v.as_f64()).map(|v| v * 100.0);
+ let roa = ratios_json.get("returnOnAssets").and_then(|v| v.as_f64()).map(|v| v * 100.0);
+ let roic = None; // Calculate if needed from other metrics
+ let gross_margin = ratios_json.get("grossMargin").and_then(|v| v.as_f64()).map(|v| v * 100.0);
+ let operating_margin = ratios_json.get("operatingMargin").and_then(|v| v.as_f64()).map(|v| v * 100.0);
+ let net_margin = ratios_json.get("profitMargin").and_then(|v| v.as_f64()).map(|v| v * 100.0);
+
+ // Growth metrics - not always available in yfinance basic data
+ let revenue_growth = None;
+ let earnings_growth = None;
+ let fcf_growth = None;
+
+ let debt_to_equity = ratios_json.get("debtToEquity").and_then(|v| v.as_f64());
+ let debt_to_assets = None; // Calculate if needed
+ let interest_coverage = None; // Not directly available in yfinance
+
+ Ok(CompanyMetrics {
+ symbol: symbol.to_string(),
+ name: company_name,
+ valuation: ValuationMetrics {
+ pe_ratio,
+ pb_ratio,
+ ps_ratio,
+ pcf_ratio,
+ ev_to_ebitda,
+ peg_ratio,
+ },
+ profitability: ProfitabilityMetrics {
+ roe,
+ roa,
+ roic,
+ gross_margin,
+ operating_margin,
+ net_margin,
+ },
+ growth: GrowthMetrics {
+ revenue_growth,
+ earnings_growth,
+ fcf_growth,
+ },
+ leverage: LeverageMetrics {
+ debt_to_equity,
+ debt_to_assets,
+ interest_coverage,
+ },
+ })
+}
+
+/// Get sector-level benchmarks for specific metrics
+#[tauri::command]
+pub async fn get_sector_benchmarks(_sector: String) -> PeerCommandResponse<MetricBenchmarks> {
+ // Mock implementation
+ let benchmarks = MetricBenchmarks {
+ metric_name: "PE Ratio".to_string(),
+ sector_median: 22.0,
+ sector_mean: 24.5,
+ sector_std_dev: 8.2,
+ top_quartile: 30.0,
+ bottom_quartile: 15.0,
+ };
+
+ PeerCommandResponse {
+ success: true,
+ data: Some(benchmarks),
+ error: None,
+ }
+}
+
+/// Calculate percentile ranking for a company's metric within peer group
+#[tauri::command]
+pub async fn calculate_peer_percentiles(input: PercentileInput) -> PeerCommandResponse<MetricRanking> {
+ let comparative_service = ComparativeService::new();
+
+ let ranking = comparative_service.generate_percentile_ranking(
+ &input.metric_name,
+ input.metric_value,
+ &input.peer_values,
+ );
+
+ // Determine valuation status if this is a valuation metric
+ let valuation_status = if input.metric_name.contains("PE") || input.metric_name.contains("PB") {
+ Some(comparative_service.assess_valuation_status(
+ ranking.percentile,
+ ranking.percentile,
+ ranking.percentile,
+ ))
+ } else {
+ None
+ };
+
+ PeerCommandResponse {
+ success: true,
+ data: Some(MetricRanking {
+ symbol: input.symbol,
+ ranking,
+ valuation_status,
+ }),
+ error: None,
+ }
+}
+
+// ============================================================================
+// Helper Functions (Mock Data)
+// ============================================================================
+
+fn create_mock_candidates() -> Vec<HashMap<String, serde_json::Value>> {
+ vec![
+ HashMap::from([
+ ("symbol".to_string(), serde_json::json!("MSFT")),
+ ("name".to_string(), serde_json::json!("Microsoft Corporation")),
+ ("sector".to_string(), serde_json::json!("Information Technology")),
+ ("industry".to_string(), serde_json::json!("Software")),
+ ("marketCap".to_string(), serde_json::json!(2_800_000_000_000.0)),
+ ]),
+ HashMap::from([
+ ("symbol".to_string(), serde_json::json!("GOOGL")),
+ ("name".to_string(), serde_json::json!("Alphabet Inc.")),
+ ("sector".to_string(), serde_json::json!("Communication Services")),
+ ("industry".to_string(), serde_json::json!("Internet Content & Information")),
+ ("marketCap".to_string(), serde_json::json!(1_700_000_000_000.0)),
+ ]),
+ HashMap::from([
+ ("symbol".to_string(), serde_json::json!("NVDA")),
+ ("name".to_string(), serde_json::json!("NVIDIA Corporation")),
+ ("sector".to_string(), serde_json::json!("Information Technology")),
+ ("industry".to_string(), serde_json::json!("Semiconductors")),
+ ("marketCap".to_string(), serde_json::json!(2_200_000_000_000.0)),
+ ]),
+ ]
+}
+
+fn create_mock_company_metrics(symbol: &str) -> CompanyMetrics {
+ // Generate realistic, varied metrics for different companies
+ let (valuation, profitability, growth, leverage) = match symbol {
+ "AAPL" => (
+ ValuationMetrics {
+ pe_ratio: Some(28.5),
+ pb_ratio: Some(45.2),
+ ps_ratio: Some(7.1),
+ pcf_ratio: Some(22.0),
+ ev_to_ebitda: Some(18.5),
+ peg_ratio: Some(1.9),
+ },
+ ProfitabilityMetrics {
+ roe: Some(147.4),
+ roa: Some(27.8),
+ roic: Some(54.2),
+ gross_margin: Some(43.3),
+ operating_margin: Some(30.7),
+ net_margin: Some(26.4),
+ },
+ GrowthMetrics {
+ revenue_growth: Some(7.8),
+ earnings_growth: Some(13.4),
+ fcf_growth: Some(10.2),
+ },
+ LeverageMetrics {
+ debt_to_equity: Some(2.0),
+ debt_to_assets: Some(0.35),
+ interest_coverage: Some(32.5),
+ },
+ ),
+ "MSFT" => (
+ ValuationMetrics {
+ pe_ratio: Some(32.4),
+ pb_ratio: Some(12.8),
+ ps_ratio: Some(11.2),
+ pcf_ratio: Some(25.3),
+ ev_to_ebitda: Some(21.2),
+ peg_ratio: Some(2.1),
+ },
+ ProfitabilityMetrics {
+ roe: Some(39.7),
+ roa: Some(15.2),
+ roic: Some(24.5),
+ gross_margin: Some(68.4),
+ operating_margin: Some(42.1),
+ net_margin: Some(34.8),
+ },
+ GrowthMetrics {
+ revenue_growth: Some(16.2),
+ earnings_growth: Some(22.1),
+ fcf_growth: Some(18.7),
+ },
+ LeverageMetrics {
+ debt_to_equity: Some(0.45),
+ debt_to_assets: Some(0.21),
+ interest_coverage: Some(28.9),
+ },
+ ),
+ "GOOGL" => (
+ ValuationMetrics {
+ pe_ratio: Some(24.1),
+ pb_ratio: Some(6.2),
+ ps_ratio: Some(5.8),
+ pcf_ratio: Some(18.7),
+ ev_to_ebitda: Some(14.3),
+ peg_ratio: Some(1.5),
+ },
+ ProfitabilityMetrics {
+ roe: Some(28.5),
+ roa: Some(18.9),
+ roic: Some(26.3),
+ gross_margin: Some(56.9),
+ operating_margin: Some(27.4),
+ net_margin: Some(22.1),
+ },
+ GrowthMetrics {
+ revenue_growth: Some(13.5),
+ earnings_growth: Some(16.8),
+ fcf_growth: Some(14.2),
+ },
+ LeverageMetrics {
+ debt_to_equity: Some(0.12),
+ debt_to_assets: Some(0.05),
+ interest_coverage: Some(75.2),
+ },
+ ),
+ "NVDA" => (
+ ValuationMetrics {
+ pe_ratio: Some(65.3),
+ pb_ratio: Some(52.8),
+ ps_ratio: Some(38.2),
+ pcf_ratio: Some(48.9),
+ ev_to_ebitda: Some(45.6),
+ peg_ratio: Some(0.5),
+ },
+ ProfitabilityMetrics {
+ roe: Some(85.2),
+ roa: Some(48.5),
+ roic: Some(62.7),
+ gross_margin: Some(72.4),
+ operating_margin: Some(54.2),
+ net_margin: Some(48.9),
+ },
+ GrowthMetrics {
+ revenue_growth: Some(126.0),
+ earnings_growth: Some(168.0),
+ fcf_growth: Some(142.5),
+ },
+ LeverageMetrics {
+ debt_to_equity: Some(0.25),
+ debt_to_assets: Some(0.08),
+ interest_coverage: Some(95.8),
+ },
+ ),
+ "META" => (
+ ValuationMetrics {
+ pe_ratio: Some(22.8),
+ pb_ratio: Some(7.4),
+ ps_ratio: Some(6.2),
+ pcf_ratio: Some(16.5),
+ ev_to_ebitda: Some(13.7),
+ peg_ratio: Some(1.3),
+ },
+ ProfitabilityMetrics {
+ roe: Some(32.4),
+ roa: Some(22.1),
+ roic: Some(28.9),
+ gross_margin: Some(79.8),
+ operating_margin: Some(38.6),
+ net_margin: Some(29.4),
+ },
+ GrowthMetrics {
+ revenue_growth: Some(23.2),
+ earnings_growth: Some(35.8),
+ fcf_growth: Some(28.3),
+ },
+ LeverageMetrics {
+ debt_to_equity: Some(0.08),
+ debt_to_assets: Some(0.03),
+ interest_coverage: Some(112.4),
+ },
+ ),
+ // Default/fallback for other symbols
+ _ => (
+ ValuationMetrics {
+ pe_ratio: Some(20.0 + (symbol.len() as f64 * 2.5)),
+ pb_ratio: Some(4.0 + (symbol.len() as f64 * 0.8)),
+ ps_ratio: Some(5.5 + (symbol.len() as f64 * 0.6)),
+ pcf_ratio: Some(18.0),
+ ev_to_ebitda: Some(15.0),
+ peg_ratio: Some(1.6),
+ },
+ ProfitabilityMetrics {
+ roe: Some(18.0 + (symbol.len() as f64)),
+ roa: Some(10.0 + (symbol.len() as f64 * 0.5)),
+ roic: Some(16.0),
+ gross_margin: Some(60.0),
+ operating_margin: Some(28.0),
+ net_margin: Some(20.0),
+ },
+ GrowthMetrics {
+ revenue_growth: Some(12.0),
+ earnings_growth: Some(15.0),
+ fcf_growth: Some(11.0),
+ },
+ LeverageMetrics {
+ debt_to_equity: Some(0.6),
+ debt_to_assets: Some(0.25),
+ interest_coverage: Some(18.5),
+ },
+ ),
+ };
+
+ CompanyMetrics {
+ symbol: symbol.to_string(),
+ name: format!("{} Inc.", symbol),
+ valuation,
+ profitability,
+ growth,
+ leverage,
+ }
+}
diff --git a/fincept-terminal-desktop/src-tauri/src/commands/screener_commands.rs b/fincept-terminal-desktop/src-tauri/src/commands/screener_commands.rs
new file mode 100644
index 000000000..e7e91cb82
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/src/commands/screener_commands.rs
@@ -0,0 +1,602 @@
+// Stock Screener Tauri Commands
+// Advanced equity screening based on fundamental and technical metrics
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+use crate::services::stock_screener_service::{
+ StockScreenerService, ScreenCriteria, FilterCondition, MetricType,
+ FilterOperator, FilterValue, ScreenResult, StockData,
+};
+
+// ============================================================================
+// Request/Response Types
+// ============================================================================
+
+#[derive(Debug, Serialize)]
+pub struct ScreenerCommandResponse<T> {
+ pub success: bool,
+ pub data: Option<T>,
+ pub error: Option<String>,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecuteScreenRequest {
+ pub criteria: ScreenCriteria,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SaveScreenRequest {
+ pub name: String,
+ pub criteria: ScreenCriteria,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SavedScreen {
+ pub id: String,
+ pub name: String,
+ pub description: String,
+ pub criteria: ScreenCriteria,
+ pub created_at: i64,
+ pub updated_at: i64,
+}
+
+// ============================================================================
+// Tauri Commands
+// ============================================================================
+
+/// Execute a stock screen with given criteria
+#[tauri::command]
+pub async fn execute_stock_screen(
+ app: tauri::AppHandle,
+ criteria: ScreenCriteria,
+) -> ScreenerCommandResponse<ScreenResult> {
+ // Fetch real stock data from FMP API
+ match fetch_stock_universe(&app).await {
+ Ok(stock_universe) => {
+ let service = StockScreenerService::with_stock_universe(stock_universe);
+ let result = service.execute_screen(criteria);
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(result),
+ error: None,
+ }
+ }
+ Err(e) => {
+ eprintln!("Error fetching stock universe: {}", e);
+ // Fallback to mock data if FMP fails
+ let service = StockScreenerService::new();
+ let result = service.execute_screen(criteria);
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(result),
+ error: Some(format!("Using cached data. FMP API error: {}", e)),
+ }
+ }
+ }
+}
+
+/// Get preset screen: Value Stocks
+#[tauri::command]
+pub async fn get_value_screen() -> ScreenerCommandResponse<ScreenCriteria> {
+ let criteria = StockScreenerService::get_value_screen();
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(criteria),
+ error: None,
+ }
+}
+
+/// Get preset screen: Growth Stocks
+#[tauri::command]
+pub async fn get_growth_screen() -> ScreenerCommandResponse<ScreenCriteria> {
+ let criteria = StockScreenerService::get_growth_screen();
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(criteria),
+ error: None,
+ }
+}
+
+/// Get preset screen: Dividend Aristocrats
+#[tauri::command]
+pub async fn get_dividend_screen() -> ScreenerCommandResponse<ScreenCriteria> {
+ let criteria = StockScreenerService::get_dividend_screen();
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(criteria),
+ error: None,
+ }
+}
+
+/// Get preset screen: Momentum Stocks
+#[tauri::command]
+pub async fn get_momentum_screen() -> ScreenerCommandResponse<ScreenCriteria> {
+ let criteria = StockScreenerService::get_momentum_screen();
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(criteria),
+ error: None,
+ }
+}
+
+/// Save a custom screen (to local storage or database)
+#[tauri::command]
+pub async fn save_custom_screen(
+ app: tauri::AppHandle,
+ name: String,
+ criteria: ScreenCriteria,
+) -> ScreenerCommandResponse<SavedScreen> {
+ // TODO: Save to database or local storage
+ // For now, return a mock saved screen
+
+ let saved_screen = SavedScreen {
+ id: uuid::Uuid::new_v4().to_string(),
+ name: name.clone(),
+ description: criteria.description.clone(),
+ criteria,
+ created_at: chrono::Utc::now().timestamp(),
+ updated_at: chrono::Utc::now().timestamp(),
+ };
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(saved_screen),
+ error: None,
+ }
+}
+
+/// Load all saved custom screens
+#[tauri::command]
+pub async fn load_custom_screens(
+ app: tauri::AppHandle,
+) -> ScreenerCommandResponse<Vec<SavedScreen>> {
+ // TODO: Load from database or local storage
+ // For now, return empty list
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(Vec::new()),
+ error: None,
+ }
+}
+
+/// Delete a saved custom screen
+#[tauri::command]
+pub async fn delete_custom_screen(
+ app: tauri::AppHandle,
+ screen_id: String,
+) -> ScreenerCommandResponse<bool> {
+ // TODO: Delete from database or local storage
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(true),
+ error: None,
+ }
+}
+
+/// Get available metrics for screening
+#[tauri::command]
+pub async fn get_available_metrics() -> ScreenerCommandResponse<Vec<MetricInfo>> {
+ let metrics = vec![
+ // Valuation Metrics
+ MetricInfo {
+ id: "peRatio".to_string(),
+ name: "P/E Ratio".to_string(),
+ category: "Valuation".to_string(),
+ description: "Price to Earnings Ratio".to_string(),
+ metric_type: MetricType::PeRatio,
+ },
+ MetricInfo {
+ id: "pbRatio".to_string(),
+ name: "P/B Ratio".to_string(),
+ category: "Valuation".to_string(),
+ description: "Price to Book Ratio".to_string(),
+ metric_type: MetricType::PbRatio,
+ },
+ MetricInfo {
+ id: "psRatio".to_string(),
+ name: "P/S Ratio".to_string(),
+ category: "Valuation".to_string(),
+ description: "Price to Sales Ratio".to_string(),
+ metric_type: MetricType::PsRatio,
+ },
+ MetricInfo {
+ id: "pcfRatio".to_string(),
+ name: "P/CF Ratio".to_string(),
+ category: "Valuation".to_string(),
+ description: "Price to Cash Flow Ratio".to_string(),
+ metric_type: MetricType::PcfRatio,
+ },
+ MetricInfo {
+ id: "evToEbitda".to_string(),
+ name: "EV/EBITDA".to_string(),
+ category: "Valuation".to_string(),
+ description: "Enterprise Value to EBITDA".to_string(),
+ metric_type: MetricType::EvToEbitda,
+ },
+ MetricInfo {
+ id: "pegRatio".to_string(),
+ name: "PEG Ratio".to_string(),
+ category: "Valuation".to_string(),
+ description: "Price/Earnings to Growth Ratio".to_string(),
+ metric_type: MetricType::PegRatio,
+ },
+ // Profitability Metrics
+ MetricInfo {
+ id: "roe".to_string(),
+ name: "ROE".to_string(),
+ category: "Profitability".to_string(),
+ description: "Return on Equity (%)".to_string(),
+ metric_type: MetricType::Roe,
+ },
+ MetricInfo {
+ id: "roa".to_string(),
+ name: "ROA".to_string(),
+ category: "Profitability".to_string(),
+ description: "Return on Assets (%)".to_string(),
+ metric_type: MetricType::Roa,
+ },
+ MetricInfo {
+ id: "roic".to_string(),
+ name: "ROIC".to_string(),
+ category: "Profitability".to_string(),
+ description: "Return on Invested Capital (%)".to_string(),
+ metric_type: MetricType::Roic,
+ },
+ MetricInfo {
+ id: "grossMargin".to_string(),
+ name: "Gross Margin".to_string(),
+ category: "Profitability".to_string(),
+ description: "Gross Profit Margin (%)".to_string(),
+ metric_type: MetricType::GrossMargin,
+ },
+ MetricInfo {
+ id: "operatingMargin".to_string(),
+ name: "Operating Margin".to_string(),
+ category: "Profitability".to_string(),
+ description: "Operating Profit Margin (%)".to_string(),
+ metric_type: MetricType::OperatingMargin,
+ },
+ MetricInfo {
+ id: "netMargin".to_string(),
+ name: "Net Margin".to_string(),
+ category: "Profitability".to_string(),
+ description: "Net Profit Margin (%)".to_string(),
+ metric_type: MetricType::NetMargin,
+ },
+ // Growth Metrics
+ MetricInfo {
+ id: "revenueGrowth".to_string(),
+ name: "Revenue Growth".to_string(),
+ category: "Growth".to_string(),
+ description: "Year-over-Year Revenue Growth (%)".to_string(),
+ metric_type: MetricType::RevenueGrowth,
+ },
+ MetricInfo {
+ id: "earningsGrowth".to_string(),
+ name: "Earnings Growth".to_string(),
+ category: "Growth".to_string(),
+ description: "Year-over-Year Earnings Growth (%)".to_string(),
+ metric_type: MetricType::EarningsGrowth,
+ },
+ MetricInfo {
+ id: "fcfGrowth".to_string(),
+ name: "FCF Growth".to_string(),
+ category: "Growth".to_string(),
+ description: "Free Cash Flow Growth (%)".to_string(),
+ metric_type: MetricType::FcfGrowth,
+ },
+ // Leverage Metrics
+ MetricInfo {
+ id: "debtToEquity".to_string(),
+ name: "Debt/Equity".to_string(),
+ category: "Leverage".to_string(),
+ description: "Debt to Equity Ratio".to_string(),
+ metric_type: MetricType::DebtToEquity,
+ },
+ MetricInfo {
+ id: "debtToAssets".to_string(),
+ name: "Debt/Assets".to_string(),
+ category: "Leverage".to_string(),
+ description: "Debt to Assets Ratio".to_string(),
+ metric_type: MetricType::DebtToAssets,
+ },
+ MetricInfo {
+ id: "interestCoverage".to_string(),
+ name: "Interest Coverage".to_string(),
+ category: "Leverage".to_string(),
+ description: "Interest Coverage Ratio".to_string(),
+ metric_type: MetricType::InterestCoverage,
+ },
+ // Market Data
+ MetricInfo {
+ id: "marketCap".to_string(),
+ name: "Market Cap".to_string(),
+ category: "Market Data".to_string(),
+ description: "Market Capitalization".to_string(),
+ metric_type: MetricType::MarketCap,
+ },
+ // Dividend Metrics
+ MetricInfo {
+ id: "dividendYield".to_string(),
+ name: "Dividend Yield".to_string(),
+ category: "Dividend".to_string(),
+ description: "Dividend Yield (%)".to_string(),
+ metric_type: MetricType::DividendYield,
+ },
+ MetricInfo {
+ id: "payoutRatio".to_string(),
+ name: "Payout Ratio".to_string(),
+ category: "Dividend".to_string(),
+ description: "Dividend Payout Ratio (%)".to_string(),
+ metric_type: MetricType::PayoutRatio,
+ },
+ MetricInfo {
+ id: "dividendGrowth".to_string(),
+ name: "Dividend Growth".to_string(),
+ category: "Dividend".to_string(),
+ description: "Dividend Growth Rate (%)".to_string(),
+ metric_type: MetricType::DividendGrowth,
+ },
+ ];
+
+ ScreenerCommandResponse {
+ success: true,
+ data: Some(metrics),
+ error: None,
+ }
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MetricInfo {
+ pub id: String,
+ pub name: String,
+ pub category: String,
+ pub description: String,
+ #[serde(rename = "type")]
+ pub metric_type: MetricType,
+}
+
+// ============================================================================
+// Helper Functions - FMP Data Fetching
+// ============================================================================
+
+/// Fetch stock universe from FMP API with financial metrics
+async fn fetch_stock_universe(app: &tauri::AppHandle) -> Result<Vec<StockData>, String> {
+ // Comprehensive list of liquid stocks across sectors for screening
+ let symbols = vec![
+ // Technology
+ "AAPL", "MSFT", "GOOGL", "NVDA", "META", "TSLA", "AVGO", "ORCL", "CSCO", "ADBE",
+ "CRM", "AMD", "INTC", "QCOM", "UBER", "NOW", "SNOW", "PANW", "ANET", "CRWD",
+ // Healthcare
+ "JNJ", "UNH", "LLY", "ABBV", "MRK", "TMO", "ABT", "DHR", "PFE", "BMY",
+ "AMGN", "GILD", "VRTX", "CI", "CVS", "REGN", "ISRG", "HUM", "ZTS", "MRNA",
+ // Financials
+ "JPM", "BAC", "WFC", "GS", "MS", "C", "SCHW", "BLK", "AXP", "SPGI",
+ "USB", "PNC", "TFC", "BK", "COF", "CME", "ICE", "MCO", "AON", "MMC",
+ // Consumer
+ "AMZN", "WMT", "HD", "MCD", "NKE", "SBUX", "TGT", "LOW", "TJX", "BKNG",
+ "MAR", "CMG", "YUM", "DG", "ROST", "ULTA", "DPZ", "ABNB", "DKNG", "ETSY",
+ // Consumer Staples
+ "PG", "KO", "PEP", "COST", "PM", "MO", "MDLZ", "CL", "KMB", "GIS",
+ "HSY", "K", "STZ", "TSN", "CHD", "CAG", "CPB", "SJM", "HRL", "MKC",
+ // Energy
+ "XOM", "CVX", "COP", "SLB", "EOG", "MPC", "PSX", "VLO", "OXY", "HAL",
+ "BKR", "WMB", "KMI", "HES", "DVN", "FANG", "MRO", "APA", "OKE", "TRGP",
+ // Industrials
+ "CAT", "BA", "UPS", "RTX", "HON", "UNP", "DE", "LMT", "GE", "MMM",
+ "ETN", "FDX", "NSC", "CSX", "EMR", "WM", "ITW", "PH", "TT", "CARR",
+ // Materials
+ "LIN", "APD", "SHW", "ECL", "DD", "NEM", "FCX", "VMC", "MLM", "ALB",
+ "PPG", "NUE", "CTVA", "DOW", "IFF", "CE", "CF", "MOS", "FMC", "SEE",
+ // Real Estate
+ "PLD", "AMT", "EQIX", "PSA", "WELL", "DLR", "CBRE", "SPG", "O", "VICI",
+ "AVB", "EQR", "INVH", "MAA", "ESS", "VTR", "ARE", "BXP", "KIM", "REG",
+ // Utilities
+ "NEE", "DUK", "SO", "D", "AEP", "EXC", "SRE", "PCG", "XEL", "WEC",
+ "ED", "ES", "PEG", "EIX", "AWK", "DTE", "PPL", "AEE", "CMS", "ATO",
+ // Communication
+ "T", "VZ", "TMUS", "NFLX", "DIS", "CMCSA", "CHTR", "PARA", "WBD", "OMC",
+ "IPG", "FOXA", "MTCH", "EA", "TTWO", "NWSA", "LYV", "PINS", "SNAP", "RBLX",
+ ];
+
+ let total_symbols = symbols.len();
+ let mut stock_universe = Vec::new();
+ let mut fetch_errors = 0;
+ let max_errors = 50; // Allow some failures
+
+ for symbol in symbols {
+ match fetch_stock_data(app, symbol).await {
+ Ok(stock_data) => {
+ stock_universe.push(stock_data);
+ }
+ Err(e) => {
+ eprintln!("Failed to fetch data for {}: {}", symbol, e);
+ fetch_errors += 1;
+ if fetch_errors > max_errors {
+ return Err(format!(
+ "Too many fetch errors ({}/{}). Check FMP API key and connection.",
+ fetch_errors, total_symbols
+ ));
+ }
+ }
+ }
+ }
+
+ if stock_universe.is_empty() {
+ return Err("Failed to fetch any stock data from FMP".to_string());
+ }
+
+ Ok(stock_universe)
+}
+
+/// Fetch individual stock data from FMP
+async fn fetch_stock_data(app: &tauri::AppHandle, symbol: &str) -> Result<StockData, String> {
+ // Fetch financial ratios from FMP
+ let ratios_result = crate::commands::fmp::get_fmp_financial_ratios(
+ app.clone(),
+ symbol.to_string(),
+ Some("annual".to_string()),
+ Some(1),
+ )
+ .await;
+
+ let profile_result = crate::commands::fmp::get_fmp_company_profile(
+ app.clone(),
+ symbol.to_string(),
+ )
+ .await;
+
+ // Parse responses
+ let ratios_json: serde_json::Value = ratios_result
+ .map_err(|e| format!("FMP ratios error: {}", e))
+ .and_then(|json_str| {
+ serde_json::from_str(&json_str)
+ .map_err(|e| format!("JSON parse error: {}", e))
+ })?;
+
+ let profile_json: serde_json::Value = profile_result
+ .map_err(|e| format!("FMP profile error: {}", e))
+ .and_then(|json_str| {
+ serde_json::from_str(&json_str)
+ .map_err(|e| format!("JSON parse error: {}", e))
+ })?;
+
+ // Extract profile data
+ let profile = profile_json
+ .get("data")
+ .and_then(|d| d.as_object())
+ .ok_or("Profile data not found")?;
+
+ let company_name = profile
+ .get("companyName")
+ .and_then(|n| n.as_str())
+ .unwrap_or(symbol)
+ .to_string();
+
+ let sector = profile
+ .get("sector")
+ .and_then(|s| s.as_str())
+ .unwrap_or("Unknown")
+ .to_string();
+
+ let industry = profile
+ .get("industry")
+ .and_then(|i| i.as_str())
+ .unwrap_or("Unknown")
+ .to_string();
+
+ let market_cap = profile
+ .get("mktCap")
+ .and_then(|m| m.as_f64())
+ .unwrap_or(0.0);
+
+ // Extract ratios data
+ let ratios = ratios_json
+ .get("data")
+ .and_then(|d| d.as_array())
+ .and_then(|arr| arr.first())
+ .and_then(|r| r.as_object())
+ .ok_or("Ratios data not found")?;
+
+ // Build metrics hashmap with all available metrics
+ let mut metrics = HashMap::new();
+
+ // Valuation metrics
+ if let Some(pe) = ratios.get("priceEarningsRatio").and_then(|v| v.as_f64()) {
+ metrics.insert("peRatio".to_string(), pe);
+ }
+ if let Some(pb) = ratios.get("priceToBookRatio").and_then(|v| v.as_f64()) {
+ metrics.insert("pbRatio".to_string(), pb);
+ }
+ if let Some(ps) = ratios.get("priceToSalesRatio").and_then(|v| v.as_f64()) {
+ metrics.insert("psRatio".to_string(), ps);
+ }
+ if let Some(pcf) = ratios.get("priceCashFlowRatio").and_then(|v| v.as_f64()) {
+ metrics.insert("pcfRatio".to_string(), pcf);
+ }
+ if let Some(ev_ebitda) = ratios.get("enterpriseValueMultiple").and_then(|v| v.as_f64()) {
+ metrics.insert("evToEbitda".to_string(), ev_ebitda);
+ }
+ if let Some(peg) = ratios.get("priceEarningsToGrowthRatio").and_then(|v| v.as_f64()) {
+ metrics.insert("pegRatio".to_string(), peg);
+ }
+
+ // Profitability metrics (convert to percentages)
+ if let Some(roe) = ratios.get("returnOnEquity").and_then(|v| v.as_f64()) {
+ metrics.insert("roe".to_string(), roe * 100.0);
+ }
+ if let Some(roa) = ratios.get("returnOnAssets").and_then(|v| v.as_f64()) {
+ metrics.insert("roa".to_string(), roa * 100.0);
+ }
+ if let Some(roic) = ratios.get("returnOnCapitalEmployed").and_then(|v| v.as_f64()) {
+ metrics.insert("roic".to_string(), roic * 100.0);
+ }
+ if let Some(gm) = ratios.get("grossProfitMargin").and_then(|v| v.as_f64()) {
+ metrics.insert("grossMargin".to_string(), gm * 100.0);
+ }
+ if let Some(om) = ratios.get("operatingProfitMargin").and_then(|v| v.as_f64()) {
+ metrics.insert("operatingMargin".to_string(), om * 100.0);
+ }
+ if let Some(nm) = ratios.get("netProfitMargin").and_then(|v| v.as_f64()) {
+ metrics.insert("netMargin".to_string(), nm * 100.0);
+ }
+
+ // Growth metrics (convert to percentages)
+ if let Some(rg) = ratios.get("revenueGrowth").and_then(|v| v.as_f64()) {
+ metrics.insert("revenueGrowth".to_string(), rg * 100.0);
+ }
+ if let Some(eg) = ratios.get("epsgrowth").and_then(|v| v.as_f64()) {
+ metrics.insert("earningsGrowth".to_string(), eg * 100.0);
+ }
+ if let Some(fcfg) = ratios.get("freeCashFlowGrowth").and_then(|v| v.as_f64()) {
+ metrics.insert("fcfGrowth".to_string(), fcfg * 100.0);
+ }
+
+ // Leverage metrics
+ if let Some(de) = ratios.get("debtEquityRatio").and_then(|v| v.as_f64()) {
+ metrics.insert("debtToEquity".to_string(), de);
+ }
+ if let Some(da) = ratios.get("debtRatio").and_then(|v| v.as_f64()) {
+ metrics.insert("debtToAssets".to_string(), da);
+ }
+ if let Some(ic) = ratios.get("interestCoverage").and_then(|v| v.as_f64()) {
+ metrics.insert("interestCoverage".to_string(), ic);
+ }
+
+ // Market data
+ metrics.insert("marketCap".to_string(), market_cap);
+ if let Some(price) = profile.get("price").and_then(|v| v.as_f64()) {
+ metrics.insert("price".to_string(), price);
+ }
+ if let Some(beta) = profile.get("beta").and_then(|v| v.as_f64()) {
+ metrics.insert("beta".to_string(), beta);
+ }
+
+ // Dividend metrics
+ if let Some(dy) = ratios.get("dividendYield").and_then(|v| v.as_f64()) {
+ metrics.insert("dividendYield".to_string(), dy * 100.0);
+ }
+ if let Some(pr) = ratios.get("payoutRatio").and_then(|v| v.as_f64()) {
+ metrics.insert("payoutRatio".to_string(), pr * 100.0);
+ }
+
+ Ok(StockData {
+ symbol: symbol.to_string(),
+ name: company_name,
+ sector,
+ industry,
+ metrics,
+ })
+}
diff --git a/fincept-terminal-desktop/src-tauri/src/lib.rs b/fincept-terminal-desktop/src-tauri/src/lib.rs
index f64f08f58..ddd3ebb83 100644
--- a/fincept-terminal-desktop/src-tauri/src/lib.rs
+++ b/fincept-terminal-desktop/src-tauri/src/lib.rs
@@ -20,6 +20,7 @@ mod database;
mod python_runtime;
mod websocket;
mod barter_integration;
+mod services;
// mod finscript; // TODO: Implement FinScript module
// MCP Server Process with communication channels
@@ -1760,7 +1761,29 @@ pub fn run() {
commands::database::db_get_recent_excel_files,
commands::database::db_create_excel_snapshot,
commands::database::db_get_excel_snapshots,
- commands::database::db_delete_excel_snapshot
+ commands::database::db_delete_excel_snapshot,
+ // Financial Statement Analysis - CFA-compliant analysis via PyO3
+ commands::financial_analysis::analyze_income_statement,
+ commands::financial_analysis::analyze_balance_sheet,
+ commands::financial_analysis::analyze_cash_flow,
+ commands::financial_analysis::analyze_financial_statements,
+ commands::financial_analysis::get_financial_key_metrics,
+ commands::financial_analysis::analyze_financial_json,
+ // Peer Comparison & Benchmarking Commands
+ commands::peer_commands::find_peers,
+ commands::peer_commands::compare_peers,
+ commands::peer_commands::get_sector_benchmarks,
+ commands::peer_commands::calculate_peer_percentiles,
+ // Stock Screener Commands
+ commands::screener_commands::execute_stock_screen,
+ commands::screener_commands::get_value_screen,
+ commands::screener_commands::get_growth_screen,
+ commands::screener_commands::get_dividend_screen,
+ commands::screener_commands::get_momentum_screen,
+ commands::screener_commands::save_custom_screen,
+ commands::screener_commands::load_custom_screens,
+ commands::screener_commands::delete_custom_screen,
+ commands::screener_commands::get_available_metrics
])
.run(tauri::generate_context!())
.expect("error while running tauri application");
diff --git a/fincept-terminal-desktop/src-tauri/src/python_runtime.rs b/fincept-terminal-desktop/src-tauri/src/python_runtime.rs
index f82dd810d..efe425a93 100644
--- a/fincept-terminal-desktop/src-tauri/src/python_runtime.rs
+++ b/fincept-terminal-desktop/src-tauri/src/python_runtime.rs
@@ -52,6 +52,21 @@ impl PythonRuntime {
args: Vec<String>,
) -> PyResult<String> {
Python::with_gil(|py| {
+ // Set environment variables for Python script access
+ // Check if FMP_API_KEY is already set, if not, try to get it from Rust environment
+ let os_module = py.import("os")?;
+ let environ = os_module.getattr("environ")?;
+
+ // Get FMP_API_KEY from Rust environment if available
+ if let Ok(api_key) = std::env::var("FMP_API_KEY") {
+ environ.set_item("FMP_API_KEY", api_key)?;
+ } else {
+ // Try alternative environment variable names
+ if let Ok(api_key) = std::env::var("FINANCIAL_MODELING_PREP_API_KEY") {
+ environ.set_item("FMP_API_KEY", api_key)?;
+ }
+ }
+
// Read the Python script
let script_code = std::fs::read_to_string(script_path)
.map_err(|e| PyErr::new::<pyo3::exceptions::PyIOError, _>(
diff --git a/fincept-terminal-desktop/src-tauri/src/services/comparative_service.rs b/fincept-terminal-desktop/src-tauri/src/services/comparative_service.rs
new file mode 100644
index 000000000..c098bf603
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/src/services/comparative_service.rs
@@ -0,0 +1,292 @@
+// Comparative Analysis Service
+// Implements QoQ, YoY, MoM, TTM comparative calculations and percentile rankings
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ComparativeMetrics {
+ pub qoq_growth: Option<f64>, // Quarter-over-Quarter
+ pub yoy_growth: Option<f64>, // Year-over-Year
+ pub mom_growth: Option<f64>, // Month-over-Month
+ pub ttm_value: Option<f64>, // Trailing Twelve Months
+ pub cagr_3y: Option<f64>, // 3-Year Compound Annual Growth Rate
+ pub cagr_5y: Option<f64>, // 5-Year Compound Annual Growth Rate
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ValuationMetrics {
+ pub pe_ratio: Option<f64>,
+ pub pb_ratio: Option<f64>,
+ pub ps_ratio: Option<f64>,
+ pub pcf_ratio: Option<f64>,
+ pub ev_to_ebitda: Option<f64>,
+ pub peg_ratio: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ProfitabilityMetrics {
+ pub roe: Option<f64>, // Return on Equity
+ pub roa: Option<f64>, // Return on Assets
+ pub roic: Option<f64>, // Return on Invested Capital
+ pub gross_margin: Option<f64>,
+ pub operating_margin: Option<f64>,
+ pub net_margin: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GrowthMetrics {
+ pub revenue_growth: Option<f64>,
+ pub earnings_growth: Option<f64>,
+ pub fcf_growth: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LeverageMetrics {
+ pub debt_to_equity: Option<f64>,
+ pub debt_to_assets: Option<f64>,
+ pub interest_coverage: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PercentileRanking {
+ pub metric_name: String,
+ pub value: f64,
+ pub percentile: f64, // 0.0 to 100.0
+ pub z_score: f64, // Standard deviations from mean
+ pub peer_median: f64,
+ pub peer_mean: f64,
+ pub peer_std_dev: f64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ValuationStatus {
+ pub status: String, // "Undervalued", "Fairly Valued", "Overvalued"
+ pub confidence: f64, // 0.0 to 1.0
+ pub reasoning: Vec<String>,
+}
+
+pub struct ComparativeService;
+
+impl ComparativeService {
+ pub fn new() -> Self {
+ ComparativeService
+ }
+
+ /// Calculate Quarter-over-Quarter growth
+ pub fn calculate_qoq_growth(&self, current_quarter: f64, previous_quarter: f64) -> Option<f64> {
+ if previous_quarter == 0.0 {
+ return None;
+ }
+ Some(((current_quarter - previous_quarter) / previous_quarter) * 100.0)
+ }
+
+ /// Calculate Year-over-Year growth
+ pub fn calculate_yoy_growth(&self, current_year: f64, previous_year: f64) -> Option<f64> {
+ if previous_year == 0.0 {
+ return None;
+ }
+ Some(((current_year - previous_year) / previous_year) * 100.0)
+ }
+
+ /// Calculate Month-over-Month growth
+ pub fn calculate_mom_growth(&self, current_month: f64, previous_month: f64) -> Option<f64> {
+ if previous_month == 0.0 {
+ return None;
+ }
+ Some(((current_month - previous_month) / previous_month) * 100.0)
+ }
+
+ /// Calculate Compound Annual Growth Rate
+ pub fn calculate_cagr(&self, beginning_value: f64, ending_value: f64, num_years: f64) -> Option<f64> {
+ if beginning_value <= 0.0 || num_years <= 0.0 {
+ return None;
+ }
+ Some((f64::powf(ending_value / beginning_value, 1.0 / num_years) - 1.0) * 100.0)
+ }
+
+ /// Calculate percentile ranking for a value within a peer group
+ pub fn calculate_percentile(&self, value: f64, peer_values: &[f64]) -> f64 {
+ if peer_values.is_empty() {
+ return 50.0;
+ }
+
+ let count_below = peer_values.iter().filter(|&&v| v < value).count();
+ (count_below as f64 / peer_values.len() as f64) * 100.0
+ }
+
+ /// Calculate z-score for a value within a peer group
+ pub fn calculate_z_score(&self, value: f64, mean: f64, std_dev: f64) -> f64 {
+ if std_dev == 0.0 {
+ return 0.0;
+ }
+ (value - mean) / std_dev
+ }
+
+ /// Calculate mean (average) of values
+ pub fn calculate_mean(&self, values: &[f64]) -> f64 {
+ if values.is_empty() {
+ return 0.0;
+ }
+ values.iter().sum::<f64>() / values.len() as f64
+ }
+
+ /// Calculate median of values
+ pub fn calculate_median(&self, values: &[f64]) -> f64 {
+ if values.is_empty() {
+ return 0.0;
+ }
+
+ let mut sorted = values.to_vec();
+ sorted.sort_by(|a, b| a.partial_cmp(b).unwrap_or(std::cmp::Ordering::Equal));
+
+ let mid = sorted.len() / 2;
+ if sorted.len() % 2 == 0 {
+ (sorted[mid - 1] + sorted[mid]) / 2.0
+ } else {
+ sorted[mid]
+ }
+ }
+
+ /// Calculate standard deviation
+ pub fn calculate_std_dev(&self, values: &[f64], mean: f64) -> f64 {
+ if values.is_empty() {
+ return 0.0;
+ }
+
+ let variance = values
+ .iter()
+ .map(|&v| {
+ let diff = v - mean;
+ diff * diff
+ })
+ .sum::<f64>()
+ / values.len() as f64;
+
+ variance.sqrt()
+ }
+
+ /// Generate comprehensive percentile ranking for a metric
+ pub fn generate_percentile_ranking(
+ &self,
+ metric_name: &str,
+ value: f64,
+ peer_values: &[f64],
+ ) -> PercentileRanking {
+ let mean = self.calculate_mean(peer_values);
+ let std_dev = self.calculate_std_dev(peer_values, mean);
+ let percentile = self.calculate_percentile(value, peer_values);
+ let z_score = self.calculate_z_score(value, mean, std_dev);
+ let median = self.calculate_median(peer_values);
+
+ PercentileRanking {
+ metric_name: metric_name.to_string(),
+ value,
+ percentile,
+ z_score,
+ peer_median: median,
+ peer_mean: mean,
+ peer_std_dev: std_dev,
+ }
+ }
+
+ /// Assess valuation status based on multiple metrics
+ pub fn assess_valuation_status(
+ &self,
+ pe_percentile: f64,
+ pb_percentile: f64,
+ ps_percentile: f64,
+ ) -> ValuationStatus {
+ let mut score = 0.0;
+ let mut reasoning = Vec::new();
+
+ // Lower percentiles indicate cheaper valuation (better value)
+ if pe_percentile < 33.0 {
+ score += 1.0;
+ reasoning.push(format!("P/E ratio in bottom third of peers ({}th percentile)", pe_percentile.round()));
+ } else if pe_percentile > 66.0 {
+ score -= 1.0;
+ reasoning.push(format!("P/E ratio in top third of peers ({}th percentile)", pe_percentile.round()));
+ }
+
+ if pb_percentile < 33.0 {
+ score += 1.0;
+ reasoning.push(format!("P/B ratio in bottom third of peers ({}th percentile)", pb_percentile.round()));
+ } else if pb_percentile > 66.0 {
+ score -= 1.0;
+ reasoning.push(format!("P/B ratio in top third of peers ({}th percentile)", pb_percentile.round()));
+ }
+
+ if ps_percentile < 33.0 {
+ score += 1.0;
+ reasoning.push(format!("P/S ratio in bottom third of peers ({}th percentile)", ps_percentile.round()));
+ } else if ps_percentile > 66.0 {
+ score -= 1.0;
+ reasoning.push(format!("P/S ratio in top third of peers ({}th percentile)", ps_percentile.round()));
+ }
+
+ let (status, confidence) = if score >= 2.0 {
+ ("Undervalued".to_string(), 0.8)
+ } else if score >= 1.0 {
+ ("Potentially Undervalued".to_string(), 0.6)
+ } else if score <= -2.0 {
+ ("Overvalued".to_string(), 0.8)
+ } else if score <= -1.0 {
+ ("Potentially Overvalued".to_string(), 0.6)
+ } else {
+ ("Fairly Valued".to_string(), 0.5)
+ };
+
+ ValuationStatus {
+ status,
+ confidence,
+ reasoning,
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_qoq_growth() {
+ let service = ComparativeService::new();
+ let growth = service.calculate_qoq_growth(110.0, 100.0);
+ assert_eq!(growth, Some(10.0));
+ }
+
+ #[test]
+ fn test_yoy_growth() {
+ let service = ComparativeService::new();
+ let growth = service.calculate_yoy_growth(120.0, 100.0);
+ assert_eq!(growth, Some(20.0));
+ }
+
+ #[test]
+ fn test_cagr() {
+ let service = ComparativeService::new();
+ let cagr = service.calculate_cagr(100.0, 121.0, 2.0).unwrap();
+ assert!((cagr - 10.0).abs() < 0.1);
+ }
+
+ #[test]
+ fn test_percentile() {
+ let service = ComparativeService::new();
+ let values = vec![10.0, 20.0, 30.0, 40.0, 50.0];
+ let percentile = service.calculate_percentile(30.0, &values);
+ assert_eq!(percentile, 40.0); // 2 out of 5 values are below 30
+ }
+
+ #[test]
+ fn test_mean_median() {
+ let service = ComparativeService::new();
+ let values = vec![10.0, 20.0, 30.0, 40.0, 50.0];
+ assert_eq!(service.calculate_mean(&values), 30.0);
+ assert_eq!(service.calculate_median(&values), 30.0);
+ }
+}
diff --git a/fincept-terminal-desktop/src-tauri/src/services/gics_service.rs b/fincept-terminal-desktop/src-tauri/src/services/gics_service.rs
new file mode 100644
index 000000000..e4bbcb4a4
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/src/services/gics_service.rs
@@ -0,0 +1,290 @@
+// GICS (Global Industry Classification Standard) Service
+// Implements CFA Institute-compliant sector classification and peer identification
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum GICSSector {
+ Energy,
+ Materials,
+ Industrials,
+ ConsumerDiscretionary,
+ ConsumerStaples,
+ HealthCare,
+ Financials,
+ InformationTechnology,
+ CommunicationServices,
+ Utilities,
+ RealEstate,
+}
+
+impl GICSSector {
+ pub fn from_string(s: &str) -> Option<Self> {
+ match s.to_lowercase().as_str() {
+ "energy" => Some(GICSSector::Energy),
+ "materials" => Some(GICSSector::Materials),
+ "industrials" => Some(GICSSector::Industrials),
+ "consumer discretionary" | "consumerdiscretionary" => Some(GICSSector::ConsumerDiscretionary),
+ "consumer staples" | "consumerstaples" => Some(GICSSector::ConsumerStaples),
+ "health care" | "healthcare" => Some(GICSSector::HealthCare),
+ "financials" => Some(GICSSector::Financials),
+ "information technology" | "informationtechnology" | "technology" => Some(GICSSector::InformationTechnology),
+ "communication services" | "communicationservices" => Some(GICSSector::CommunicationServices),
+ "utilities" => Some(GICSSector::Utilities),
+ "real estate" | "realestate" => Some(GICSSector::RealEstate),
+ _ => None,
+ }
+ }
+
+ pub fn to_string(&self) -> String {
+ match self {
+ GICSSector::Energy => "Energy".to_string(),
+ GICSSector::Materials => "Materials".to_string(),
+ GICSSector::Industrials => "Industrials".to_string(),
+ GICSSector::ConsumerDiscretionary => "Consumer Discretionary".to_string(),
+ GICSSector::ConsumerStaples => "Consumer Staples".to_string(),
+ GICSSector::HealthCare => "Health Care".to_string(),
+ GICSSector::Financials => "Financials".to_string(),
+ GICSSector::InformationTechnology => "Information Technology".to_string(),
+ GICSSector::CommunicationServices => "Communication Services".to_string(),
+ GICSSector::Utilities => "Utilities".to_string(),
+ GICSSector::RealEstate => "Real Estate".to_string(),
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum MarketCapCategory {
+ Mega, // > $200B
+ Large, // $10B - $200B
+ Mid, // $2B - $10B
+ Small, // $300M - $2B
+ Micro, // $50M - $300M
+ Nano, // < $50M
+}
+
+impl MarketCapCategory {
+ pub fn from_market_cap(market_cap: f64) -> Self {
+ if market_cap > 200_000_000_000.0 {
+ MarketCapCategory::Mega
+ } else if market_cap > 10_000_000_000.0 {
+ MarketCapCategory::Large
+ } else if market_cap > 2_000_000_000.0 {
+ MarketCapCategory::Mid
+ } else if market_cap > 300_000_000.0 {
+ MarketCapCategory::Small
+ } else if market_cap > 50_000_000.0 {
+ MarketCapCategory::Micro
+ } else {
+ MarketCapCategory::Nano
+ }
+ }
+
+ pub fn to_string(&self) -> String {
+ match self {
+ MarketCapCategory::Mega => "Mega Cap".to_string(),
+ MarketCapCategory::Large => "Large Cap".to_string(),
+ MarketCapCategory::Mid => "Mid Cap".to_string(),
+ MarketCapCategory::Small => "Small Cap".to_string(),
+ MarketCapCategory::Micro => "Micro Cap".to_string(),
+ MarketCapCategory::Nano => "Nano Cap".to_string(),
+ }
+ }
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct PeerCompany {
+ pub symbol: String,
+ pub name: String,
+ pub sector: String,
+ pub industry: String,
+ pub market_cap: f64,
+ pub similarity_score: f64,
+ pub match_details: MatchDetails,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct MatchDetails {
+ pub sector_match: bool,
+ pub industry_match: bool,
+ pub market_cap_similarity: f64, // 0.0 to 1.0
+ pub geographic_match: bool,
+}
+
+pub struct PeerIdentificationService;
+
+impl PeerIdentificationService {
+ pub fn new() -> Self {
+ PeerIdentificationService
+ }
+
+ /// Calculate similarity score between two companies
+ pub fn calculate_similarity(
+ &self,
+ target_sector: &str,
+ target_industry: &str,
+ target_market_cap: f64,
+ peer_sector: &str,
+ peer_industry: &str,
+ peer_market_cap: f64,
+ ) -> f64 {
+ let mut score = 0.0;
+ let max_score = 100.0;
+
+ // Sector match (40 points)
+ if target_sector.to_lowercase() == peer_sector.to_lowercase() {
+ score += 40.0;
+ }
+
+ // Industry match (30 points)
+ if target_industry.to_lowercase() == peer_industry.to_lowercase() {
+ score += 30.0;
+ }
+
+ // Market cap similarity (30 points)
+ let market_cap_ratio = if target_market_cap > peer_market_cap {
+ peer_market_cap / target_market_cap
+ } else {
+ target_market_cap / peer_market_cap
+ };
+ score += 30.0 * market_cap_ratio;
+
+ // Normalize to 0-1 scale
+ score / max_score
+ }
+
+ /// Find peer companies based on sector, industry, and market cap
+ pub fn find_peers(
+ &self,
+ target_symbol: &str,
+ target_sector: &str,
+ target_industry: &str,
+ target_market_cap: f64,
+ candidate_companies: Vec<HashMap<String, serde_json::Value>>,
+ min_similarity: f64,
+ max_peers: usize,
+ ) -> Vec<PeerCompany> {
+ let mut peers: Vec<PeerCompany> = candidate_companies
+ .iter()
+ .filter_map(|company| {
+ let symbol = company.get("symbol")?.as_str()?.to_string();
+
+ // Skip target company
+ if symbol == target_symbol {
+ return None;
+ }
+
+ let name = company.get("name")?.as_str()?.to_string();
+ let sector = company.get("sector")?.as_str()?.to_string();
+ let industry = company.get("industry")?.as_str()?.to_string();
+ let market_cap = company.get("marketCap")?.as_f64()?;
+
+ let similarity_score = self.calculate_similarity(
+ target_sector,
+ target_industry,
+ target_market_cap,
+ &sector,
+ &industry,
+ market_cap,
+ );
+
+ if similarity_score < min_similarity {
+ return None;
+ }
+
+ let market_cap_ratio = if target_market_cap > market_cap {
+ market_cap / target_market_cap
+ } else {
+ target_market_cap / market_cap
+ };
+
+ Some(PeerCompany {
+ symbol,
+ name,
+ sector: sector.clone(),
+ industry: industry.clone(),
+ market_cap,
+ similarity_score,
+ match_details: MatchDetails {
+ sector_match: target_sector.to_lowercase() == sector.to_lowercase(),
+ industry_match: target_industry.to_lowercase() == industry.to_lowercase(),
+ market_cap_similarity: market_cap_ratio,
+ geographic_match: false, // Could be enhanced with geographic data
+ },
+ })
+ })
+ .collect();
+
+ // Sort by similarity score (descending)
+ peers.sort_by(|a, b| {
+ b.similarity_score
+ .partial_cmp(&a.similarity_score)
+ .unwrap_or(std::cmp::Ordering::Equal)
+ });
+
+ // Take top N peers
+ peers.into_iter().take(max_peers).collect()
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_gics_sector_from_string() {
+ assert_eq!(
+ GICSSector::from_string("Energy"),
+ Some(GICSSector::Energy)
+ );
+ assert_eq!(
+ GICSSector::from_string("information technology"),
+ Some(GICSSector::InformationTechnology)
+ );
+ assert_eq!(GICSSector::from_string("invalid"), None);
+ }
+
+ #[test]
+ fn test_market_cap_category() {
+ assert_eq!(
+ MarketCapCategory::from_market_cap(300_000_000_000.0),
+ MarketCapCategory::Mega
+ );
+ assert_eq!(
+ MarketCapCategory::from_market_cap(50_000_000_000.0),
+ MarketCapCategory::Large
+ );
+ assert_eq!(
+ MarketCapCategory::from_market_cap(5_000_000_000.0),
+ MarketCapCategory::Mid
+ );
+ }
+
+ #[test]
+ fn test_similarity_calculation() {
+ let service = PeerIdentificationService::new();
+
+ // Same sector, same industry, similar market cap
+ let score = service.calculate_similarity(
+ "Technology",
+ "Software",
+ 100_000_000_000.0,
+ "Technology",
+ "Software",
+ 90_000_000_000.0,
+ );
+ assert!(score > 0.95);
+
+ // Different sector
+ let score = service.calculate_similarity(
+ "Technology",
+ "Software",
+ 100_000_000_000.0,
+ "Energy",
+ "Oil & Gas",
+ 100_000_000_000.0,
+ );
+ assert!(score < 0.5);
+ }
+}
diff --git a/fincept-terminal-desktop/src-tauri/src/services/mod.rs b/fincept-terminal-desktop/src-tauri/src/services/mod.rs
new file mode 100644
index 000000000..6a116282d
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/src/services/mod.rs
@@ -0,0 +1,6 @@
+// Services module
+// Business logic and analytical services
+
+pub mod gics_service;
+pub mod comparative_service;
+pub mod stock_screener_service;
diff --git a/fincept-terminal-desktop/src-tauri/src/services/stock_screener_service.rs b/fincept-terminal-desktop/src-tauri/src/services/stock_screener_service.rs
new file mode 100644
index 000000000..a3d07e262
--- /dev/null
+++ b/fincept-terminal-desktop/src-tauri/src/services/stock_screener_service.rs
@@ -0,0 +1,625 @@
+// Stock Screener Service
+// Advanced filtering system for equity screening based on fundamental metrics
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+// ============================================================================
+// Core Types
+// ============================================================================
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum FilterOperator {
+ GreaterThan,
+ LessThan,
+ GreaterThanOrEqual,
+ LessThanOrEqual,
+ Equal,
+ NotEqual,
+ Between,
+ InList,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum MetricType {
+ // Valuation
+ PeRatio,
+ PbRatio,
+ PsRatio,
+ PcfRatio,
+ EvToEbitda,
+ PegRatio,
+
+ // Profitability
+ Roe,
+ Roa,
+ Roic,
+ GrossMargin,
+ OperatingMargin,
+ NetMargin,
+
+ // Growth
+ RevenueGrowth,
+ EarningsGrowth,
+ FcfGrowth,
+
+ // Leverage
+ DebtToEquity,
+ DebtToAssets,
+ InterestCoverage,
+
+ // Market Data
+ MarketCap,
+ Price,
+ Volume,
+ Beta,
+
+ // Dividend
+ DividendYield,
+ PayoutRatio,
+ DividendGrowth,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FilterCondition {
+ pub metric: MetricType,
+ pub operator: FilterOperator,
+ pub value: FilterValue,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum FilterValue {
+ Single(f64),
+ Range { min: f64, max: f64 },
+ List(Vec<String>),
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScreenCriteria {
+ pub name: String,
+ pub description: String,
+ pub conditions: Vec<FilterCondition>,
+ pub sector_filter: Option<Vec<String>>,
+ pub industry_filter: Option<Vec<String>>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct StockData {
+ pub symbol: String,
+ pub name: String,
+ pub sector: String,
+ pub industry: String,
+ pub metrics: HashMap<String, f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ScreenResult {
+ pub total_stocks_screened: usize,
+ pub matching_stocks: Vec<StockData>,
+ pub criteria_used: ScreenCriteria,
+}
+
+// ============================================================================
+// Stock Screener Service
+// ============================================================================
+
+pub struct StockScreenerService {
+ stock_universe: Vec<StockData>,
+}
+
+impl StockScreenerService {
+ pub fn new() -> Self {
+ StockScreenerService {
+ stock_universe: create_mock_stock_universe(),
+ }
+ }
+
+ /// Create screener with custom stock universe (for real FMP data)
+ pub fn with_stock_universe(stock_universe: Vec<StockData>) -> Self {
+ StockScreenerService {
+ stock_universe,
+ }
+ }
+
+ /// Execute a screen with given criteria
+ pub fn execute_screen(&self, criteria: ScreenCriteria) -> ScreenResult {
+ let mut matching_stocks = Vec::new();
+
+ for stock in &self.stock_universe {
+ // Apply sector filter
+ if let Some(ref sectors) = criteria.sector_filter {
+ if !sectors.contains(&stock.sector) {
+ continue;
+ }
+ }
+
+ // Apply industry filter
+ if let Some(ref industries) = criteria.industry_filter {
+ if !industries.contains(&stock.industry) {
+ continue;
+ }
+ }
+
+ // Apply metric conditions
+ if self.matches_conditions(stock, &criteria.conditions) {
+ matching_stocks.push(stock.clone());
+ }
+ }
+
+ ScreenResult {
+ total_stocks_screened: self.stock_universe.len(),
+ matching_stocks,
+ criteria_used: criteria,
+ }
+ }
+
+ /// Check if stock matches all conditions
+ fn matches_conditions(&self, stock: &StockData, conditions: &[FilterCondition]) -> bool {
+ for condition in conditions {
+ if !self.matches_condition(stock, condition) {
+ return false;
+ }
+ }
+ true
+ }
+
+ /// Check if stock matches a single condition
+ fn matches_condition(&self, stock: &StockData, condition: &FilterCondition) -> bool {
+ let metric_key = self.metric_to_key(&condition.metric);
+ let stock_value = match stock.metrics.get(&metric_key) {
+ Some(&value) => value,
+ None => return false, // Missing metric = no match
+ };
+
+ match (&condition.operator, &condition.value) {
+ (FilterOperator::GreaterThan, FilterValue::Single(threshold)) => {
+ stock_value > *threshold
+ }
+ (FilterOperator::LessThan, FilterValue::Single(threshold)) => {
+ stock_value < *threshold
+ }
+ (FilterOperator::GreaterThanOrEqual, FilterValue::Single(threshold)) => {
+ stock_value >= *threshold
+ }
+ (FilterOperator::LessThanOrEqual, FilterValue::Single(threshold)) => {
+ stock_value <= *threshold
+ }
+ (FilterOperator::Equal, FilterValue::Single(threshold)) => {
+ (stock_value - threshold).abs() < 0.01 // Float comparison tolerance
+ }
+ (FilterOperator::NotEqual, FilterValue::Single(threshold)) => {
+ (stock_value - threshold).abs() >= 0.01
+ }
+ (FilterOperator::Between, FilterValue::Range { min, max }) => {
+ stock_value >= *min && stock_value <= *max
+ }
+ _ => false, // Invalid combination
+ }
+ }
+
+ /// Convert metric type to string key
+ fn metric_to_key(&self, metric: &MetricType) -> String {
+ match metric {
+ MetricType::PeRatio => "peRatio".to_string(),
+ MetricType::PbRatio => "pbRatio".to_string(),
+ MetricType::PsRatio => "psRatio".to_string(),
+ MetricType::PcfRatio => "pcfRatio".to_string(),
+ MetricType::EvToEbitda => "evToEbitda".to_string(),
+ MetricType::PegRatio => "pegRatio".to_string(),
+ MetricType::Roe => "roe".to_string(),
+ MetricType::Roa => "roa".to_string(),
+ MetricType::Roic => "roic".to_string(),
+ MetricType::GrossMargin => "grossMargin".to_string(),
+ MetricType::OperatingMargin => "operatingMargin".to_string(),
+ MetricType::NetMargin => "netMargin".to_string(),
+ MetricType::RevenueGrowth => "revenueGrowth".to_string(),
+ MetricType::EarningsGrowth => "earningsGrowth".to_string(),
+ MetricType::FcfGrowth => "fcfGrowth".to_string(),
+ MetricType::DebtToEquity => "debtToEquity".to_string(),
+ MetricType::DebtToAssets => "debtToAssets".to_string(),
+ MetricType::InterestCoverage => "interestCoverage".to_string(),
+ MetricType::MarketCap => "marketCap".to_string(),
+ MetricType::Price => "price".to_string(),
+ MetricType::Volume => "volume".to_string(),
+ MetricType::Beta => "beta".to_string(),
+ MetricType::DividendYield => "dividendYield".to_string(),
+ MetricType::PayoutRatio => "payoutRatio".to_string(),
+ MetricType::DividendGrowth => "dividendGrowth".to_string(),
+ }
+ }
+
+ /// Get preset screen: Value Stocks
+ pub fn get_value_screen() -> ScreenCriteria {
+ ScreenCriteria {
+ name: "Value Stocks".to_string(),
+ description: "Stocks trading below intrinsic value with strong fundamentals".to_string(),
+ conditions: vec![
+ FilterCondition {
+ metric: MetricType::PeRatio,
+ operator: FilterOperator::LessThan,
+ value: FilterValue::Single(15.0),
+ },
+ FilterCondition {
+ metric: MetricType::PbRatio,
+ operator: FilterOperator::LessThan,
+ value: FilterValue::Single(3.0),
+ },
+ FilterCondition {
+ metric: MetricType::DebtToEquity,
+ operator: FilterOperator::LessThan,
+ value: FilterValue::Single(0.8),
+ },
+ FilterCondition {
+ metric: MetricType::Roe,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(12.0),
+ },
+ ],
+ sector_filter: None,
+ industry_filter: None,
+ }
+ }
+
+ /// Get preset screen: Growth Stocks
+ pub fn get_growth_screen() -> ScreenCriteria {
+ ScreenCriteria {
+ name: "Growth Stocks".to_string(),
+ description: "High-growth companies with strong revenue and earnings expansion".to_string(),
+ conditions: vec![
+ FilterCondition {
+ metric: MetricType::RevenueGrowth,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(20.0),
+ },
+ FilterCondition {
+ metric: MetricType::EarningsGrowth,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(15.0),
+ },
+ FilterCondition {
+ metric: MetricType::Roe,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(15.0),
+ },
+ FilterCondition {
+ metric: MetricType::GrossMargin,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(40.0),
+ },
+ ],
+ sector_filter: None,
+ industry_filter: None,
+ }
+ }
+
+ /// Get preset screen: Dividend Aristocrats
+ pub fn get_dividend_screen() -> ScreenCriteria {
+ ScreenCriteria {
+ name: "Dividend Aristocrats".to_string(),
+ description: "Stable dividend payers with sustainable payouts".to_string(),
+ conditions: vec![
+ FilterCondition {
+ metric: MetricType::DividendYield,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(3.0),
+ },
+ FilterCondition {
+ metric: MetricType::PayoutRatio,
+ operator: FilterOperator::LessThan,
+ value: FilterValue::Single(70.0),
+ },
+ FilterCondition {
+ metric: MetricType::DividendGrowth,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(5.0),
+ },
+ FilterCondition {
+ metric: MetricType::DebtToEquity,
+ operator: FilterOperator::LessThan,
+ value: FilterValue::Single(1.0),
+ },
+ ],
+ sector_filter: None,
+ industry_filter: None,
+ }
+ }
+
+ /// Get preset screen: Momentum Stocks
+ pub fn get_momentum_screen() -> ScreenCriteria {
+ ScreenCriteria {
+ name: "Momentum Stocks".to_string(),
+ description: "Stocks with strong price momentum and volume".to_string(),
+ conditions: vec![
+ FilterCondition {
+ metric: MetricType::RevenueGrowth,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(15.0),
+ },
+ FilterCondition {
+ metric: MetricType::Roe,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(18.0),
+ },
+ FilterCondition {
+ metric: MetricType::OperatingMargin,
+ operator: FilterOperator::GreaterThan,
+ value: FilterValue::Single(15.0),
+ },
+ ],
+ sector_filter: Some(vec![
+ "Information Technology".to_string(),
+ "Communication Services".to_string(),
+ "Consumer Discretionary".to_string(),
+ ]),
+ industry_filter: None,
+ }
+ }
+}
+
+// ============================================================================
+// Mock Data (For Development)
+// ============================================================================
+
+fn create_mock_stock_universe() -> Vec<StockData> {
+ vec![
+ StockData {
+ symbol: "AAPL".to_string(),
+ name: "Apple Inc.".to_string(),
+ sector: "Information Technology".to_string(),
+ industry: "Consumer Electronics".to_string(),
+ metrics: HashMap::from([
+ ("peRatio".to_string(), 28.5),
+ ("pbRatio".to_string(), 45.2),
+ ("psRatio".to_string(), 7.1),
+ ("roe".to_string(), 147.4),
+ ("roa".to_string(), 27.8),
+ ("roic".to_string(), 54.2),
+ ("grossMargin".to_string(), 43.3),
+ ("operatingMargin".to_string(), 30.7),
+ ("netMargin".to_string(), 26.4),
+ ("revenueGrowth".to_string(), 7.8),
+ ("earningsGrowth".to_string(), 13.4),
+ ("debtToEquity".to_string(), 2.0),
+ ("marketCap".to_string(), 2_800_000_000_000.0),
+ ("dividendYield".to_string(), 0.5),
+ ("payoutRatio".to_string(), 15.0),
+ ]),
+ },
+ StockData {
+ symbol: "MSFT".to_string(),
+ name: "Microsoft Corporation".to_string(),
+ sector: "Information Technology".to_string(),
+ industry: "Software".to_string(),
+ metrics: HashMap::from([
+ ("peRatio".to_string(), 32.4),
+ ("pbRatio".to_string(), 12.8),
+ ("psRatio".to_string(), 11.2),
+ ("roe".to_string(), 39.7),
+ ("roa".to_string(), 15.2),
+ ("roic".to_string(), 24.5),
+ ("grossMargin".to_string(), 68.4),
+ ("operatingMargin".to_string(), 42.1),
+ ("netMargin".to_string(), 34.8),
+ ("revenueGrowth".to_string(), 16.2),
+ ("earningsGrowth".to_string(), 22.1),
+ ("debtToEquity".to_string(), 0.45),
+ ("marketCap".to_string(), 2_900_000_000_000.0),
+ ("dividendYield".to_string(), 0.8),
+ ("payoutRatio".to_string(), 25.0),
+ ]),
+ },
+ StockData {
+ symbol: "JNJ".to_string(),
+ name: "Johnson & Johnson".to_string(),
+ sector: "Health Care".to_string(),
+ industry: "Pharmaceuticals".to_string(),
+ metrics: HashMap::from([
+ ("peRatio".to_string(), 14.2),
+ ("pbRatio".to_string(), 5.1),
+ ("psRatio".to_string(), 4.2),
+ ("roe".to_string(), 23.4),
+ ("roa".to_string(), 9.8),
+ ("roic".to_string(), 15.7),
+ ("grossMargin".to_string(), 66.8),
+ ("operatingMargin".to_string(), 24.5),
+ ("netMargin".to_string(), 18.9),
+ ("revenueGrowth".to_string(), 6.3),
+ ("earningsGrowth".to_string(), 8.1),
+ ("debtToEquity".to_string(), 0.52),
+ ("marketCap".to_string(), 380_000_000_000.0),
+ ("dividendYield".to_string(), 3.1),
+ ("payoutRatio".to_string(), 44.0),
+ ("dividendGrowth".to_string(), 6.2),
+ ]),
+ },
+ StockData {
+ symbol: "KO".to_string(),
+ name: "The Coca-Cola Company".to_string(),
+ sector: "Consumer Staples".to_string(),
+ industry: "Beverages".to_string(),
+ metrics: HashMap::from([
+ ("peRatio".to_string(), 24.8),
+ ("pbRatio".to_string(), 10.2),
+ ("psRatio".to_string(), 6.1),
+ ("roe".to_string(), 39.5),
+ ("roa".to_string(), 8.7),
+ ("roic".to_string(), 14.2),
+ ("grossMargin".to_string(), 59.8),
+ ("operatingMargin".to_string(), 27.6),
+ ("netMargin".to_string(), 23.1),
+ ("revenueGrowth".to_string(), 11.2),
+ ("earningsGrowth".to_string(), 9.8),
+ ("debtToEquity".to_string(), 1.78),
+ ("marketCap".to_string(), 270_000_000_000.0),
+ ("dividendYield".to_string(), 3.0),
+ ("payoutRatio".to_string(), 73.0),
+ ("dividendGrowth".to_string(), 3.5),
+ ]),
+ },
+ StockData {
+ symbol: "NVDA".to_string(),
+ name: "NVIDIA Corporation".to_string(),
+ sector: "Information Technology".to_string(),
+ industry: "Semiconductors".to_string(),
+ metrics: HashMap::from([
+ ("peRatio".to_string(), 65.3),
+ ("pbRatio".to_string(), 52.8),
+ ("psRatio".to_string(), 38.2),
+ ("roe".to_string(), 85.2),
+ ("roa".to_string(), 48.5),
+ ("roic".to_string(), 62.7),
+ ("grossMargin".to_string(), 72.4),
+ ("operatingMargin".to_string(), 54.2),
+ ("netMargin".to_string(), 48.9),
+ ("revenueGrowth".to_string(), 126.0),
+ ("earningsGrowth".to_string(), 168.0),
+ ("debtToEquity".to_string(), 0.25),
+ ("marketCap".to_string(), 2_200_000_000_000.0),
+ ("dividendYield".to_string(), 0.03),
+ ("payoutRatio".to_string(), 1.5),
+ ]),
+ },
+ StockData {
+ symbol: "PG".to_string(),
+ name: "Procter & Gamble Co.".to_string(),
+ sector: "Consumer Staples".to_string(),
+ industry: "Household Products".to_string(),
+ metrics: HashMap::from([
+ ("peRatio".to_string(), 25.1),
+ ("pbRatio".to_string(), 7.8),
+ ("psRatio".to_string(), 4.5),
+ ("roe".to_string(), 31.2),
+ ("roa".to_string(), 9.4),
+ ("roic".to_string(), 16.8),
+ ("grossMargin".to_string(), 50.2),
+ ("operatingMargin".to_string(), 23.4),
+ ("netMargin".to_string(), 17.6),
+ ("revenueGrowth".to_string(), 5.8),
+ ("earningsGrowth".to_string(), 6.4),
+ ("debtToEquity".to_string(), 0.62),
+ ("marketCap".to_string(), 390_000_000_000.0),
+ ("dividendYield".to_string(), 2.4),
+ ("payoutRatio".to_string(), 60.0),
+ ("dividendGrowth".to_string(), 4.8),
+ ]),
+ },
+ StockData {
+ symbol: "V".to_string(),
+ name: "Visa Inc.".to_string(),
+ sector: "Information Technology".to_string(),
+ industry: "Financial Services".to_string(),
+ metrics: HashMap::from([
+ ("peRatio".to_string(), 31.2),
+ ("pbRatio".to_string(), 13.5),
+ ("psRatio".to_string(), 15.8),
+ ("roe".to_string(), 44.7),
+ ("roa".to_string(), 14.8),
+ ("roic".to_string(), 22.5),
+ ("grossMargin".to_string(), 98.5),
+ ("operatingMargin".to_string(), 67.2),
+ ("netMargin".to_string(), 51.4),
+ ("revenueGrowth".to_string(), 11.5),
+ ("earningsGrowth".to_string(), 13.2),
+ ("debtToEquity".to_string(), 0.58),
+ ("marketCap".to_string(), 530_000_000_000.0),
+ ("dividendYield".to_string(), 0.7),
+ ("payoutRatio".to_string(), 21.0),
+ ("dividendGrowth".to_string(), 17.5),
+ ]),
+ },
+ StockData {
+ symbol: "XOM".to_string(),
+ name: "Exxon Mobil Corporation".to_string(),
+ sector: "Energy".to_string(),
+ industry: "Oil & Gas".to_string(),
+ metrics: HashMap::from([
+ ("peRatio".to_string(), 9.8),
+ ("pbRatio".to_string(), 1.9),
+ ("psRatio".to_string(), 1.2),
+ ("roe".to_string(), 19.5),
+ ("roa".to_string(), 10.2),
+ ("roic".to_string(), 14.8),
+ ("grossMargin".to_string(), 34.2),
+ ("operatingMargin".to_string(), 15.8),
+ ("netMargin".to_string(), 10.5),
+ ("revenueGrowth".to_string(), 8.2),
+ ("earningsGrowth".to_string(), 25.4),
+ ("debtToEquity".to_string(), 0.28),
+ ("marketCap".to_string(), 420_000_000_000.0),
+ ("dividendYield".to_string(), 3.4),
+ ("payoutRatio".to_string(), 33.0),
+ ("dividendGrowth".to_string(), 2.1),
+ ]),
+ },
+ ]
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_value_screen() {
+ let service = StockScreenerService::new();
+ let criteria = StockScreenerService::get_value_screen();
+ let result = service.execute_screen(criteria);
+
+ // XOM and JNJ should match value criteria
+ assert!(result.matching_stocks.len() > 0);
+ assert!(result.matching_stocks.iter().any(|s| s.symbol == "XOM" || s.symbol == "JNJ"));
+ }
+
+ #[test]
+ fn test_growth_screen() {
+ let service = StockScreenerService::new();
+ let criteria = StockScreenerService::get_growth_screen();
+ let result = service.execute_screen(criteria);
+
+ // NVDA should match growth criteria
+ assert!(result.matching_stocks.len() > 0);
+ assert!(result.matching_stocks.iter().any(|s| s.symbol == "NVDA"));
+ }
+
+ #[test]
+ fn test_dividend_screen() {
+ let service = StockScreenerService::new();
+ let criteria = StockScreenerService::get_dividend_screen();
+ let result = service.execute_screen(criteria);
+
+ // JNJ, XOM should match dividend criteria
+ assert!(result.matching_stocks.len() > 0);
+ }
+
+ #[test]
+ fn test_custom_filter() {
+ let service = StockScreenerService::new();
+ let criteria = ScreenCriteria {
+ name: "Custom Test".to_string(),
+ description: "Test".to_string(),
+ conditions: vec![
+ FilterCondition {
+ metric: MetricType::PeRatio,
+ operator: FilterOperator::LessThan,
+ value: FilterValue::Single(20.0),
+ },
+ ],
+ sector_filter: None,
+ industry_filter: None,
+ };
+ let result = service.execute_screen(criteria);
+
+ // Should find stocks with P/E < 20
+ assert!(result.matching_stocks.len() > 0);
+ for stock in &result.matching_stocks {
+ let pe = stock.metrics.get("peRatio").unwrap();
+ assert!(*pe < 20.0);
+ }
+ }
+}
diff --git a/fincept-terminal-desktop/src/components/tabs/EquityResearchTab.tsx b/fincept-terminal-desktop/src/components/tabs/EquityResearchTab.tsx
index f9eaf6732..a113659fd 100644
--- a/fincept-terminal-desktop/src/components/tabs/EquityResearchTab.tsx
+++ b/fincept-terminal-desktop/src/components/tabs/EquityResearchTab.tsx
@@ -4,6 +4,8 @@ import { invoke } from '@tauri-apps/api/core';
import { createChart, CandlestickSeries, HistogramSeries, LineSeries, BarSeries } from 'lightweight-charts';
import { LineChart, Line, XAxis, YAxis, CartesianGrid, Tooltip, ResponsiveContainer, ComposedChart, Bar, Area } from 'recharts';
import { ProChartWithToolkit } from './trading/charts/ProChartWithToolkit';
+import { FinancialAnalysisPanel } from './equity-research/components/FinancialAnalysisPanel';
+import { PeerComparisonPanel } from './equity-research/components/PeerComparisonPanel';
import { TabFooter } from '@/components/common/TabFooter';
import { useTranslation } from 'react-i18next';
@@ -743,7 +745,7 @@ const EquityResearchTab: React.FC = () => {
const [loading, setLoading] = useState(false);
const [chartPeriod, setChartPeriod] = useState<'1M' | '3M' | '6M' | '1Y' | '5Y'>('6M');
const [currentTime, setCurrentTime] = useState(new Date());
- const [activeTab, setActiveTab] = useState<'overview' | 'financials' | 'analysis' | 'technicals' | 'news'>('overview');
+ const [activeTab, setActiveTab] = useState<'overview' | 'financials' | 'analysis' | 'technicals' | 'peers' | 'news'>('overview');
const [fontSize, setFontSize] = useState(12);
const [selectedMetrics, setSelectedMetrics] = useState<string[]>(['Total Revenue', 'Gross Profit', 'Operating Income', 'Net Income', 'EBITDA', 'Basic EPS', 'Diluted EPS']);
const [showYearsCount, setShowYearsCount] = useState(4);
@@ -1433,7 +1435,7 @@ const EquityResearchTab: React.FC = () => {
display: 'flex',
gap: '1px',
}}>
- {(['overview', 'financials', 'analysis', 'technicals', 'news'] as const).map((tab) => (
+ {(['overview', 'financials', 'analysis', 'technicals', 'peers', 'news'] as const).map((tab) => (
<button
key={tab}
onClick={() => setActiveTab(tab)}
@@ -2291,6 +2293,13 @@ const EquityResearchTab: React.FC = () => {
{/* Analysis Tab */}
{activeTab === 'analysis' && (
<div style={{ padding: '0 8px 8px 8px' }}>
+ {/* Financial Analysis Panel - CFA-Compliant Analysis */}
+ <div style={{ marginBottom: '8px' }}>
+ <FinancialAnalysisPanel
+ ticker={currentSymbol}
+ companyName={stockInfo?.company_name || currentSymbol}
+ />
+ </div>
<div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '8px' }}>
{/* Financial Health */}
<div style={{
@@ -2621,6 +2630,13 @@ const EquityResearchTab: React.FC = () => {
</div>
)}
+ {/* Peers Tab */}
+ {activeTab === 'peers' && (
+ <div style={{ padding: '8px' }}>
+ <PeerComparisonPanel initialSymbol={currentSymbol} />
+ </div>
+ )}
+
{/* Technicals Tab */}
{activeTab === 'technicals' && (
<div style={{ padding: '8px' }}>
diff --git a/fincept-terminal-desktop/src/components/tabs/equity-research/EquityResearchWithPeers.tsx b/fincept-terminal-desktop/src/components/tabs/equity-research/EquityResearchWithPeers.tsx
new file mode 100644
index 000000000..5b22c4a9b
--- /dev/null
+++ b/fincept-terminal-desktop/src/components/tabs/equity-research/EquityResearchWithPeers.tsx
@@ -0,0 +1,314 @@
+// Equity Research with Peer Comparison - Complete Integration
+// Combines all peer analysis components into a comprehensive research tool
+
+import React, { useState } from 'react';
+import { PeerComparisonPanel } from './components/PeerComparisonPanel';
+import { SectorHeatmap, SectorPerformance } from './components/SectorHeatmap';
+import { PercentileRankChart, PercentileTable } from './components/PercentileRankChart';
+import { StockScreenerPanel } from './components/StockScreenerPanel';
+import { usePeerComparison } from '../../../hooks/usePeerComparison';
+
+interface EquityResearchWithPeersProps {
+ symbol: string;
+}
+
+type TabView = 'overview' | 'peers' | 'rankings' | 'sectors' | 'screener';
+
+export const EquityResearchWithPeers: React.FC<EquityResearchWithPeersProps> = ({ symbol }) => {
+ const [activeTab, setActiveTab] = useState<TabView>('overview');
+ const [searchSymbol, setSearchSymbol] = useState(symbol);
+
+ const {
+ targetSymbol,
+ selectedPeers,
+ availablePeers,
+ comparisonData,
+ loading,
+ error,
+ setTargetSymbol,
+ fetchPeers,
+ runComparison,
+ } = usePeerComparison(symbol);
+
+ const handleSearch = () => {
+ if (searchSymbol) {
+ setTargetSymbol(searchSymbol);
+ }
+ };
+
+ const tabs = [
+ { id: 'overview' as TabView, label: 'Overview', icon: '📊' },
+ { id: 'peers' as TabView, label: 'Peer Comparison', icon: '👥' },
+ { id: 'rankings' as TabView, label: 'Percentile Rankings', icon: '📈' },
+ { id: 'sectors' as TabView, label: 'Sector Analysis', icon: '🗺️' },
+ { id: 'screener' as TabView, label: 'Stock Screener', icon: '🔍' },
+ ];
+
+ // Extract percentile rankings from comparison data
+ const percentileRankings = comparisonData?.percentileRanks
+ ? Object.values(comparisonData.percentileRanks)
+ : [];
+
+ return (
+ <div className="min-h-screen bg-gray-950 p-6">
+ <div className="max-w-7xl mx-auto space-y-6">
+ {/* Header */}
+ <div className="bg-gradient-to-r from-blue-600 to-purple-600 rounded-lg p-6 shadow-xl">
+ <h1 className="text-3xl font-bold text-white mb-2">
+ Equity Research & Peer Analysis
+ </h1>
+ <p className="text-blue-100">
+ CFA Institute-compliant peer comparison and benchmarking
+ </p>
+ </div>
+
+ {/* Search Bar */}
+ <div className="bg-gray-900 rounded-lg p-4 border border-gray-700">
+ <div className="flex gap-3">
+ <input
+ type="text"
+ value={searchSymbol}
+ onChange={(e) => setSearchSymbol(e.target.value.toUpperCase())}
+ onKeyPress={(e) => e.key === 'Enter' && handleSearch()}
+ placeholder="Enter stock symbol (e.g., AAPL, MSFT)"
+ className="flex-1 px-4 py-2 bg-gray-800 border border-gray-700 rounded-lg text-white placeholder-gray-500 focus:outline-none focus:ring-2 focus:ring-blue-500"
+ />
+ <button
+ onClick={handleSearch}
+ disabled={loading}
+ className="px-6 py-2 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-700 text-white rounded-lg transition-colors font-medium"
+ >
+ {loading ? 'Searching...' : 'Search'}
+ </button>
+ </div>
+ </div>
+
+ {/* Tab Navigation */}
+ <div className="bg-gray-900 rounded-lg border border-gray-700 overflow-hidden">
+ <div className="flex border-b border-gray-700">
+ {tabs.map((tab) => (
+ <button
+ key={tab.id}
+ onClick={() => setActiveTab(tab.id)}
+ className={`flex-1 px-6 py-4 font-medium transition-colors ${
+ activeTab === tab.id
+ ? 'bg-blue-600 text-white'
+ : 'text-gray-400 hover:text-gray-300 hover:bg-gray-800'
+ }`}
+ >
+ <span className="mr-2">{tab.icon}</span>
+ {tab.label}
+ </button>
+ ))}
+ </div>
+
+ <div className="p-6">
+ {/* Overview Tab */}
+ {activeTab === 'overview' && (
+ <div className="space-y-6">
+ <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+ {/* Company Info Card */}
+ <div className="bg-gray-800 rounded-lg p-6 border border-gray-700">
+ <h3 className="text-xl font-semibold text-white mb-4">
+ {targetSymbol || 'Select a Symbol'}
+ </h3>
+ {comparisonData?.target && (
+ <div className="space-y-3">
+ <div className="flex justify-between">
+ <span className="text-gray-400">P/E Ratio:</span>
+ <span className="text-white font-semibold">
+ {comparisonData.target.valuation.peRatio?.toFixed(2) || 'N/A'}
+ </span>
+ </div>
+ <div className="flex justify-between">
+ <span className="text-gray-400">ROE:</span>
+ <span className="text-white font-semibold">
+ {comparisonData.target.profitability.roe
+ ? `${(comparisonData.target.profitability.roe * 100).toFixed(2)}%`
+ : 'N/A'}
+ </span>
+ </div>
+ <div className="flex justify-between">
+ <span className="text-gray-400">Revenue Growth:</span>
+ <span className="text-white font-semibold">
+ {comparisonData.target.growth.revenueGrowth
+ ? `${(comparisonData.target.growth.revenueGrowth * 100).toFixed(2)}%`
+ : 'N/A'}
+ </span>
+ </div>
+ </div>
+ )}
+ </div>
+
+ {/* Quick Stats */}
+ <div className="bg-gray-800 rounded-lg p-6 border border-gray-700">
+ <h3 className="text-xl font-semibold text-white mb-4">Peer Summary</h3>
+ <div className="space-y-3">
+ <div className="flex justify-between">
+ <span className="text-gray-400">Available Peers:</span>
+ <span className="text-white font-semibold">{availablePeers.length}</span>
+ </div>
+ <div className="flex justify-between">
+ <span className="text-gray-400">Selected Peers:</span>
+ <span className="text-white font-semibold">{selectedPeers.length}</span>
+ </div>
+ <div className="flex justify-between">
+ <span className="text-gray-400">Avg Similarity:</span>
+ <span className="text-white font-semibold">
+ {selectedPeers.length > 0
+ ? `${(
+ (selectedPeers.reduce((sum, p) => sum + p.similarityScore, 0) /
+ selectedPeers.length) *
+ 100
+ ).toFixed(1)}%`
+ : 'N/A'}
+ </span>
+ </div>
+ </div>
+ </div>
+ </div>
+
+ {/* Valuation Status */}
+ {comparisonData?.summary && (
+ <div className="bg-gray-800 rounded-lg p-6 border border-gray-700">
+ <h3 className="text-xl font-semibold text-white mb-4">Overall Rating</h3>
+ <div className="grid grid-cols-1 md:grid-cols-4 gap-4">
+ <ScoreCard
+ title="Valuation"
+ score={comparisonData.summary.valuationScore}
+ maxScore={2}
+ />
+ <ScoreCard
+ title="Profitability"
+ score={comparisonData.summary.profitabilityScore}
+ maxScore={2}
+ />
+ <ScoreCard
+ title="Growth"
+ score={comparisonData.summary.growthScore}
+ maxScore={2}
+ />
+ <ScoreCard
+ title="Overall"
+ score={comparisonData.summary.overallRating}
+ maxScore={6}
+ />
+ </div>
+ </div>
+ )}
+ </div>
+ )}
+
+ {/* Peer Comparison Tab */}
+ {activeTab === 'peers' && <PeerComparisonPanel initialSymbol={targetSymbol} />}
+
+ {/* Percentile Rankings Tab */}
+ {activeTab === 'rankings' && (
+ <div className="space-y-6">
+ {percentileRankings.length > 0 ? (
+ <>
+ <PercentileRankChart rankings={percentileRankings} orientation="horizontal" />
+ <PercentileTable rankings={percentileRankings} />
+ </>
+ ) : (
+ <div className="bg-gray-800 rounded-lg p-8 text-center border border-gray-700">
+ <p className="text-gray-400">
+ Run a peer comparison to see percentile rankings
+ </p>
+ <button
+ onClick={() => setActiveTab('peers')}
+ className="mt-4 px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white rounded-lg transition-colors"
+ >
+ Go to Peer Comparison
+ </button>
+ </div>
+ )}
+ </div>
+ )}
+
+ {/* Sector Analysis Tab */}
+ {activeTab === 'sectors' && (
+ <div className="space-y-6">
+ {availablePeers.length > 0 ? (
+ <>
+ <SectorHeatmap peers={availablePeers} />
+ {comparisonData?.benchmarks && (
+ <SectorPerformance
+ sector={comparisonData.benchmarks.sector}
+ metrics={{
+ avgPE: comparisonData.benchmarks.medianPe,
+ avgROE: comparisonData.benchmarks.medianRoe,
+ avgGrowth: comparisonData.benchmarks.medianRevenueGrowth,
+ }}
+ />
+ )}
+ </>
+ ) : (
+ <div className="bg-gray-800 rounded-lg p-8 text-center border border-gray-700">
+ <p className="text-gray-400">
+ Search for a symbol to see sector analysis
+ </p>
+ </div>
+ )}
+ </div>
+ )}
+
+ {/* Stock Screener Tab */}
+ {activeTab === 'screener' && (
+ <StockScreenerPanel />
+ )}
+ </div>
+ </div>
+
+ {/* Error Display */}
+ {error && (
+ <div className="bg-red-900/20 border border-red-700 rounded-lg p-4">
+ <div className="flex items-center gap-3">
+ <svg className="w-5 h-5 text-red-400" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 8v4m0 4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
+ </svg>
+ <p className="text-red-400">{error}</p>
+ </div>
+ </div>
+ )}
+ </div>
+ </div>
+ );
+};
+
+// Score Card Component
+interface ScoreCardProps {
+ title: string;
+ score: number;
+ maxScore: number;
+}
+
+const ScoreCard: React.FC<ScoreCardProps> = ({ title, score, maxScore }) => {
+ const percentage = (score / maxScore) * 100;
+ const color =
+ percentage >= 75 ? '#10b981' :
+ percentage >= 50 ? '#3b82f6' :
+ percentage >= 25 ? '#f59e0b' :
+ '#ef4444';
+
+ return (
+ <div className="bg-gray-900 rounded-lg p-4 border border-gray-700">
+ <h4 className="text-sm text-gray-400 mb-2">{title}</h4>
+ <div className="flex items-baseline gap-2">
+ <span className="text-2xl font-bold text-white">{score}</span>
+ <span className="text-sm text-gray-500">/ {maxScore}</span>
+ </div>
+ <div className="mt-2 w-full bg-gray-700 rounded-full h-2">
+ <div
+ className="h-2 rounded-full transition-all duration-300"
+ style={{
+ width: `${percentage}%`,
+ backgroundColor: color,
+ }}
+ />
+ </div>
+ </div>
+ );
+};
+
+export default EquityResearchWithPeers;
diff --git a/fincept-terminal-desktop/src/components/tabs/equity-research/components/FinancialAnalysisPanel.tsx b/fincept-terminal-desktop/src/components/tabs/equity-research/components/FinancialAnalysisPanel.tsx
new file mode 100644
index 000000000..15592c5d7
--- /dev/null
+++ b/fincept-terminal-desktop/src/components/tabs/equity-research/components/FinancialAnalysisPanel.tsx
@@ -0,0 +1,77 @@
+// Financial Analysis Panel
+import React, { useState, useCallback } from 'react';
+import { invoke } from '@tauri-apps/api/core';
+import { AlertCircle, CheckCircle, BarChart3, DollarSign, PieChart, Activity, FileText, ChevronDown, ChevronUp, Loader2 } from 'lucide-react';
+
+interface FinancialsInput { revenue?: number; net_income?: number; total_assets?: number; operating_cash_flow?: number; }
+interface FinancialDataInput { company: { ticker: string; name: string; sector?: string; country?: string }; period: { period_end: string; fiscal_year: number }; financials: FinancialsInput; }
+interface AnalysisResult { success: boolean; metrics?: Record<string, any>; summary?: string; error?: string; results?: any[]; }
+type AnalysisType = 'income' | 'balance' | 'cashflow' | 'comprehensive' | 'metrics';
+
+const ANALYSIS_TYPES = [
+ { type: 'income' as AnalysisType, label: 'Income', icon: <DollarSign className="w-4 h-4" /> },
+ { type: 'balance' as AnalysisType, label: 'Balance', icon: <PieChart className="w-4 h-4" /> },
+ { type: 'cashflow' as AnalysisType, label: 'Cash Flow', icon: <Activity className="w-4 h-4" /> },
+ { type: 'comprehensive' as AnalysisType, label: 'Full', icon: <FileText className="w-4 h-4" /> },
+ { type: 'metrics' as AnalysisType, label: 'Metrics', icon: <BarChart3 className="w-4 h-4" /> },
+];
+
+export const FinancialAnalysisPanel: React.FC<{ ticker?: string; companyName?: string; }> = ({ ticker = 'AAPL', companyName = 'Apple Inc.' }) => {
+ const [selected, setSelected] = useState<AnalysisType>('comprehensive');
+ const [loading, setLoading] = useState(false);
+ const [result, setResult] = useState<AnalysisResult | null>(null);
+ const [expanded, setExpanded] = useState(true);
+
+ const run = useCallback(async () => {
+ setLoading(true);
+ try {
+ const cmds: Record<AnalysisType, string> = { income: 'analyze_income_statement', balance: 'analyze_balance_sheet', cashflow: 'analyze_cash_flow', comprehensive: 'analyze_financial_statements', metrics: 'get_financial_key_metrics' };
+ const res = await invoke<string>(cmds[selected], { data: { company: { ticker, name: companyName }, period: { period_end: new Date().toISOString().split('T')[0], fiscal_year: new Date().getFullYear() }, financials: {} } });
+ const p = JSON.parse(res);
+ setResult({ success: p.success !== false, summary: p.summary || p.error, results: p.results, metrics: p.metrics, error: p.error });
+ } catch (e) { setResult({ success: false, error: e instanceof Error ? e.message : 'Failed' }); }
+ finally { setLoading(false); }
+ }, [selected, ticker, companyName]);
+
+ return (
+ <div className="bg-gray-900 rounded-xl border border-gray-700/50 overflow-hidden">
+ <div className="flex items-center justify-between p-4 bg-gray-800/50 cursor-pointer" onClick={() => setExpanded(!expanded)}>
+ <div className="flex items-center gap-3"><BarChart3 className="w5 h-5 text-blue-400" /><h3 className="font-semibold text-white">Financial Analysis</h3></div>
+ {expanded ? <ChevronUp className="w-5 h-5 text-gray-400" /> : <ChevronDown className="w5 h-5 text-gray-400" />}
+ </div>
+ {expanded && (
+ <div className="p-4 space-y-4">
+ <div className="flex flex-wrap gap-2">{ANALYSIS_TYPES.map(({ type, label, icon }) => (<button key={type} onClick={() => setSelected(type)} className={selected === type ? 'flex items-center gap-2 px-3 py-2 rounded-lg text-sm bg-blue-600 text-white' : 'flex items-center gap-2 px-3 py-2 rounded-lg text-sm bg-gray-800 text-gray-300'}>{icon}<span>{label}</span></button>))}</div>
+ <button onClick={run} disabled={loading} className="w-full py-3 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-700 text-white rounded-lg flex items-center justify-center gap-2">{loading ? <><Loader2 className="w-5 h-5 animate-spin" />Analyzing...</> : <><BarChart3 className="w-5 h-5" />Run Analysis</>}</button>
+ {result && (
+ <div className={result.success ? "p-4 bg-green-900/20 border border-green-700/30 rounded-lg" : "p-4 bg-red-900/20 border border-red-700/30 rounded-lg"}>
+ <div className="flex items-center gap-2 mb-2">
+ {result.success ? <CheckCircle className="w-5 h-5 text-green-400" /> : <AlertCircle className="w-5 h-5 text-red-400" />}
+ <span className={result.success ? "text-green-400 font-bold" : "text-red-400 font-bold"}>
+ {result.success ? 'Analysis Complete' : 'Analysis Failed'}
+ </span>
+ </div>
+ {result.summary && <div className="text-gray-300 text-sm mb-2">{result.summary}</div>}
+ {result.error && !result.success && <div className="text-red-400 text-sm">{result.error}</div>}
+ {result.results && result.results.length > 0 && (
+ <div className="mt-2 max-h-40 overflow-y-auto">
+ <div className="text-gray-500 text-xs mb-1">{result.results.length} metrics analyzed</div>
+ {result.results.slice(0,5).map((r: any, i: number) => (
+ <div key={i} className="flex justify-between text-xs py-1 border-b border-gray-700">
+ <span className="text-cyan-400">{r.metric_name}</span>
+ <span className={r.risk_level === 'low' ? 'text-green-400' : r.risk_level === 'high' ? 'text-red-400' : 'text-yellow-400'}>
+ {typeof r.value === 'number' ? r.value.toFixed(4) : r.value}
+ </span>
+ </div>
+ ))}
+ </div>
+ )}
+ </div>
+ )}
+ </div>
+ )}
+ </div>
+ );
+};
+
+export default FinancialAnalysisPanel;
\ No newline at end of file
diff --git a/fincept-terminal-desktop/src/components/tabs/equity-research/components/PeerComparisonPanel.tsx b/fincept-terminal-desktop/src/components/tabs/equity-research/components/PeerComparisonPanel.tsx
new file mode 100644
index 000000000..86b6b7785
--- /dev/null
+++ b/fincept-terminal-desktop/src/components/tabs/equity-research/components/PeerComparisonPanel.tsx
@@ -0,0 +1,705 @@
+// Peer Comparison Panel Component
+// Main UI for peer analysis and comparison
+
+import React, { useState } from 'react';
+import { RadarChart, PolarGrid, PolarAngleAxis, PolarRadiusAxis, Radar, Legend, ResponsiveContainer, Tooltip, ComposedChart, Bar, XAxis, YAxis, CartesianGrid } from 'recharts';
+import type { PeerCompany, CompanyMetrics, ViewMode } from '../../../../types/peer';
+import { formatMetricValue, getMetricValue, getAllMetricNames } from '../../../../types/peer';
+import { usePeerComparison } from '../../../../hooks/usePeerComparison';
+import { PercentileRankMini } from './PercentileRankChart';
+
+interface PeerComparisonPanelProps {
+ initialSymbol?: string;
+}
+
+export const PeerComparisonPanel: React.FC<PeerComparisonPanelProps> = ({ initialSymbol }) => {
+ const {
+ targetSymbol,
+ selectedPeers,
+ availablePeers,
+ comparisonData,
+ loading,
+ error,
+ setTargetSymbol,
+ addPeer,
+ removePeer,
+ runComparison,
+ } = usePeerComparison(initialSymbol);
+
+ const [viewMode, setViewMode] = useState<ViewMode>('table');
+ const [selectedMetrics, setSelectedMetrics] = useState<string[]>([
+ 'P/E Ratio',
+ 'ROE',
+ 'Revenue Growth',
+ 'Debt/Equity',
+ ]);
+ const [manualPeerSymbol, setManualPeerSymbol] = useState('');
+
+ const handleAddManualPeer = () => {
+ if (!manualPeerSymbol.trim()) return;
+
+ // Create a peer object with the symbol
+ const newPeer: PeerCompany = {
+ symbol: manualPeerSymbol.toUpperCase(),
+ name: manualPeerSymbol.toUpperCase(), // Will be updated when data is fetched
+ sector: '',
+ industry: '',
+ marketCap: 0,
+ marketCapCategory: 'Large Cap',
+ similarityScore: 1.0, // Manually added peers are assumed to be good matches
+ matchDetails: {
+ sectorMatch: true,
+ industryMatch: true,
+ marketCapSimilarity: 1.0,
+ geographicMatch: true,
+ },
+ };
+
+ addPeer(newPeer);
+ setManualPeerSymbol('');
+ };
+
+ const handleRunComparison = () => {
+ runComparison();
+ };
+
+ const toggleMetric = (metric: string) => {
+ setSelectedMetrics((prev) =>
+ prev.includes(metric) ? prev.filter((m) => m !== metric) : [...prev, metric]
+ );
+ };
+
+ const handleExportToCSV = () => {
+ if (!comparisonData) return;
+
+ // Prepare CSV data
+ const headers = ['Metric', comparisonData.target.symbol, ...comparisonData.peers.map(p => p.symbol)];
+ const rows: string[][] = [];
+
+ // Add all metrics
+ const allMetrics = getAllMetricNames(comparisonData.target);
+ allMetrics.forEach(metric => {
+ const targetVal = getMetricValue(comparisonData.target, metric);
+ const peerVals = comparisonData.peers.map(p => getMetricValue(p, metric));
+ const row = [
+ metric,
+ targetVal !== undefined ? targetVal.toString() : 'N/A',
+ ...peerVals.map(v => v !== undefined ? v.toString() : 'N/A')
+ ];
+ rows.push(row);
+ });
+
+ // Convert to CSV string
+ const csvContent = [
+ headers.join(','),
+ ...rows.map(row => row.join(','))
+ ].join('\n');
+
+ // Create download
+ const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+ const link = document.createElement('a');
+ const url = URL.createObjectURL(blob);
+ link.setAttribute('href', url);
+ link.setAttribute('download', `peer_comparison_${comparisonData.target.symbol}_${new Date().toISOString().split('T')[0]}.csv`);
+ link.style.visibility = 'hidden';
+ document.body.appendChild(link);
+ link.click();
+ document.body.removeChild(link);
+ };
+
+ // Prepare radar chart data with normalized values
+ const radarData = React.useMemo(() => {
+ if (!comparisonData) return [];
+
+ return selectedMetrics.map((metric) => {
+ const data: any = { metric };
+
+ // Collect all values for this metric
+ const targetValue = getMetricValue(comparisonData.target, metric) || 0;
+ const peerValues = comparisonData.peers.map((peer, index) => ({
+ index,
+ value: getMetricValue(peer, metric) || 0,
+ }));
+
+ // Find min and max for normalization
+ const allValues = [targetValue, ...peerValues.map(p => p.value)];
+ const minVal = Math.min(...allValues);
+ const maxVal = Math.max(...allValues);
+ const range = maxVal - minVal;
+
+ // Normalize to 0-100 scale (avoid division by zero)
+ const normalize = (val: number) => {
+ if (range === 0) return 50; // All values the same
+ return ((val - minVal) / range) * 100;
+ };
+
+ data.target = normalize(targetValue);
+ peerValues.forEach(({ index, value }) => {
+ data[`peer${index + 1}`] = normalize(value);
+ });
+
+ // Store original values for tooltip
+ data.targetOriginal = targetValue;
+ peerValues.forEach(({ index, value }) => {
+ data[`peer${index + 1}Original`] = value;
+ });
+
+ return data;
+ });
+ }, [comparisonData, selectedMetrics]);
+
+ return (
+ <div className="space-y-6">
+ {/* Header */}
+ <div className="flex justify-between items-center">
+ <div className="flex-1">
+ <h2 className="text-2xl font-bold text-white mb-3">Peer Comparison</h2>
+
+ {/* Target Symbol Input */}
+ <div className="flex gap-2 max-w-md">
+ <div className="flex-1">
+ <label className="text-xs text-gray-400 mb-1 block">Target Company Symbol</label>
+ <input
+ type="text"
+ value={targetSymbol}
+ onChange={(e) => setTargetSymbol(e.target.value.toUpperCase())}
+ placeholder="Enter symbol (e.g., AAPL, GOOGL)"
+ className="w-full px-3 py-2 bg-gray-800 border border-gray-700 rounded-lg text-white placeholder-gray-500 focus:outline-none focus:ring-2 focus:ring-blue-500 text-sm"
+ />
+ </div>
+ </div>
+ <p className="text-gray-400 text-xs mt-2">
+ Select target company and add peer companies to compare
+ </p>
+ </div>
+
+ <div className="flex gap-2">
+ {comparisonData && (
+ <button
+ onClick={handleExportToCSV}
+ className="px-4 py-2 bg-gray-700 hover:bg-gray-600 text-white rounded-lg transition-colors font-medium flex items-center gap-2"
+ >
+ <svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 10v6m0 0l-3-3m3 3l3-3m2 8H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+ </svg>
+ Export CSV
+ </button>
+ )}
+ <button
+ onClick={handleRunComparison}
+ disabled={loading || !targetSymbol || selectedPeers.length === 0}
+ className="px-4 py-2 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-700 disabled:cursor-not-allowed text-white rounded-lg transition-colors font-medium"
+ >
+ {loading ? 'Comparing...' : 'Run Comparison'}
+ </button>
+ </div>
+ </div>
+
+ {/* Error Display */}
+ {error && (
+ <div className="bg-red-900/20 border border-red-700 rounded-lg p-4">
+ <p className="text-red-400">{error}</p>
+ </div>
+ )}
+
+ {/* Peer Selection */}
+ <div className="bg-gray-900 rounded-lg p-4 border border-gray-700">
+ <h3 className="text-lg font-semibold text-white mb-3">Selected Peers ({selectedPeers.length})</h3>
+
+ {selectedPeers.length === 0 ? (
+ <p className="text-gray-400 text-sm">No peers selected. Add peers manually using the input below.</p>
+ ) : (
+ <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 gap-3">
+ {selectedPeers.map((peer) => (
+ <div
+ key={peer.symbol}
+ className="flex items-center justify-between p-3 bg-gray-800 rounded-lg border border-gray-700"
+ >
+ <div className="flex-1">
+ <div className="flex items-center gap-2">
+ <span className="font-semibold text-white">{peer.symbol}</span>
+ <span className="text-xs px-2 py-0.5 bg-blue-900/30 text-blue-400 rounded">
+ {(peer.similarityScore * 100).toFixed(0)}% match
+ </span>
+ </div>
+ <p className="text-xs text-gray-400 truncate">{peer.name}</p>
+ </div>
+ <button
+ onClick={() => removePeer(peer.symbol)}
+ className="ml-2 p-1 hover:bg-gray-700 rounded transition-colors"
+ >
+ <svg className="w-5 h-5 text-gray-400 hover:text-red-400" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+ </svg>
+ </button>
+ </div>
+ ))}
+ </div>
+ )}
+
+ {/* Manual Peer Input */}
+ <div className="mt-4">
+ <h4 className="text-sm font-medium text-gray-400 mb-2">Add Peer Manually</h4>
+ <div className="flex gap-2">
+ <input
+ type="text"
+ value={manualPeerSymbol}
+ onChange={(e) => setManualPeerSymbol(e.target.value.toUpperCase())}
+ onKeyPress={(e) => e.key === 'Enter' && handleAddManualPeer()}
+ placeholder="Enter peer symbol (e.g., MSFT, GOOGL)"
+ className="flex-1 px-3 py-2 bg-gray-800 border border-gray-700 rounded-lg text-white placeholder-gray-500 focus:outline-none focus:ring-2 focus:ring-blue-500 text-sm"
+ />
+ <button
+ onClick={handleAddManualPeer}
+ disabled={!manualPeerSymbol.trim()}
+ className="px-4 py-2 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-700 disabled:cursor-not-allowed text-white rounded-lg transition-colors font-medium text-sm"
+ >
+ Add Peer
+ </button>
+ </div>
+ <p className="text-xs text-gray-500 mt-1">
+ Tip: Add companies from the same industry/sector for better comparison
+ </p>
+ </div>
+
+ {/* Available Peers */}
+ {availablePeers.length > 0 && (
+ <div className="mt-4">
+ <h4 className="text-sm font-medium text-gray-400 mb-2">Available Peers</h4>
+ <div className="flex flex-wrap gap-2">
+ {availablePeers
+ .filter((peer) => !selectedPeers.find((p) => p.symbol === peer.symbol))
+ .map((peer) => (
+ <button
+ key={peer.symbol}
+ onClick={() => addPeer(peer)}
+ className="px-3 py-1 text-sm bg-gray-800 hover:bg-gray-700 border border-gray-700 text-white rounded transition-colors"
+ >
+ + {peer.symbol}
+ </button>
+ ))}
+ </div>
+ </div>
+ )}
+ </div>
+
+ {/* View Mode Selector */}
+ {comparisonData && (
+ <div className="flex gap-2 border-b border-gray-700">
+ {(['table', 'chart', 'radar'] as ViewMode[]).map((mode) => (
+ <button
+ key={mode}
+ onClick={() => setViewMode(mode)}
+ className={`px-4 py-2 font-medium transition-colors ${
+ viewMode === mode
+ ? 'text-blue-400 border-b-2 border-blue-400'
+ : 'text-gray-400 hover:text-gray-300'
+ }`}
+ >
+ {mode.charAt(0).toUpperCase() + mode.slice(1)}
+ </button>
+ ))}
+ </div>
+ )}
+
+ {/* Comparison Results */}
+ {comparisonData && (
+ <div className="space-y-4">
+ {/* Valuation Assessment */}
+ {(() => {
+ // Calculate valuation status based on percentiles
+ const peValue = comparisonData.target.valuation.peRatio;
+ const pbValue = comparisonData.target.valuation.pbRatio;
+ const psValue = comparisonData.target.valuation.psRatio;
+
+ const pePeers = comparisonData.peers.map(p => p.valuation.peRatio).filter(v => v !== undefined) as number[];
+ const pbPeers = comparisonData.peers.map(p => p.valuation.pbRatio).filter(v => v !== undefined) as number[];
+ const psPeers = comparisonData.peers.map(p => p.valuation.psRatio).filter(v => v !== undefined) as number[];
+
+ const calcPercentile = (val: number | undefined, peers: number[]) => {
+ if (val === undefined || peers.length === 0) return 50;
+ const allVals = [val, ...peers];
+ const below = allVals.filter(v => v < val).length;
+ return (below / allVals.length) * 100;
+ };
+
+ const pePercentile = calcPercentile(peValue, pePeers);
+ const pbPercentile = calcPercentile(pbValue, pbPeers);
+ const psPercentile = calcPercentile(psValue, psPeers);
+
+ // Lower percentiles = cheaper valuation = better value
+ let score = 0;
+ if (pePercentile < 33) score++;
+ else if (pePercentile > 66) score--;
+ if (pbPercentile < 33) score++;
+ else if (pbPercentile > 66) score--;
+ if (psPercentile < 33) score++;
+ else if (psPercentile > 66) score--;
+
+ const getStatus = () => {
+ if (score >= 2) return { label: 'Undervalued', color: 'green', bgColor: 'bg-green-900/30', textColor: 'text-green-400', borderColor: 'border-green-700' };
+ if (score >= 1) return { label: 'Potentially Undervalued', color: 'emerald', bgColor: 'bg-emerald-900/30', textColor: 'text-emerald-400', borderColor: 'border-emerald-700' };
+ if (score <= -2) return { label: 'Overvalued', color: 'red', bgColor: 'bg-red-900/30', textColor: 'text-red-400', borderColor: 'border-red-700' };
+ if (score <= -1) return { label: 'Potentially Overvalued', color: 'orange', bgColor: 'bg-orange-900/30', textColor: 'text-orange-400', borderColor: 'border-orange-700' };
+ return { label: 'Fairly Valued', color: 'blue', bgColor: 'bg-blue-900/30', textColor: 'text-blue-400', borderColor: 'border-blue-700' };
+ };
+
+ const status = getStatus();
+
+ return (
+ <div className={`rounded-lg p-4 border ${status.borderColor} ${status.bgColor}`}>
+ <div className="flex items-center justify-between">
+ <div>
+ <h3 className="text-lg font-semibold text-white mb-1">Valuation Assessment</h3>
+ <p className="text-sm text-gray-400">
+ Based on P/E, P/B, and P/S percentile rankings vs peers
+ </p>
+ </div>
+ <div className="text-right">
+ <span className={`inline-block px-4 py-2 rounded-lg font-semibold text-lg ${status.textColor}`}>
+ {status.label}
+ </span>
+ <p className="text-xs text-gray-400 mt-1">
+ P/E: {pePercentile.toFixed(0)}th • P/B: {pbPercentile.toFixed(0)}th • P/S: {psPercentile.toFixed(0)}th percentile
+ </p>
+ </div>
+ </div>
+ </div>
+ );
+ })()}
+
+ {/* Sector Benchmarks Card */}
+ <div className="bg-gray-900 rounded-lg p-6 border border-gray-700">
+ <div className="flex items-center justify-between mb-4">
+ <h3 className="text-lg font-semibold text-white">Sector Benchmarks</h3>
+ <span className="text-xs px-2 py-1 bg-blue-900/30 text-blue-400 rounded">
+ {comparisonData.benchmarks.sector}
+ </span>
+ </div>
+ <div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-5 gap-4">
+ <div className="bg-gray-800 rounded-lg p-3">
+ <p className="text-xs text-gray-400 mb-1">Median P/E</p>
+ <p className="text-xl font-semibold text-white">
+ {comparisonData.benchmarks.medianPe?.toFixed(1) || 'N/A'}
+ </p>
+ </div>
+ <div className="bg-gray-800 rounded-lg p-3">
+ <p className="text-xs text-gray-400 mb-1">Median P/B</p>
+ <p className="text-xl font-semibold text-white">
+ {comparisonData.benchmarks.medianPb?.toFixed(1) || 'N/A'}
+ </p>
+ </div>
+ <div className="bg-gray-800 rounded-lg p-3">
+ <p className="text-xs text-gray-400 mb-1">Median ROE</p>
+ <p className="text-xl font-semibold text-white">
+ {comparisonData.benchmarks.medianRoe?.toFixed(1) || 'N/A'}%
+ </p>
+ </div>
+ <div className="bg-gray-800 rounded-lg p-3">
+ <p className="text-xs text-gray-400 mb-1">Median Revenue Growth</p>
+ <p className="text-xl font-semibold text-white">
+ {comparisonData.benchmarks.medianRevenueGrowth?.toFixed(1) || 'N/A'}%
+ </p>
+ </div>
+ <div className="bg-gray-800 rounded-lg p-3">
+ <p className="text-xs text-gray-400 mb-1">Median D/E</p>
+ <p className="text-xl font-semibold text-white">
+ {comparisonData.benchmarks.medianDebtToEquity?.toFixed(2) || 'N/A'}
+ </p>
+ </div>
+ </div>
+ </div>
+
+ {viewMode === 'table' && (
+ <ComparisonTable
+ target={comparisonData.target}
+ peers={comparisonData.peers}
+ selectedMetrics={selectedMetrics}
+ onToggleMetric={toggleMetric}
+ />
+ )}
+
+ {viewMode === 'chart' && (
+ <div className="bg-gray-900 rounded-lg p-6 border border-gray-700">
+ <div className="flex items-center justify-between mb-4">
+ <h3 className="text-lg font-semibold text-white">Metric Comparison - Bar Charts</h3>
+ <p className="text-xs text-gray-400">
+ Compare key financial metrics across all companies
+ </p>
+ </div>
+ <div className="grid grid-cols-1 lg:grid-cols-2 gap-6">
+ {selectedMetrics.map((metric) => {
+ const targetValue = getMetricValue(comparisonData.target, metric);
+ const chartData = [
+ {
+ name: comparisonData.target.symbol,
+ value: targetValue || 0,
+ fill: '#3b82f6', // Blue for target
+ },
+ ...comparisonData.peers.map((peer, index) => ({
+ name: peer.symbol,
+ value: getMetricValue(peer, metric) || 0,
+ fill: `hsl(${(index * 360) / comparisonData.peers.length}, 70%, 50%)`,
+ })),
+ ];
+
+ return (
+ <div key={metric} className="bg-gray-800 rounded-lg p-4">
+ <h4 className="text-sm font-semibold text-white mb-3">{metric}</h4>
+ <ResponsiveContainer width="100%" height={200}>
+ <ComposedChart data={chartData} layout="vertical">
+ <CartesianGrid strokeDasharray="3 3" stroke="#374151" />
+ <XAxis
+ type="number"
+ stroke="#9ca3af"
+ tick={{ fill: '#9ca3af', fontSize: 11 }}
+ />
+ <YAxis
+ type="category"
+ dataKey="name"
+ stroke="#9ca3af"
+ tick={{ fill: '#9ca3af', fontSize: 11 }}
+ width={80}
+ />
+ <Tooltip
+ contentStyle={{
+ backgroundColor: '#1f2937',
+ border: '1px solid #374151',
+ borderRadius: '8px',
+ color: '#fff',
+ }}
+ formatter={(value: any) => [value.toFixed(2), metric]}
+ />
+ <Bar dataKey="value" radius={[0, 4, 4, 0]} />
+ </ComposedChart>
+ </ResponsiveContainer>
+ </div>
+ );
+ })}
+ </div>
+ </div>
+ )}
+
+ {viewMode === 'radar' && (
+ <div className="bg-gray-900 rounded-lg p-6 border border-gray-700">
+ <div className="flex items-center justify-between mb-4">
+ <h3 className="text-lg font-semibold text-white">Metric Comparison</h3>
+ <p className="text-xs text-gray-400">
+ Values normalized 0-100 for visualization
+ </p>
+ </div>
+ <ResponsiveContainer width="100%" height={400}>
+ <RadarChart data={radarData}>
+ <PolarGrid stroke="#374151" />
+ <PolarAngleAxis
+ dataKey="metric"
+ stroke="#9ca3af"
+ tick={{ fill: '#9ca3af', fontSize: 12 }}
+ />
+ <PolarRadiusAxis
+ stroke="#9ca3af"
+ tick={{ fill: '#6b7280', fontSize: 10 }}
+ domain={[0, 100]}
+ />
+ <Radar
+ name={comparisonData.target.symbol}
+ dataKey="target"
+ stroke="#3b82f6"
+ fill="#3b82f6"
+ fillOpacity={0.3}
+ strokeWidth={2}
+ />
+ {comparisonData.peers.map((peer, index) => (
+ <Radar
+ key={peer.symbol}
+ name={peer.symbol}
+ dataKey={`peer${index + 1}`}
+ stroke={`hsl(${(index * 360) / comparisonData.peers.length}, 70%, 50%)`}
+ fill={`hsl(${(index * 360) / comparisonData.peers.length}, 70%, 50%)`}
+ fillOpacity={0.1}
+ strokeWidth={2}
+ />
+ ))}
+ <Legend wrapperStyle={{ paddingTop: '20px' }} />
+ <Tooltip
+ contentStyle={{
+ backgroundColor: '#1f2937',
+ border: '1px solid #374151',
+ borderRadius: '8px',
+ color: '#fff'
+ }}
+ formatter={(value: any, name: string, props: any) => {
+ // Show original value in tooltip
+ const originalKey = `${name}Original`;
+ const originalValue = props.payload[originalKey];
+ return [originalValue?.toFixed(2) || value.toFixed(2), name];
+ }}
+ />
+ </RadarChart>
+ </ResponsiveContainer>
+ </div>
+ )}
+
+ {/* Percentile Rankings Section */}
+ <div className="mt-6 bg-gray-900 rounded-lg p-6 border border-gray-700">
+ <div className="flex items-start justify-between mb-4">
+ <div>
+ <h3 className="text-lg font-semibold text-white mb-2">Percentile Rankings</h3>
+ <p className="text-sm text-gray-400">
+ {comparisonData.target.symbol}'s position within selected peer group
+ </p>
+ </div>
+ {comparisonData.peers.length < 5 && (
+ <div className="bg-yellow-900/20 border border-yellow-700 rounded-lg px-3 py-2 max-w-md">
+ <div className="flex items-start gap-2">
+ <svg className="w-5 h-5 text-yellow-400 flex-shrink-0 mt-0.5" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+ </svg>
+ <div className="text-xs text-yellow-400">
+ <p className="font-semibold mb-1">Limited Peer Sample</p>
+ <p>Add more peers (5-10 recommended) for statistically significant percentile rankings. With only {comparisonData.peers.length} {comparisonData.peers.length === 1 ? 'peer' : 'peers'}, percentiles will only show 0%, 50%, or 100%.</p>
+ </div>
+ </div>
+ </div>
+ )}
+ </div>
+ <div className="space-y-4">
+ {selectedMetrics.map((metric) => {
+ const targetValue = getMetricValue(comparisonData.target, metric);
+ const peerValues = comparisonData.peers.map((p) => getMetricValue(p, metric)).filter(v => v !== undefined) as number[];
+
+ if (targetValue === undefined || peerValues.length === 0) return null;
+
+ // Calculate percentile and statistics
+ const allValues = [targetValue, ...peerValues];
+ const sortedValues = [...allValues].sort((a, b) => a - b);
+ const countBelow = allValues.filter(v => v < targetValue).length;
+ const percentile = (countBelow / allValues.length) * 100;
+
+ // Calculate mean, median, and std dev
+ const mean = allValues.reduce((sum, v) => sum + v, 0) / allValues.length;
+ const median = sortedValues[Math.floor(sortedValues.length / 2)];
+ const variance = allValues.reduce((sum, v) => sum + Math.pow(v - mean, 2), 0) / allValues.length;
+ const stdDev = Math.sqrt(variance);
+ const zScore = stdDev > 0 ? (targetValue - mean) / stdDev : 0;
+
+ const ranking = {
+ metricName: metric,
+ value: targetValue,
+ percentile: percentile,
+ zScore: zScore,
+ peerMedian: median,
+ peerMean: mean,
+ peerStdDev: stdDev,
+ };
+
+ return (
+ <PercentileRankMini
+ key={metric}
+ ranking={ranking}
+ />
+ );
+ })}
+ </div>
+ </div>
+ </div>
+ )}
+ </div>
+ );
+};
+
+// Comparison Table Component
+interface ComparisonTableProps {
+ target: CompanyMetrics;
+ peers: CompanyMetrics[];
+ selectedMetrics: string[];
+ onToggleMetric: (metric: string) => void;
+}
+
+const ComparisonTable: React.FC<ComparisonTableProps> = ({
+ target,
+ peers,
+ selectedMetrics,
+ onToggleMetric,
+}) => {
+ const allMetrics = getAllMetricNames(target);
+
+ return (
+ <div className="bg-gray-900 rounded-lg border border-gray-700 overflow-hidden">
+ {/* Metric Selector */}
+ <div className="p-4 border-b border-gray-700">
+ <h4 className="text-sm font-medium text-gray-400 mb-2">Select Metrics</h4>
+ <div className="flex flex-wrap gap-2">
+ {allMetrics.map((metric) => (
+ <button
+ key={metric}
+ onClick={() => onToggleMetric(metric)}
+ className={`px-3 py-1 text-sm rounded transition-colors ${
+ selectedMetrics.includes(metric)
+ ? 'bg-blue-600 text-white'
+ : 'bg-gray-800 text-gray-400 hover:bg-gray-700'
+ }`}
+ >
+ {metric}
+ </button>
+ ))}
+ </div>
+ </div>
+
+ {/* Table */}
+ <div className="overflow-x-auto">
+ <table className="min-w-full divide-y divide-gray-700">
+ <thead className="bg-gray-800">
+ <tr>
+ <th className="px-4 py-3 text-left text-xs font-medium text-gray-400 uppercase">
+ Metric
+ </th>
+ <th className="px-4 py-3 text-right text-xs font-medium text-blue-400 uppercase">
+ {target.symbol} (Target)
+ </th>
+ {peers.map((peer) => (
+ <th
+ key={peer.symbol}
+ className="px-4 py-3 text-right text-xs font-medium text-gray-400 uppercase"
+ >
+ {peer.symbol}
+ </th>
+ ))}
+ </tr>
+ </thead>
+ <tbody className="divide-y divide-gray-800">
+ {selectedMetrics.map((metric) => {
+ const targetValue = getMetricValue(target, metric);
+ const peerValues = peers.map((p) => getMetricValue(p, metric));
+ const allValues = [targetValue, ...peerValues].filter((v) => v !== undefined) as number[];
+ const max = Math.max(...allValues);
+ const min = Math.min(...allValues);
+
+ return (
+ <tr key={metric} className="hover:bg-gray-800 transition-colors">
+ <td className="px-4 py-3 whitespace-nowrap text-sm font-medium text-white">
+ {metric}
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-right">
+ <span
+ className={`font-semibold ${
+ targetValue === max ? 'text-green-400' : targetValue === min ? 'text-red-400' : 'text-blue-400'
+ }`}
+ >
+ {formatMetricValue(targetValue, 'ratio')}
+ </span>
+ </td>
+ {peerValues.map((value, index) => (
+ <td key={index} className="px-4 py-3 whitespace-nowrap text-sm text-right text-gray-300">
+ {formatMetricValue(value, 'ratio')}
+ </td>
+ ))}
+ </tr>
+ );
+ })}
+ </tbody>
+ </table>
+ </div>
+ </div>
+ );
+};
diff --git a/fincept-terminal-desktop/src/components/tabs/equity-research/components/PercentileRankChart.tsx b/fincept-terminal-desktop/src/components/tabs/equity-research/components/PercentileRankChart.tsx
new file mode 100644
index 000000000..e8269ef72
--- /dev/null
+++ b/fincept-terminal-desktop/src/components/tabs/equity-research/components/PercentileRankChart.tsx
@@ -0,0 +1,240 @@
+// Percentile Rank Chart Component
+// Visualizes percentile rankings with bar charts
+
+import React from 'react';
+import { BarChart, Bar, XAxis, YAxis, CartesianGrid, Tooltip, Legend, ResponsiveContainer, Cell } from 'recharts';
+import type { PercentileRanking } from '../../../../types/peer';
+import { getPercentileColor } from '../../../../types/peer';
+
+interface PercentileRankChartProps {
+ rankings: PercentileRanking[];
+ orientation?: 'horizontal' | 'vertical';
+ title?: string;
+ height?: number;
+}
+
+export const PercentileRankChart: React.FC<PercentileRankChartProps> = ({
+ rankings,
+ orientation = 'horizontal',
+ title = 'Percentile Rankings',
+ height = 400,
+}) => {
+ // Prepare data for chart
+ const chartData = rankings.map((ranking) => ({
+ metric: ranking.metricName,
+ percentile: ranking.percentile,
+ value: ranking.value,
+ median: ranking.peerMedian,
+ mean: ranking.peerMean,
+ zScore: ranking.zScore,
+ }));
+
+ const CustomTooltip = ({ active, payload }: any) => {
+ if (active && payload && payload.length) {
+ const data = payload[0].payload;
+ return (
+ <div className="bg-gray-900 border border-gray-700 rounded-lg p-3 shadow-lg">
+ <p className="text-white font-semibold mb-2">{data.metric}</p>
+ <div className="space-y-1 text-sm">
+ <p className="text-blue-400">
+ Percentile: <span className="font-semibold">{data.percentile.toFixed(1)}%</span>
+ </p>
+ <p className="text-green-400">
+ Value: <span className="font-semibold">{data.value.toFixed(2)}</span>
+ </p>
+ <p className="text-yellow-400">
+ Peer Median: <span className="font-semibold">{data.median.toFixed(2)}</span>
+ </p>
+ <p className="text-purple-400">
+ Z-Score: <span className="font-semibold">{data.zScore.toFixed(2)}</span>
+ </p>
+ </div>
+ </div>
+ );
+ }
+ return null;
+ };
+
+ if (orientation === 'horizontal') {
+ return (
+ <div className="w-full">
+ {title && <h3 className="text-lg font-semibold text-white mb-4">{title}</h3>}
+ <ResponsiveContainer width="100%" height={height}>
+ <BarChart
+ data={chartData}
+ layout="vertical"
+ margin={{ top: 5, right: 30, left: 100, bottom: 5 }}
+ >
+ <CartesianGrid strokeDasharray="3 3" stroke="#374151" />
+ <XAxis type="number" domain={[0, 100]} stroke="#9ca3af" />
+ <YAxis dataKey="metric" type="category" stroke="#9ca3af" width={90} />
+ <Tooltip content={<CustomTooltip />} />
+ <Legend />
+ <Bar dataKey="percentile" name="Percentile Rank" radius={[0, 4, 4, 0]}>
+ {chartData.map((entry, index) => (
+ <Cell key={`cell-${index}`} fill={getPercentileColor(entry.percentile)} />
+ ))}
+ </Bar>
+ </BarChart>
+ </ResponsiveContainer>
+ </div>
+ );
+ }
+
+ // Vertical orientation
+ return (
+ <div className="w-full">
+ {title && <h3 className="text-lg font-semibold text-white mb-4">{title}</h3>}
+ <ResponsiveContainer width="100%" height={height}>
+ <BarChart
+ data={chartData}
+ margin={{ top: 5, right: 30, left: 20, bottom: 100 }}
+ >
+ <CartesianGrid strokeDasharray="3 3" stroke="#374151" />
+ <XAxis
+ dataKey="metric"
+ stroke="#9ca3af"
+ angle={-45}
+ textAnchor="end"
+ height={100}
+ />
+ <YAxis domain={[0, 100]} stroke="#9ca3af" />
+ <Tooltip content={<CustomTooltip />} />
+ <Legend />
+ <Bar dataKey="percentile" name="Percentile Rank" radius={[4, 4, 0, 0]}>
+ {chartData.map((entry, index) => (
+ <Cell key={`cell-${index}`} fill={getPercentileColor(entry.percentile)} />
+ ))}
+ </Bar>
+ </BarChart>
+ </ResponsiveContainer>
+ </div>
+ );
+};
+
+// Compact version for dashboard widgets
+export const PercentileRankMini: React.FC<{ ranking: PercentileRanking }> = ({ ranking }) => {
+ const color = getPercentileColor(ranking.percentile);
+ const width = `${ranking.percentile}%`;
+
+ // Determine interpretation based on metric type
+ const isValuationMetric = ranking.metricName.includes('Ratio') ||
+ ranking.metricName.includes('P/E') ||
+ ranking.metricName.includes('P/B') ||
+ ranking.metricName.includes('P/S') ||
+ ranking.metricName.includes('Debt');
+
+ // For valuation and leverage metrics, lower is better
+ // For profitability and growth metrics, higher is better
+ let interpretation = '';
+ if (ranking.percentile <= 25) {
+ interpretation = isValuationMetric ? 'Lower than peers (better value)' : 'Lower than peers';
+ } else if (ranking.percentile <= 50) {
+ interpretation = 'Below median';
+ } else if (ranking.percentile <= 75) {
+ interpretation = 'Above median';
+ } else {
+ interpretation = isValuationMetric ? 'Higher than peers (expensive)' : 'Higher than peers (good)';
+ }
+
+ return (
+ <div className="space-y-1">
+ <div className="flex justify-between items-center text-sm">
+ <span className="text-gray-400">{ranking.metricName}</span>
+ <div className="flex items-center gap-2">
+ <span className="text-white font-semibold">{ranking.percentile !== null && ranking.percentile !== undefined ? ranking.percentile.toFixed(1) : 'N/A'}%</span>
+ <span className="text-xs text-gray-500">({interpretation})</span>
+ </div>
+ </div>
+ <div className="w-full bg-gray-700 rounded-full h-2">
+ <div
+ className="h-2 rounded-full transition-all duration-300"
+ style={{ width, backgroundColor: color }}
+ />
+ </div>
+ <div className="flex justify-between text-xs text-gray-500">
+ <span>Value: {ranking.value !== null && ranking.value !== undefined ? ranking.value.toFixed(2) : 'N/A'}</span>
+ <span>Median: {ranking.peerMedian !== null && ranking.peerMedian !== undefined ? ranking.peerMedian.toFixed(2) : 'N/A'}</span>
+ </div>
+ </div>
+ );
+};
+
+// Percentile comparison table
+interface PercentileTableProps {
+ rankings: PercentileRanking[];
+}
+
+export const PercentileTable: React.FC<PercentileTableProps> = ({ rankings }) => {
+ return (
+ <div className="overflow-x-auto">
+ <table className="min-w-full divide-y divide-gray-700">
+ <thead className="bg-gray-800">
+ <tr>
+ <th className="px-4 py-3 text-left text-xs font-medium text-gray-400 uppercase tracking-wider">
+ Metric
+ </th>
+ <th className="px-4 py-3 text-right text-xs font-medium text-gray-400 uppercase tracking-wider">
+ Value
+ </th>
+ <th className="px-4 py-3 text-right text-xs font-medium text-gray-400 uppercase tracking-wider">
+ Percentile
+ </th>
+ <th className="px-4 py-3 text-right text-xs font-medium text-gray-400 uppercase tracking-wider">
+ Z-Score
+ </th>
+ <th className="px-4 py-3 text-right text-xs font-medium text-gray-400 uppercase tracking-wider">
+ Peer Median
+ </th>
+ <th className="px-4 py-3 text-right text-xs font-medium text-gray-400 uppercase tracking-wider">
+ Status
+ </th>
+ </tr>
+ </thead>
+ <tbody className="bg-gray-900 divide-y divide-gray-800">
+ {rankings.map((ranking, index) => {
+ const color = getPercentileColor(ranking.percentile);
+ const status =
+ ranking.percentile >= 75 ? 'Excellent' :
+ ranking.percentile >= 50 ? 'Above Average' :
+ ranking.percentile >= 25 ? 'Below Average' :
+ 'Poor';
+
+ return (
+ <tr key={index} className="hover:bg-gray-800 transition-colors">
+ <td className="px-4 py-3 whitespace-nowrap text-sm font-medium text-white">
+ {ranking.metricName}
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-right text-gray-300">
+ {ranking.value.toFixed(2)}
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-right">
+ <span className="font-semibold" style={{ color }}>
+ {ranking.percentile.toFixed(1)}%
+ </span>
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-right text-gray-300">
+ {ranking.zScore.toFixed(2)}
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-right text-gray-400">
+ {ranking.peerMedian.toFixed(2)}
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-right">
+ <span
+ className="px-2 py-1 rounded-full text-xs font-medium"
+ style={{
+ backgroundColor: `${color}20`,
+ color: color,
+ }}
+ >
+ {status}
+ </span>
+ </td>
+ </tr>
+ );
+ })}
+ </tbody>
+ </table>
+ </div>
+ );
+};
diff --git a/fincept-terminal-desktop/src/components/tabs/equity-research/components/SectorHeatmap.tsx b/fincept-terminal-desktop/src/components/tabs/equity-research/components/SectorHeatmap.tsx
new file mode 100644
index 000000000..3106d8859
--- /dev/null
+++ b/fincept-terminal-desktop/src/components/tabs/equity-research/components/SectorHeatmap.tsx
@@ -0,0 +1,272 @@
+// Sector Heatmap Component
+// Visualizes sector performance and peer distribution
+
+import React, { useState } from 'react';
+import { Treemap, ResponsiveContainer, Tooltip } from 'recharts';
+import type { GICSSector, PeerCompany } from '../../../../types/peer';
+
+interface SectorHeatmapProps {
+ peers: PeerCompany[];
+ selectedSector?: GICSSector;
+ onSectorClick?: (sector: string) => void;
+}
+
+interface SectorData {
+ name: string;
+ value: number;
+ count: number;
+ avgMarketCap: number;
+ avgSimilarity: number;
+ color: string;
+}
+
+const SECTOR_COLORS: Record<string, string> = {
+ 'Energy': '#f59e0b',
+ 'Materials': '#8b5cf6',
+ 'Industrials': '#3b82f6',
+ 'Consumer Discretionary': '#ec4899',
+ 'Consumer Staples': '#10b981',
+ 'Health Care': '#ef4444',
+ 'Financials': '#06b6d4',
+ 'Information Technology': '#6366f1',
+ 'Communication Services': '#8b5cf6',
+ 'Utilities': '#14b8a6',
+ 'Real Estate': '#f97316',
+};
+
+export const SectorHeatmap: React.FC<SectorHeatmapProps> = ({
+ peers,
+ selectedSector,
+ onSectorClick,
+}) => {
+ const [viewMode, setViewMode] = useState<'treemap' | 'grid'>('treemap');
+
+ // Aggregate data by sector
+ const sectorData: SectorData[] = React.useMemo(() => {
+ const sectorMap = new Map<string, { count: number; totalMarketCap: number; totalSimilarity: number }>();
+
+ peers.forEach((peer) => {
+ const existing = sectorMap.get(peer.sector) || { count: 0, totalMarketCap: 0, totalSimilarity: 0 };
+ sectorMap.set(peer.sector, {
+ count: existing.count + 1,
+ totalMarketCap: existing.totalMarketCap + peer.marketCap,
+ totalSimilarity: existing.totalSimilarity + peer.similarityScore,
+ });
+ });
+
+ return Array.from(sectorMap.entries()).map(([sector, data]) => ({
+ name: sector,
+ value: data.totalMarketCap,
+ count: data.count,
+ avgMarketCap: data.totalMarketCap / data.count,
+ avgSimilarity: data.totalSimilarity / data.count,
+ color: SECTOR_COLORS[sector] || '#6b7280',
+ }));
+ }, [peers]);
+
+ const CustomTooltip = ({ active, payload }: any) => {
+ if (active && payload && payload.length) {
+ const data = payload[0].payload as SectorData;
+ return (
+ <div className="bg-gray-900 border border-gray-700 rounded-lg p-3 shadow-lg">
+ <p className="text-white font-semibold mb-2">{data.name}</p>
+ <div className="space-y-1 text-sm">
+ <p className="text-blue-400">
+ Companies: <span className="font-semibold">{data.count}</span>
+ </p>
+ <p className="text-green-400">
+ Avg Market Cap: <span className="font-semibold">
+ ${(data.avgMarketCap / 1e9).toFixed(2)}B
+ </span>
+ </p>
+ <p className="text-purple-400">
+ Avg Similarity: <span className="font-semibold">
+ {(data.avgSimilarity * 100).toFixed(1)}%
+ </span>
+ </p>
+ </div>
+ </div>
+ );
+ }
+ return null;
+ };
+
+ const CustomContent = (props: any) => {
+ const { x, y, width, height, name, value, count, color } = props;
+
+ if (width < 50 || height < 30) return null;
+
+ return (
+ <g>
+ <rect
+ x={x}
+ y={y}
+ width={width}
+ height={height}
+ fill={color}
+ fillOpacity={0.8}
+ stroke="#1f2937"
+ strokeWidth={2}
+ className="cursor-pointer hover:fill-opacity-100 transition-all"
+ onClick={() => onSectorClick?.(name)}
+ />
+ <text
+ x={x + width / 2}
+ y={y + height / 2 - 10}
+ textAnchor="middle"
+ fill="#fff"
+ fontSize={14}
+ fontWeight="bold"
+ >
+ {name}
+ </text>
+ <text
+ x={x + width / 2}
+ y={y + height / 2 + 10}
+ textAnchor="middle"
+ fill="#fff"
+ fontSize={12}
+ >
+ {count} {count === 1 ? 'company' : 'companies'}
+ </text>
+ </g>
+ );
+ };
+
+ if (viewMode === 'grid') {
+ return (
+ <div className="space-y-4">
+ <div className="flex justify-between items-center">
+ <h3 className="text-lg font-semibold text-white">Sector Distribution</h3>
+ <button
+ onClick={() => setViewMode('treemap')}
+ className="px-3 py-1 text-sm bg-gray-700 hover:bg-gray-600 text-white rounded transition-colors"
+ >
+ Switch to Treemap
+ </button>
+ </div>
+
+ <div className="grid grid-cols-2 md:grid-cols-3 lg:grid-cols-4 gap-4">
+ {sectorData.map((sector) => (
+ <div
+ key={sector.name}
+ className={`p-4 rounded-lg border-2 transition-all cursor-pointer ${
+ selectedSector === sector.name
+ ? 'border-blue-500 bg-gray-800'
+ : 'border-gray-700 bg-gray-900 hover:border-gray-600'
+ }`}
+ onClick={() => onSectorClick?.(sector.name)}
+ style={{
+ borderLeftWidth: '4px',
+ borderLeftColor: sector.color,
+ }}
+ >
+ <h4 className="text-white font-semibold text-sm mb-2 truncate">{sector.name}</h4>
+ <div className="space-y-1 text-xs">
+ <div className="flex justify-between text-gray-400">
+ <span>Companies:</span>
+ <span className="font-semibold text-white">{sector.count}</span>
+ </div>
+ <div className="flex justify-between text-gray-400">
+ <span>Avg Cap:</span>
+ <span className="font-semibold text-white">
+ ${(sector.avgMarketCap / 1e9).toFixed(1)}B
+ </span>
+ </div>
+ <div className="flex justify-between text-gray-400">
+ <span>Similarity:</span>
+ <span className="font-semibold" style={{ color: sector.color }}>
+ {(sector.avgSimilarity * 100).toFixed(0)}%
+ </span>
+ </div>
+ </div>
+ </div>
+ ))}
+ </div>
+ </div>
+ );
+ }
+
+ // Treemap view
+ return (
+ <div className="space-y-4">
+ <div className="flex justify-between items-center">
+ <h3 className="text-lg font-semibold text-white">Sector Heatmap</h3>
+ <button
+ onClick={() => setViewMode('grid')}
+ className="px-3 py-1 text-sm bg-gray-700 hover:bg-gray-600 text-white rounded transition-colors"
+ >
+ Switch to Grid
+ </button>
+ </div>
+
+ <ResponsiveContainer width="100%" height={400}>
+ <Treemap
+ data={sectorData}
+ dataKey="value"
+ stroke="#1f2937"
+ fill="#8884d8"
+ content={<CustomContent />}
+ >
+ <Tooltip content={<CustomTooltip />} />
+ </Treemap>
+ </ResponsiveContainer>
+
+ <div className="flex flex-wrap gap-3 justify-center">
+ {sectorData.map((sector) => (
+ <div key={sector.name} className="flex items-center gap-2">
+ <div
+ className="w-4 h-4 rounded"
+ style={{ backgroundColor: sector.color }}
+ />
+ <span className="text-sm text-gray-400">{sector.name}</span>
+ </div>
+ ))}
+ </div>
+ </div>
+ );
+};
+
+// Sector performance indicator
+interface SectorPerformanceProps {
+ sector: string;
+ metrics: {
+ avgPE?: number;
+ avgROE?: number;
+ avgGrowth?: number;
+ };
+}
+
+export const SectorPerformance: React.FC<SectorPerformanceProps> = ({ sector, metrics }) => {
+ const color = SECTOR_COLORS[sector] || '#6b7280';
+
+ return (
+ <div className="bg-gray-900 rounded-lg p-4 border border-gray-700">
+ <div className="flex items-center gap-3 mb-3">
+ <div className="w-3 h-3 rounded-full" style={{ backgroundColor: color }} />
+ <h4 className="text-white font-semibold">{sector}</h4>
+ </div>
+
+ <div className="grid grid-cols-3 gap-4 text-sm">
+ {metrics.avgPE !== undefined && (
+ <div>
+ <p className="text-gray-400 text-xs">Avg P/E</p>
+ <p className="text-white font-semibold">{metrics.avgPE.toFixed(2)}</p>
+ </div>
+ )}
+ {metrics.avgROE !== undefined && (
+ <div>
+ <p className="text-gray-400 text-xs">Avg ROE</p>
+ <p className="text-white font-semibold">{(metrics.avgROE * 100).toFixed(1)}%</p>
+ </div>
+ )}
+ {metrics.avgGrowth !== undefined && (
+ <div>
+ <p className="text-gray-400 text-xs">Avg Growth</p>
+ <p className="text-white font-semibold">{(metrics.avgGrowth * 100).toFixed(1)}%</p>
+ </div>
+ )}
+ </div>
+ </div>
+ );
+};
diff --git a/fincept-terminal-desktop/src/components/tabs/equity-research/components/StockScreenerPanel.tsx b/fincept-terminal-desktop/src/components/tabs/equity-research/components/StockScreenerPanel.tsx
new file mode 100644
index 000000000..9d6d3741a
--- /dev/null
+++ b/fincept-terminal-desktop/src/components/tabs/equity-research/components/StockScreenerPanel.tsx
@@ -0,0 +1,679 @@
+// Stock Screener Panel Component
+// Advanced equity screening UI with filter builder and preset screens
+
+import React, { useState, useEffect } from 'react';
+import { screenerApi } from '../../../../services/screenerApi';
+import type {
+ ScreenCriteria,
+ ScreenResult,
+ FilterCondition,
+ MetricType,
+ FilterOperator,
+ FilterValue,
+ MetricInfo,
+ StockData,
+ SavedScreen,
+} from '../../../../types/screener';
+import {
+ createSingleValue,
+ createRangeValue,
+ getMetricDisplayName,
+ getOperatorDisplayName,
+} from '../../../../types/screener';
+
+type PresetScreen = 'value' | 'growth' | 'dividend' | 'momentum' | 'custom';
+
+export const StockScreenerPanel: React.FC = () => {
+ const [selectedPreset, setSelectedPreset] = useState<PresetScreen>('value');
+ const [criteria, setCriteria] = useState<ScreenCriteria | null>(null);
+ const [results, setResults] = useState<ScreenResult | null>(null);
+ const [loading, setLoading] = useState(false);
+ const [error, setError] = useState<string | null>(null);
+ const [availableMetrics, setAvailableMetrics] = useState<MetricInfo[]>([]);
+ const [savedScreens, setSavedScreens] = useState<SavedScreen[]>([]);
+ const [showSaveDialog, setShowSaveDialog] = useState(false);
+ const [newScreenName, setNewScreenName] = useState('');
+
+ // Load available metrics on mount
+ useEffect(() => {
+ loadAvailableMetrics();
+ loadSavedScreens();
+ }, []);
+
+ // Load preset when selected
+ useEffect(() => {
+ if (selectedPreset !== 'custom') {
+ loadPresetScreen(selectedPreset);
+ }
+ }, [selectedPreset]);
+
+ const loadAvailableMetrics = async () => {
+ try {
+ const metrics = await screenerApi.getAvailableMetrics();
+ setAvailableMetrics(metrics);
+ } catch (err) {
+ console.error('Failed to load metrics:', err);
+ }
+ };
+
+ const loadSavedScreens = async () => {
+ try {
+ const screens = await screenerApi.loadCustomScreens();
+ setSavedScreens(screens);
+ } catch (err) {
+ console.error('Failed to load saved screens:', err);
+ }
+ };
+
+ const loadPresetScreen = async (preset: 'value' | 'growth' | 'dividend' | 'momentum') => {
+ try {
+ let presetCriteria: ScreenCriteria;
+ switch (preset) {
+ case 'value':
+ presetCriteria = await screenerApi.getValueScreen();
+ break;
+ case 'growth':
+ presetCriteria = await screenerApi.getGrowthScreen();
+ break;
+ case 'dividend':
+ presetCriteria = await screenerApi.getDividendScreen();
+ break;
+ case 'momentum':
+ presetCriteria = await screenerApi.getMomentumScreen();
+ break;
+ }
+ setCriteria(presetCriteria);
+ setError(null);
+ } catch (err) {
+ setError(`Failed to load ${preset} screen`);
+ console.error(err);
+ }
+ };
+
+ const executeScreen = async () => {
+ if (!criteria) {
+ setError('No screening criteria defined');
+ return;
+ }
+
+ setLoading(true);
+ setError(null);
+
+ try {
+ const screenResults = await screenerApi.executeScreen(criteria);
+ setResults(screenResults);
+
+ // Show warning if using cached data
+ if ((screenResults as any).error) {
+ setError((screenResults as any).error);
+ }
+ } catch (err) {
+ setError('Failed to execute screen');
+ console.error(err);
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ const addCondition = () => {
+ if (!criteria) {
+ setCriteria({
+ name: 'Custom Screen',
+ description: 'User-defined screening criteria',
+ conditions: [],
+ });
+ } else {
+ setCriteria({
+ ...criteria,
+ conditions: [
+ ...criteria.conditions,
+ {
+ metric: 'PeRatio',
+ operator: 'LessThan',
+ value: createSingleValue(20),
+ },
+ ],
+ });
+ }
+ };
+
+ const removeCondition = (index: number) => {
+ if (!criteria) return;
+ setCriteria({
+ ...criteria,
+ conditions: criteria.conditions.filter((_, i) => i !== index),
+ });
+ };
+
+ const updateCondition = (index: number, field: keyof FilterCondition, value: any) => {
+ if (!criteria) return;
+ const newConditions = [...criteria.conditions];
+ newConditions[index] = { ...newConditions[index], [field]: value };
+ setCriteria({ ...criteria, conditions: newConditions });
+ };
+
+ const saveScreen = async () => {
+ if (!criteria || !newScreenName.trim()) return;
+
+ try {
+ const saved = await screenerApi.saveCustomScreen(newScreenName, criteria);
+ setSavedScreens([...savedScreens, saved]);
+ setShowSaveDialog(false);
+ setNewScreenName('');
+ } catch (err) {
+ console.error('Failed to save screen:', err);
+ }
+ };
+
+ const loadSavedScreen = (screen: SavedScreen) => {
+ setCriteria(screen.criteria);
+ setSelectedPreset('custom');
+ };
+
+ const exportToCSV = () => {
+ if (!results) return;
+
+ const headers = ['Symbol', 'Name', 'Sector', 'Industry', ...Object.keys(results.matchingStocks[0]?.metrics || {})];
+ const rows = results.matchingStocks.map((stock) => [
+ stock.symbol,
+ stock.name,
+ stock.sector,
+ stock.industry,
+ ...Object.values(stock.metrics),
+ ]);
+
+ const csvContent = [
+ headers.join(','),
+ ...rows.map((row) => row.join(',')),
+ ].join('\n');
+
+ const blob = new Blob([csvContent], { type: 'text/csv;charset=utf-8;' });
+ const link = document.createElement('a');
+ const url = URL.createObjectURL(blob);
+ link.setAttribute('href', url);
+ link.setAttribute('download', `screen_results_${new Date().toISOString().split('T')[0]}.csv`);
+ link.style.visibility = 'hidden';
+ document.body.appendChild(link);
+ link.click();
+ document.body.removeChild(link);
+ };
+
+ return (
+ <div className="space-y-6">
+ {/* Header */}
+ <div className="flex justify-between items-center">
+ <div>
+ <h2 className="text-2xl font-bold text-white">Stock Screener</h2>
+ <p className="text-gray-400 text-sm mt-1">
+ Filter stocks by fundamental metrics and criteria
+ </p>
+ </div>
+
+ <div className="flex gap-2">
+ {results && (
+ <button
+ onClick={exportToCSV}
+ className="px-4 py-2 bg-gray-700 hover:bg-gray-600 text-white rounded-lg transition-colors font-medium flex items-center gap-2"
+ >
+ <svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 10v6m0 0l-3-3m3 3l3-3m2 8H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+ </svg>
+ Export CSV
+ </button>
+ )}
+ <button
+ onClick={() => setShowSaveDialog(true)}
+ disabled={!criteria || selectedPreset !== 'custom'}
+ className="px-4 py-2 bg-gray-700 hover:bg-gray-600 disabled:bg-gray-800 disabled:cursor-not-allowed text-white rounded-lg transition-colors font-medium"
+ >
+ Save Screen
+ </button>
+ <button
+ onClick={executeScreen}
+ disabled={loading || !criteria || criteria.conditions.length === 0}
+ className="px-4 py-2 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-700 disabled:cursor-not-allowed text-white rounded-lg transition-colors font-medium"
+ >
+ {loading ? 'Screening...' : 'Run Screen'}
+ </button>
+ </div>
+ </div>
+
+ {/* Error Display */}
+ {error && (
+ <div className="bg-red-900/20 border border-red-700 rounded-lg p-4">
+ <div className="flex items-center gap-3">
+ <svg className="w-5 h-5 text-red-400" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+ </svg>
+ <p className="text-red-400">{error}</p>
+ </div>
+ </div>
+ )}
+
+ {/* Loading Overlay */}
+ {loading && (
+ <div className="bg-blue-900/20 border border-blue-700 rounded-lg p-6">
+ <div className="flex items-center justify-center gap-4">
+ <div className="animate-spin rounded-full h-8 w-8 border-b-2 border-blue-400"></div>
+ <div>
+ <p className="text-blue-400 font-semibold">Fetching real-time data from FMP...</p>
+ <p className="text-blue-300 text-sm mt-1">This may take 30-60 seconds for 200+ stocks</p>
+ </div>
+ </div>
+ </div>
+ )}
+
+ {/* Preset Screens */}
+ <div className="bg-gray-900 rounded-lg p-4 border border-gray-700">
+ <h3 className="text-lg font-semibold text-white mb-3">Screen Templates</h3>
+ <div className="grid grid-cols-2 md:grid-cols-5 gap-3">
+ {(['value', 'growth', 'dividend', 'momentum', 'custom'] as PresetScreen[]).map((preset) => (
+ <button
+ key={preset}
+ onClick={() => setSelectedPreset(preset)}
+ className={`p-3 rounded-lg border transition-colors ${
+ selectedPreset === preset
+ ? 'bg-blue-600 border-blue-500 text-white'
+ : 'bg-gray-800 border-gray-700 text-gray-300 hover:bg-gray-700'
+ }`}
+ >
+ <div className="font-semibold capitalize">{preset}</div>
+ <div className="text-xs mt-1 opacity-80">
+ {preset === 'value' && 'Low P/E, P/B'}
+ {preset === 'growth' && 'High Growth'}
+ {preset === 'dividend' && 'High Yield'}
+ {preset === 'momentum' && 'Strong Trends'}
+ {preset === 'custom' && 'Build Your Own'}
+ </div>
+ </button>
+ ))}
+ </div>
+ </div>
+
+ {/* Saved Screens */}
+ {savedScreens.length > 0 && (
+ <div className="bg-gray-900 rounded-lg p-4 border border-gray-700">
+ <h3 className="text-lg font-semibold text-white mb-3">Saved Screens</h3>
+ <div className="flex flex-wrap gap-2">
+ {savedScreens.map((screen) => (
+ <button
+ key={screen.id}
+ onClick={() => loadSavedScreen(screen)}
+ className="px-3 py-2 text-sm bg-gray-800 hover:bg-gray-700 border border-gray-700 text-white rounded transition-colors"
+ >
+ {screen.name}
+ </button>
+ ))}
+ </div>
+ </div>
+ )}
+
+ {/* Filter Builder */}
+ {criteria && (
+ <div className="bg-gray-900 rounded-lg p-6 border border-gray-700">
+ <div className="flex items-center justify-between mb-4">
+ <div>
+ <h3 className="text-lg font-semibold text-white">{criteria.name}</h3>
+ <p className="text-sm text-gray-400">{criteria.description}</p>
+ </div>
+ <button
+ onClick={addCondition}
+ className="px-4 py-2 bg-blue-600 hover:bg-blue-700 text-white rounded-lg transition-colors font-medium flex items-center gap-2"
+ >
+ <svg className="w-4 h-4" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
+ </svg>
+ Add Filter
+ </button>
+ </div>
+
+ {/* Filter Conditions */}
+ <div className="space-y-3">
+ {criteria.conditions.length === 0 ? (
+ <div className="text-center py-8 text-gray-400">
+ No filters defined. Click "Add Filter" to start building your screen.
+ </div>
+ ) : (
+ criteria.conditions.map((condition, index) => (
+ <FilterConditionRow
+ key={index}
+ condition={condition}
+ index={index}
+ availableMetrics={availableMetrics}
+ onUpdate={updateCondition}
+ onRemove={removeCondition}
+ />
+ ))
+ )}
+ </div>
+ </div>
+ )}
+
+ {/* Results */}
+ {results && (
+ <div className="bg-gray-900 rounded-lg border border-gray-700">
+ <div className="p-4 border-b border-gray-700">
+ <div className="flex items-center justify-between">
+ <div>
+ <h3 className="text-lg font-semibold text-white">
+ Screening Results
+ </h3>
+ <p className="text-sm text-gray-400 mt-1">
+ Found {results.matchingStocks.length} of {results.totalStocksScreened} stocks
+ </p>
+ </div>
+ <div className="text-sm text-gray-400">
+ {((results.matchingStocks.length / results.totalStocksScreened) * 100).toFixed(1)}% match rate
+ </div>
+ </div>
+ </div>
+
+ <div className="overflow-x-auto">
+ <ResultsTable stocks={results.matchingStocks} />
+ </div>
+ </div>
+ )}
+
+ {/* Save Dialog */}
+ {showSaveDialog && (
+ <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+ <div className="bg-gray-800 rounded-lg p-6 max-w-md w-full mx-4 border border-gray-700">
+ <h3 className="text-xl font-semibold text-white mb-4">Save Custom Screen</h3>
+ <input
+ type="text"
+ value={newScreenName}
+ onChange={(e) => setNewScreenName(e.target.value)}
+ placeholder="Enter screen name..."
+ className="w-full px-4 py-2 bg-gray-900 border border-gray-700 rounded-lg text-white placeholder-gray-500 focus:outline-none focus:border-blue-500"
+ />
+ <div className="flex gap-3 mt-6">
+ <button
+ onClick={() => setShowSaveDialog(false)}
+ className="flex-1 px-4 py-2 bg-gray-700 hover:bg-gray-600 text-white rounded-lg transition-colors"
+ >
+ Cancel
+ </button>
+ <button
+ onClick={saveScreen}
+ disabled={!newScreenName.trim()}
+ className="flex-1 px-4 py-2 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-700 disabled:cursor-not-allowed text-white rounded-lg transition-colors"
+ >
+ Save
+ </button>
+ </div>
+ </div>
+ </div>
+ )}
+ </div>
+ );
+};
+
+// Filter Condition Row Component
+interface FilterConditionRowProps {
+ condition: FilterCondition;
+ index: number;
+ availableMetrics: MetricInfo[];
+ onUpdate: (index: number, field: keyof FilterCondition, value: any) => void;
+ onRemove: (index: number) => void;
+}
+
+const FilterConditionRow: React.FC<FilterConditionRowProps> = ({
+ condition,
+ index,
+ availableMetrics,
+ onUpdate,
+ onRemove,
+}) => {
+ const operators: FilterOperator[] = [
+ 'GreaterThan',
+ 'LessThan',
+ 'GreaterThanOrEqual',
+ 'LessThanOrEqual',
+ 'Equal',
+ 'Between',
+ ];
+
+ const getValue = (): number | { min: number; max: number } => {
+ if ('Single' in condition.value) {
+ return condition.value.Single;
+ } else if ('Range' in condition.value) {
+ return condition.value.Range;
+ }
+ return 0;
+ };
+
+ const handleValueChange = (newValue: number | { min: number; max: number }) => {
+ if (condition.operator === 'Between') {
+ onUpdate(index, 'value', createRangeValue((newValue as any).min, (newValue as any).max));
+ } else {
+ onUpdate(index, 'value', createSingleValue(newValue as number));
+ }
+ };
+
+ const value = getValue();
+ const isBetween = condition.operator === 'Between';
+
+ return (
+ <div className="flex items-center gap-3 p-3 bg-gray-800 rounded-lg border border-gray-700">
+ {/* Metric Selector */}
+ <select
+ value={condition.metric}
+ onChange={(e) => onUpdate(index, 'metric', e.target.value as MetricType)}
+ className="flex-1 px-3 py-2 bg-gray-900 border border-gray-700 rounded text-white focus:outline-none focus:border-blue-500"
+ >
+ {availableMetrics.map((metric) => (
+ <option key={metric.id} value={metric.type}>
+ {metric.name} ({metric.category})
+ </option>
+ ))}
+ </select>
+
+ {/* Operator Selector */}
+ <select
+ value={condition.operator}
+ onChange={(e) => {
+ const newOperator = e.target.value as FilterOperator;
+ onUpdate(index, 'operator', newOperator);
+ // Reset value when switching to/from Between
+ if (newOperator === 'Between') {
+ onUpdate(index, 'value', createRangeValue(0, 100));
+ } else if (condition.operator === 'Between') {
+ onUpdate(index, 'value', createSingleValue(0));
+ }
+ }}
+ className="w-32 px-3 py-2 bg-gray-900 border border-gray-700 rounded text-white focus:outline-none focus:border-blue-500"
+ >
+ {operators.map((op) => (
+ <option key={op} value={op}>
+ {getOperatorDisplayName(op)}
+ </option>
+ ))}
+ </select>
+
+ {/* Value Input(s) */}
+ {isBetween ? (
+ <div className="flex items-center gap-2">
+ <input
+ type="number"
+ value={(value as { min: number; max: number }).min}
+ onChange={(e) =>
+ handleValueChange({
+ min: parseFloat(e.target.value) || 0,
+ max: (value as { min: number; max: number }).max,
+ })
+ }
+ className="w-24 px-3 py-2 bg-gray-900 border border-gray-700 rounded text-white focus:outline-none focus:border-blue-500"
+ placeholder="Min"
+ />
+ <span className="text-gray-400">to</span>
+ <input
+ type="number"
+ value={(value as { min: number; max: number }).max}
+ onChange={(e) =>
+ handleValueChange({
+ min: (value as { min: number; max: number }).min,
+ max: parseFloat(e.target.value) || 0,
+ })
+ }
+ className="w-24 px-3 py-2 bg-gray-900 border border-gray-700 rounded text-white focus:outline-none focus:border-blue-500"
+ placeholder="Max"
+ />
+ </div>
+ ) : (
+ <input
+ type="number"
+ value={value as number}
+ onChange={(e) => handleValueChange(parseFloat(e.target.value) || 0)}
+ className="w-32 px-3 py-2 bg-gray-900 border border-gray-700 rounded text-white focus:outline-none focus:border-blue-500"
+ placeholder="Value"
+ step="0.01"
+ />
+ )}
+
+ {/* Remove Button */}
+ <button
+ onClick={() => onRemove(index)}
+ className="p-2 hover:bg-gray-700 rounded transition-colors"
+ title="Remove filter"
+ >
+ <svg className="w-5 h-5 text-red-400" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+ </svg>
+ </button>
+ </div>
+ );
+};
+
+// Results Table Component
+interface ResultsTableProps {
+ stocks: StockData[];
+}
+
+const ResultsTable: React.FC<ResultsTableProps> = ({ stocks }) => {
+ const [sortField, setSortField] = useState<string>('symbol');
+ const [sortDirection, setSortDirection] = useState<'asc' | 'desc'>('asc');
+
+ if (stocks.length === 0) {
+ return (
+ <div className="p-8 text-center text-gray-400">
+ No stocks match the screening criteria.
+ </div>
+ );
+ }
+
+ const allMetricKeys = Object.keys(stocks[0].metrics);
+
+ const handleSort = (field: string) => {
+ if (sortField === field) {
+ setSortDirection(sortDirection === 'asc' ? 'desc' : 'asc');
+ } else {
+ setSortField(field);
+ setSortDirection('asc');
+ }
+ };
+
+ const sortedStocks = [...stocks].sort((a, b) => {
+ let aVal: any;
+ let bVal: any;
+
+ if (sortField === 'symbol' || sortField === 'name' || sortField === 'sector' || sortField === 'industry') {
+ aVal = a[sortField];
+ bVal = b[sortField];
+ } else {
+ aVal = a.metrics[sortField] ?? 0;
+ bVal = b.metrics[sortField] ?? 0;
+ }
+
+ if (typeof aVal === 'string') {
+ return sortDirection === 'asc' ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
+ }
+
+ return sortDirection === 'asc' ? aVal - bVal : bVal - aVal;
+ });
+
+ return (
+ <table className="min-w-full divide-y divide-gray-700">
+ <thead className="bg-gray-800">
+ <tr>
+ <SortableHeader field="symbol" label="Symbol" sortField={sortField} sortDirection={sortDirection} onSort={handleSort} />
+ <SortableHeader field="name" label="Name" sortField={sortField} sortDirection={sortDirection} onSort={handleSort} />
+ <SortableHeader field="sector" label="Sector" sortField={sortField} sortDirection={sortDirection} onSort={handleSort} />
+ <SortableHeader field="industry" label="Industry" sortField={sortField} sortDirection={sortDirection} onSort={handleSort} />
+ {allMetricKeys.slice(0, 6).map((key) => (
+ <SortableHeader
+ key={key}
+ field={key}
+ label={key.replace(/([A-Z])/g, ' $1').trim()}
+ sortField={sortField}
+ sortDirection={sortDirection}
+ onSort={handleSort}
+ />
+ ))}
+ </tr>
+ </thead>
+ <tbody className="divide-y divide-gray-800">
+ {sortedStocks.map((stock) => (
+ <tr key={stock.symbol} className="hover:bg-gray-800 transition-colors">
+ <td className="px-4 py-3 whitespace-nowrap text-sm font-semibold text-blue-400">
+ {stock.symbol}
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-gray-300">
+ {stock.name}
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-gray-400">
+ {stock.sector}
+ </td>
+ <td className="px-4 py-3 whitespace-nowrap text-sm text-gray-400">
+ {stock.industry}
+ </td>
+ {allMetricKeys.slice(0, 6).map((key) => (
+ <td key={key} className="px-4 py-3 whitespace-nowrap text-sm text-right text-gray-300">
+ {stock.metrics[key]?.toFixed(2) || 'N/A'}
+ </td>
+ ))}
+ </tr>
+ ))}
+ </tbody>
+ </table>
+ );
+};
+
+// Sortable Header Component
+interface SortableHeaderProps {
+ field: string;
+ label: string;
+ sortField: string;
+ sortDirection: 'asc' | 'desc';
+ onSort: (field: string) => void;
+}
+
+const SortableHeader: React.FC<SortableHeaderProps> = ({
+ field,
+ label,
+ sortField,
+ sortDirection,
+ onSort,
+}) => {
+ const isActive = sortField === field;
+
+ return (
+ <th
+ onClick={() => onSort(field)}
+ className="px-4 py-3 text-left text-xs font-medium text-gray-400 uppercase tracking-wider cursor-pointer hover:text-gray-300 transition-colors"
+ >
+ <div className="flex items-center gap-1">
+ {label}
+ {isActive && (
+ <svg
+ className={`w-4 h-4 transition-transform ${sortDirection === 'desc' ? 'rotate-180' : ''}`}
+ fill="none"
+ viewBox="0 0 24 24"
+ stroke="currentColor"
+ >
+ <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M5 15l7-7 7 7" />
+ </svg>
+ )}
+ </div>
+ </th>
+ );
+};
diff --git a/fincept-terminal-desktop/src/hooks/usePeerComparison.ts b/fincept-terminal-desktop/src/hooks/usePeerComparison.ts
new file mode 100644
index 000000000..48911932e
--- /dev/null
+++ b/fincept-terminal-desktop/src/hooks/usePeerComparison.ts
@@ -0,0 +1,233 @@
+// Custom React Hook for Peer Comparison
+// Manages state and API calls for peer analysis
+
+import { useState, useCallback, useEffect } from 'react';
+import { invoke } from '@tauri-apps/api/core';
+import type {
+ PeerCompany,
+ PeerComparisonResult,
+ PeerSearchInput,
+ ComparisonInput,
+ PeerCommandResponse,
+ MetricRanking,
+ PercentileInput,
+} from '../types/peer';
+
+export interface UsePeerComparisonReturn {
+ // State
+ targetSymbol: string;
+ selectedPeers: PeerCompany[];
+ availablePeers: PeerCompany[];
+ comparisonData: PeerComparisonResult | null;
+ loading: boolean;
+ error: string | null;
+
+ // Actions
+ setTargetSymbol: (symbol: string) => void;
+ fetchPeers: (input: PeerSearchInput) => Promise<void>;
+ addPeer: (peer: PeerCompany) => void;
+ removePeer: (symbol: string) => void;
+ selectPeer: (symbol: string) => void;
+ deselectPeer: (symbol: string) => void;
+ selectAllPeers: () => void;
+ clearPeers: () => void;
+ runComparison: () => Promise<void>;
+ calculatePercentiles: (input: PercentileInput) => Promise<MetricRanking | null>;
+ reset: () => void;
+}
+
+export function usePeerComparison(initialSymbol?: string): UsePeerComparisonReturn {
+ const [targetSymbol, setTargetSymbol] = useState<string>(initialSymbol || '');
+ const [selectedPeers, setSelectedPeers] = useState<PeerCompany[]>([]);
+ const [availablePeers, setAvailablePeers] = useState<PeerCompany[]>([]);
+ const [comparisonData, setComparisonData] = useState<PeerComparisonResult | null>(null);
+ const [loading, setLoading] = useState(false);
+ const [error, setError] = useState<string | null>(null);
+
+ // Fetch peer companies
+ const fetchPeers = useCallback(async (input: PeerSearchInput) => {
+ console.log('[usePeerComparison] Fetching peers with input:', input);
+ setLoading(true);
+ setError(null);
+
+ try {
+ console.log('[usePeerComparison] Calling invoke find_peers...');
+ const response = await invoke<PeerCommandResponse<PeerCompany[]>>('find_peers', { input });
+ console.log('[usePeerComparison] Response:', response);
+
+ if (response.success && response.data) {
+ console.log('[usePeerComparison] Found', response.data.length, 'peers');
+ setAvailablePeers(response.data);
+ // Auto-select top 5 peers by similarity
+ const topPeers = response.data.slice(0, 5);
+ setSelectedPeers(topPeers);
+ console.log('[usePeerComparison] Auto-selected', topPeers.length, 'peers');
+ } else {
+ console.error('[usePeerComparison] Failed:', response.error);
+ setError(response.error || 'Failed to fetch peers');
+ }
+ } catch (err) {
+ console.error('[usePeerComparison] Error fetching peers:', err);
+ setError(err instanceof Error ? err.message : 'Unknown error occurred');
+ } finally {
+ setLoading(false);
+ }
+ }, []);
+
+ // Add a peer to selected list
+ const addPeer = useCallback((peer: PeerCompany) => {
+ setSelectedPeers((prev) => {
+ if (prev.find((p) => p.symbol === peer.symbol)) {
+ return prev;
+ }
+ return [...prev, peer];
+ });
+ }, []);
+
+ // Remove a peer from selected list
+ const removePeer = useCallback((symbol: string) => {
+ setSelectedPeers((prev) => prev.filter((p) => p.symbol !== symbol));
+ }, []);
+
+ // Select a peer from available list
+ const selectPeer = useCallback((symbol: string) => {
+ const peer = availablePeers.find((p) => p.symbol === symbol);
+ if (peer) {
+ addPeer(peer);
+ }
+ }, [availablePeers, addPeer]);
+
+ // Deselect a peer
+ const deselectPeer = useCallback((symbol: string) => {
+ removePeer(symbol);
+ }, [removePeer]);
+
+ // Select all available peers
+ const selectAllPeers = useCallback(() => {
+ setSelectedPeers(availablePeers);
+ }, [availablePeers]);
+
+ // Clear all selected peers
+ const clearPeers = useCallback(() => {
+ setSelectedPeers([]);
+ }, []);
+
+ // Run peer comparison
+ const runComparison = useCallback(async () => {
+ if (!targetSymbol || selectedPeers.length === 0) {
+ setError('Please select a target symbol and at least one peer');
+ return;
+ }
+
+ setLoading(true);
+ setError(null);
+
+ try {
+ const input: ComparisonInput = {
+ targetSymbol,
+ peerSymbols: selectedPeers.map((p) => p.symbol),
+ metrics: [
+ 'peRatio',
+ 'pbRatio',
+ 'psRatio',
+ 'roe',
+ 'roa',
+ 'netMargin',
+ 'revenueGrowth',
+ 'earningsGrowth',
+ 'debtToEquity',
+ ],
+ };
+
+ const response = await invoke<PeerCommandResponse<PeerComparisonResult>>('compare_peers', { input });
+
+ if (response.success && response.data) {
+ setComparisonData(response.data);
+ } else {
+ setError(response.error || 'Failed to run comparison');
+ }
+ } catch (err) {
+ setError(err instanceof Error ? err.message : 'Unknown error occurred');
+ console.error('Error running comparison:', err);
+ } finally {
+ setLoading(false);
+ }
+ }, [targetSymbol, selectedPeers]);
+
+ // Calculate percentile ranking for a metric
+ const calculatePercentiles = useCallback(
+ async (input: PercentileInput): Promise<MetricRanking | null> => {
+ try {
+ const response = await invoke<PeerCommandResponse<MetricRanking>>('calculate_peer_percentiles', { input });
+
+ if (response.success && response.data) {
+ return response.data;
+ } else {
+ console.error('Failed to calculate percentiles:', response.error);
+ return null;
+ }
+ } catch (err) {
+ console.error('Error calculating percentiles:', err);
+ return null;
+ }
+ },
+ []
+ );
+
+ // Reset all state
+ const reset = useCallback(() => {
+ setTargetSymbol('');
+ setSelectedPeers([]);
+ setAvailablePeers([]);
+ setComparisonData(null);
+ setError(null);
+ }, []);
+
+ // Auto-fetch peers when target symbol changes
+ useEffect(() => {
+ console.log('[usePeerComparison] useEffect triggered. targetSymbol:', targetSymbol, 'availablePeers.length:', availablePeers.length);
+ if (targetSymbol && targetSymbol.length >= 1) {
+ // Create a mock search input for demo purposes
+ // In production, you'd fetch company info first
+ const mockInput: PeerSearchInput = {
+ symbol: targetSymbol,
+ sector: 'Information Technology',
+ industry: 'Software',
+ marketCap: 2000000000000,
+ minSimilarity: 0.5,
+ maxPeers: 15,
+ };
+
+ // Only fetch if we don't have peers yet
+ if (availablePeers.length === 0) {
+ console.log('[usePeerComparison] Triggering fetchPeers...');
+ fetchPeers(mockInput);
+ } else {
+ console.log('[usePeerComparison] Peers already loaded, skipping fetch');
+ }
+ }
+ }, [targetSymbol]); // Intentionally not including fetchPeers and availablePeers to avoid loops
+
+ return {
+ // State
+ targetSymbol,
+ selectedPeers,
+ availablePeers,
+ comparisonData,
+ loading,
+ error,
+
+ // Actions
+ setTargetSymbol,
+ fetchPeers,
+ addPeer,
+ removePeer,
+ selectPeer,
+ deselectPeer,
+ selectAllPeers,
+ clearPeers,
+ runComparison,
+ calculatePercentiles,
+ reset,
+ };
+}
diff --git a/fincept-terminal-desktop/src/services/screenerApi.ts b/fincept-terminal-desktop/src/services/screenerApi.ts
new file mode 100644
index 000000000..6141a25cb
--- /dev/null
+++ b/fincept-terminal-desktop/src/services/screenerApi.ts
@@ -0,0 +1,195 @@
+// Stock Screener API Service
+// Tauri command wrappers for stock screener functionality
+
+import { invoke } from '@tauri-apps/api/core';
+import type {
+ ScreenCriteria,
+ ScreenResult,
+ SavedScreen,
+ MetricInfo,
+} from '../types/screener';
+
+export const screenerApi = {
+ /**
+ * Execute a stock screen with given criteria
+ */
+ executeScreen: async (criteria: ScreenCriteria): Promise<ScreenResult> => {
+ try {
+ const response = await invoke<{ success: boolean; data: ScreenResult; error?: string }>(
+ 'execute_stock_screen',
+ { criteria }
+ );
+
+ if (!response.success || !response.data) {
+ throw new Error(response.error || 'Failed to execute screen');
+ }
+
+ return response.data;
+ } catch (error) {
+ console.error('Error executing screen:', error);
+ throw error;
+ }
+ },
+
+ /**
+ * Get preset Value Stocks screen criteria
+ */
+ getValueScreen: async (): Promise<ScreenCriteria> => {
+ try {
+ const response = await invoke<{ success: boolean; data: ScreenCriteria; error?: string }>(
+ 'get_value_screen'
+ );
+
+ if (!response.success || !response.data) {
+ throw new Error(response.error || 'Failed to get value screen');
+ }
+
+ return response.data;
+ } catch (error) {
+ console.error('Error getting value screen:', error);
+ throw error;
+ }
+ },
+
+ /**
+ * Get preset Growth Stocks screen criteria
+ */
+ getGrowthScreen: async (): Promise<ScreenCriteria> => {
+ try {
+ const response = await invoke<{ success: boolean; data: ScreenCriteria; error?: string }>(
+ 'get_growth_screen'
+ );
+
+ if (!response.success || !response.data) {
+ throw new Error(response.error || 'Failed to get growth screen');
+ }
+
+ return response.data;
+ } catch (error) {
+ console.error('Error getting growth screen:', error);
+ throw error;
+ }
+ },
+
+ /**
+ * Get preset Dividend Aristocrats screen criteria
+ */
+ getDividendScreen: async (): Promise<ScreenCriteria> => {
+ try {
+ const response = await invoke<{ success: boolean; data: ScreenCriteria; error?: string }>(
+ 'get_dividend_screen'
+ );
+
+ if (!response.success || !response.data) {
+ throw new Error(response.error || 'Failed to get dividend screen');
+ }
+
+ return response.data;
+ } catch (error) {
+ console.error('Error getting dividend screen:', error);
+ throw error;
+ }
+ },
+
+ /**
+ * Get preset Momentum Stocks screen criteria
+ */
+ getMomentumScreen: async (): Promise<ScreenCriteria> => {
+ try {
+ const response = await invoke<{ success: boolean; data: ScreenCriteria; error?: string }>(
+ 'get_momentum_screen'
+ );
+
+ if (!response.success || !response.data) {
+ throw new Error(response.error || 'Failed to get momentum screen');
+ }
+
+ return response.data;
+ } catch (error) {
+ console.error('Error getting momentum screen:', error);
+ throw error;
+ }
+ },
+
+ /**
+ * Save a custom screen
+ */
+ saveCustomScreen: async (name: string, criteria: ScreenCriteria): Promise<SavedScreen> => {
+ try {
+ const response = await invoke<{ success: boolean; data: SavedScreen; error?: string }>(
+ 'save_custom_screen',
+ { name, criteria }
+ );
+
+ if (!response.success || !response.data) {
+ throw new Error(response.error || 'Failed to save custom screen');
+ }
+
+ return response.data;
+ } catch (error) {
+ console.error('Error saving custom screen:', error);
+ throw error;
+ }
+ },
+
+ /**
+ * Load all saved custom screens
+ */
+ loadCustomScreens: async (): Promise<SavedScreen[]> => {
+ try {
+ const response = await invoke<{ success: boolean; data: SavedScreen[]; error?: string }>(
+ 'load_custom_screens'
+ );
+
+ if (!response.success) {
+ throw new Error(response.error || 'Failed to load custom screens');
+ }
+
+ return response.data || [];
+ } catch (error) {
+ console.error('Error loading custom screens:', error);
+ throw error;
+ }
+ },
+
+ /**
+ * Delete a saved custom screen
+ */
+ deleteCustomScreen: async (screenId: string): Promise<boolean> => {
+ try {
+ const response = await invoke<{ success: boolean; data: boolean; error?: string }>(
+ 'delete_custom_screen',
+ { screenId }
+ );
+
+ if (!response.success) {
+ throw new Error(response.error || 'Failed to delete custom screen');
+ }
+
+ return response.data || false;
+ } catch (error) {
+ console.error('Error deleting custom screen:', error);
+ throw error;
+ }
+ },
+
+ /**
+ * Get available metrics for screening
+ */
+ getAvailableMetrics: async (): Promise<MetricInfo[]> => {
+ try {
+ const response = await invoke<{ success: boolean; data: MetricInfo[]; error?: string }>(
+ 'get_available_metrics'
+ );
+
+ if (!response.success || !response.data) {
+ throw new Error(response.error || 'Failed to get available metrics');
+ }
+
+ return response.data;
+ } catch (error) {
+ console.error('Error getting available metrics:', error);
+ throw error;
+ }
+ },
+};
diff --git a/fincept-terminal-desktop/src/types/peer.ts b/fincept-terminal-desktop/src/types/peer.ts
new file mode 100644
index 000000000..7fb2d2e89
--- /dev/null
+++ b/fincept-terminal-desktop/src/types/peer.ts
@@ -0,0 +1,318 @@
+// TypeScript types for Peer Comparison & Benchmarking
+// CFA-compliant peer analysis types
+
+// ============================================================================
+// GICS Classification Types
+// ============================================================================
+
+export type GICSSector =
+ | 'Energy'
+ | 'Materials'
+ | 'Industrials'
+ | 'Consumer Discretionary'
+ | 'Consumer Staples'
+ | 'Health Care'
+ | 'Financials'
+ | 'Information Technology'
+ | 'Communication Services'
+ | 'Utilities'
+ | 'Real Estate';
+
+export type MarketCapCategory =
+ | 'Mega Cap' // > $200B
+ | 'Large Cap' // $10B - $200B
+ | 'Mid Cap' // $2B - $10B
+ | 'Small Cap' // $300M - $2B
+ | 'Micro Cap' // $50M - $300M
+ | 'Nano Cap'; // < $50M
+
+export type MetricCategory =
+ | 'valuation'
+ | 'profitability'
+ | 'growth'
+ | 'leverage'
+ | 'liquidity'
+ | 'efficiency';
+
+// ============================================================================
+// Peer Company Types
+// ============================================================================
+
+export interface PeerCompany {
+ symbol: string;
+ name: string;
+ sector: string;
+ industry: string;
+ marketCap: number;
+ marketCapCategory: MarketCapCategory;
+ similarityScore: number; // 0.0 to 1.0
+ matchDetails: MatchDetails;
+}
+
+export interface MatchDetails {
+ sectorMatch: boolean;
+ industryMatch: boolean;
+ marketCapSimilarity: number; // 0.0 to 1.0
+ geographicMatch: boolean;
+}
+
+// ============================================================================
+// Financial Metrics Types
+// ============================================================================
+
+export interface ValuationMetrics {
+ peRatio?: number;
+ pbRatio?: number;
+ psRatio?: number;
+ pcfRatio?: number;
+ evToEbitda?: number;
+ pegRatio?: number;
+}
+
+export interface ProfitabilityMetrics {
+ roe?: number; // Return on Equity
+ roa?: number; // Return on Assets
+ roic?: number; // Return on Invested Capital
+ grossMargin?: number;
+ operatingMargin?: number;
+ netMargin?: number;
+}
+
+export interface GrowthMetrics {
+ revenueGrowth?: number;
+ earningsGrowth?: number;
+ fcfGrowth?: number;
+}
+
+export interface LeverageMetrics {
+ debtToEquity?: number;
+ debtToAssets?: number;
+ interestCoverage?: number;
+}
+
+export interface CompanyMetrics {
+ symbol: string;
+ name: string;
+ valuation: ValuationMetrics;
+ profitability: ProfitabilityMetrics;
+ growth: GrowthMetrics;
+ leverage: LeverageMetrics;
+}
+
+// ============================================================================
+// Comparison & Benchmarking Types
+// ============================================================================
+
+export interface PeerComparisonResult {
+ target: CompanyMetrics;
+ peers: CompanyMetrics[];
+ benchmarks: SectorBenchmarks;
+ percentileRanks?: Record<string, PercentileRanking>;
+ summary?: ComparisonSummary;
+}
+
+export interface SectorBenchmarks {
+ sector: string;
+ medianPe?: number;
+ medianPb?: number;
+ medianRoe?: number;
+ medianRevenueGrowth?: number;
+ medianDebtToEquity?: number;
+}
+
+export interface MetricBenchmarks {
+ metricName: string;
+ sectorMedian: number;
+ sectorMean: number;
+ sectorStdDev: number;
+ topQuartile: number;
+ bottomQuartile: number;
+}
+
+export interface PercentileRanking {
+ metricName: string;
+ value: number;
+ percentile: number; // 0.0 to 100.0
+ zScore: number; // Standard deviations from mean
+ peerMedian: number;
+ peerMean: number;
+ peerStdDev: number;
+}
+
+export interface ValuationStatus {
+ status: 'Undervalued' | 'Fairly Valued' | 'Overvalued' | 'Potentially Undervalued' | 'Potentially Overvalued';
+ confidence: number; // 0.0 to 1.0
+ reasoning: string[];
+}
+
+export interface ComparisonSummary {
+ valuationScore: number;
+ profitabilityScore: number;
+ growthScore: number;
+ overallRating: number;
+}
+
+// ============================================================================
+// Request/Response Types for Tauri Commands
+// ============================================================================
+
+export interface PeerSearchInput {
+ symbol: string;
+ sector: string;
+ industry: string;
+ marketCap: number;
+ minSimilarity?: number;
+ maxPeers?: number;
+}
+
+export interface ComparisonInput {
+ targetSymbol: string;
+ peerSymbols: string[];
+ metrics: string[];
+}
+
+export interface PercentileInput {
+ symbol: string;
+ metricName: string;
+ metricValue: number;
+ peerValues: number[];
+}
+
+export interface PeerCommandResponse<T> {
+ success: boolean;
+ data?: T;
+ error?: string;
+}
+
+export interface MetricRanking {
+ symbol: string;
+ ranking: PercentileRanking;
+ valuationStatus?: ValuationStatus;
+}
+
+// ============================================================================
+// UI State Types
+// ============================================================================
+
+export interface PeerComparisonState {
+ targetSymbol: string;
+ selectedPeers: PeerCompany[];
+ availablePeers: PeerCompany[];
+ comparisonData?: PeerComparisonResult;
+ loading: boolean;
+ error?: string;
+}
+
+export type ViewMode = 'table' | 'chart' | 'radar' | 'heatmap';
+
+export interface ChartDataPoint {
+ metric: string;
+ target: number;
+ peer: number;
+ benchmark: number;
+}
+
+// ============================================================================
+// Utility Functions
+// ============================================================================
+
+/**
+ * Format a metric value for display
+ */
+export function formatMetricValue(value: number | undefined, format: 'percentage' | 'ratio' | 'currency' | 'number'): string {
+ if (value === undefined || value === null) return 'N/A';
+
+ switch (format) {
+ case 'percentage':
+ return `${(value * 100).toFixed(2)}%`;
+ case 'ratio':
+ return value.toFixed(2);
+ case 'currency':
+ return new Intl.NumberFormat('en-US', {
+ style: 'currency',
+ currency: 'USD',
+ notation: value >= 1e9 ? 'compact' : 'standard',
+ maximumFractionDigits: 2,
+ }).format(value);
+ case 'number':
+ return value.toLocaleString('en-US', { maximumFractionDigits: 2 });
+ default:
+ return value.toString();
+ }
+}
+
+/**
+ * Get color based on percentile ranking
+ */
+export function getPercentileColor(percentile: number): string {
+ if (percentile >= 75) return '#10b981'; // green-500
+ if (percentile >= 50) return '#3b82f6'; // blue-500
+ if (percentile >= 25) return '#f59e0b'; // amber-500
+ return '#ef4444'; // red-500
+}
+
+/**
+ * Get market cap category from value
+ */
+export function getMarketCapCategory(marketCap: number): MarketCapCategory {
+ if (marketCap > 200_000_000_000) return 'Mega Cap';
+ if (marketCap > 10_000_000_000) return 'Large Cap';
+ if (marketCap > 2_000_000_000) return 'Mid Cap';
+ if (marketCap > 300_000_000) return 'Small Cap';
+ if (marketCap > 50_000_000) return 'Micro Cap';
+ return 'Nano Cap';
+}
+
+/**
+ * Get all metric names from a company
+ */
+export function getAllMetricNames(company: CompanyMetrics): string[] {
+ const metrics: string[] = [];
+
+ // Valuation metrics
+ if (company.valuation.peRatio) metrics.push('P/E Ratio');
+ if (company.valuation.pbRatio) metrics.push('P/B Ratio');
+ if (company.valuation.psRatio) metrics.push('P/S Ratio');
+ if (company.valuation.evToEbitda) metrics.push('EV/EBITDA');
+
+ // Profitability metrics
+ if (company.profitability.roe) metrics.push('ROE');
+ if (company.profitability.roa) metrics.push('ROA');
+ if (company.profitability.netMargin) metrics.push('Net Margin');
+
+ // Growth metrics
+ if (company.growth.revenueGrowth) metrics.push('Revenue Growth');
+ if (company.growth.earningsGrowth) metrics.push('Earnings Growth');
+
+ // Leverage metrics
+ if (company.leverage.debtToEquity) metrics.push('Debt/Equity');
+
+ return metrics;
+}
+
+/**
+ * Extract metric value by name
+ */
+export function getMetricValue(company: CompanyMetrics, metricName: string): number | undefined {
+ const metricMap: Record<string, number | undefined> = {
+ 'P/E Ratio': company.valuation.peRatio,
+ 'P/B Ratio': company.valuation.pbRatio,
+ 'P/S Ratio': company.valuation.psRatio,
+ 'EV/EBITDA': company.valuation.evToEbitda,
+ 'PEG Ratio': company.valuation.pegRatio,
+ 'ROE': company.profitability.roe,
+ 'ROA': company.profitability.roa,
+ 'ROIC': company.profitability.roic,
+ 'Gross Margin': company.profitability.grossMargin,
+ 'Operating Margin': company.profitability.operatingMargin,
+ 'Net Margin': company.profitability.netMargin,
+ 'Revenue Growth': company.growth.revenueGrowth,
+ 'Earnings Growth': company.growth.earningsGrowth,
+ 'FCF Growth': company.growth.fcfGrowth,
+ 'Debt/Equity': company.leverage.debtToEquity,
+ 'Debt/Assets': company.leverage.debtToAssets,
+ 'Interest Coverage': company.leverage.interestCoverage,
+ };
+
+ return metricMap[metricName];
+}
diff --git a/fincept-terminal-desktop/src/types/screener.ts b/fincept-terminal-desktop/src/types/screener.ts
new file mode 100644
index 000000000..29ca5c4fd
--- /dev/null
+++ b/fincept-terminal-desktop/src/types/screener.ts
@@ -0,0 +1,155 @@
+// Stock Screener Types
+// TypeScript types matching Rust screener service
+
+export type FilterOperator =
+ | 'GreaterThan'
+ | 'LessThan'
+ | 'GreaterThanOrEqual'
+ | 'LessThanOrEqual'
+ | 'Equal'
+ | 'NotEqual'
+ | 'Between'
+ | 'InList';
+
+export type MetricType =
+ // Valuation
+ | 'PeRatio'
+ | 'PbRatio'
+ | 'PsRatio'
+ | 'PcfRatio'
+ | 'EvToEbitda'
+ | 'PegRatio'
+ // Profitability
+ | 'Roe'
+ | 'Roa'
+ | 'Roic'
+ | 'GrossMargin'
+ | 'OperatingMargin'
+ | 'NetMargin'
+ // Growth
+ | 'RevenueGrowth'
+ | 'EarningsGrowth'
+ | 'FcfGrowth'
+ // Leverage
+ | 'DebtToEquity'
+ | 'DebtToAssets'
+ | 'InterestCoverage'
+ // Market Data
+ | 'MarketCap'
+ | 'Price'
+ | 'Volume'
+ | 'Beta'
+ // Dividend
+ | 'DividendYield'
+ | 'PayoutRatio'
+ | 'DividendGrowth';
+
+export type FilterValue =
+ | { Single: number }
+ | { Range: { min: number; max: number } }
+ | { List: string[] };
+
+export interface FilterCondition {
+ metric: MetricType;
+ operator: FilterOperator;
+ value: FilterValue;
+}
+
+export interface ScreenCriteria {
+ name: string;
+ description: string;
+ conditions: FilterCondition[];
+ sectorFilter?: string[];
+ industryFilter?: string[];
+}
+
+export interface StockData {
+ symbol: string;
+ name: string;
+ sector: string;
+ industry: string;
+ metrics: Record<string, number>;
+}
+
+export interface ScreenResult {
+ totalStocksScreened: number;
+ matchingStocks: StockData[];
+ criteriaUsed: ScreenCriteria;
+}
+
+export interface SavedScreen {
+ id: string;
+ name: string;
+ description: string;
+ criteria: ScreenCriteria;
+ createdAt: number;
+ updatedAt: number;
+}
+
+export interface MetricInfo {
+ id: string;
+ name: string;
+ category: 'Valuation' | 'Profitability' | 'Growth' | 'Leverage' | 'Market Data' | 'Dividend';
+ description: string;
+ type: MetricType;
+}
+
+// Helper functions to create filter values
+export const createSingleValue = (value: number): FilterValue => ({
+ Single: value,
+});
+
+export const createRangeValue = (min: number, max: number): FilterValue => ({
+ Range: { min, max },
+});
+
+export const createListValue = (values: string[]): FilterValue => ({
+ List: values,
+});
+
+// Helper function to format metric display names
+export const getMetricDisplayName = (metricType: MetricType): string => {
+ const nameMap: Record<MetricType, string> = {
+ PeRatio: 'P/E Ratio',
+ PbRatio: 'P/B Ratio',
+ PsRatio: 'P/S Ratio',
+ PcfRatio: 'P/CF Ratio',
+ EvToEbitda: 'EV/EBITDA',
+ PegRatio: 'PEG Ratio',
+ Roe: 'ROE',
+ Roa: 'ROA',
+ Roic: 'ROIC',
+ GrossMargin: 'Gross Margin',
+ OperatingMargin: 'Operating Margin',
+ NetMargin: 'Net Margin',
+ RevenueGrowth: 'Revenue Growth',
+ EarningsGrowth: 'Earnings Growth',
+ FcfGrowth: 'FCF Growth',
+ DebtToEquity: 'Debt/Equity',
+ DebtToAssets: 'Debt/Assets',
+ InterestCoverage: 'Interest Coverage',
+ MarketCap: 'Market Cap',
+ Price: 'Price',
+ Volume: 'Volume',
+ Beta: 'Beta',
+ DividendYield: 'Dividend Yield',
+ PayoutRatio: 'Payout Ratio',
+ DividendGrowth: 'Dividend Growth',
+ };
+ return nameMap[metricType] || metricType;
+};
+
+// Helper function to get operator display name
+export const getOperatorDisplayName = (operator: FilterOperator): string => {
+ const nameMap: Record<FilterOperator, string> = {
+ GreaterThan: '>',
+ LessThan: '<',
+ GreaterThanOrEqual: '≥',
+ LessThanOrEqual: '≤',
+ Equal: '=',
+ NotEqual: '≠',
+ Between: 'Between',
+ InList: 'In List',
+ };
+ return nameMap[operator] || operator;
+};