I Want Combine Tradingview+MT5+Myfxbook (Journal)

[cadisticssp-source]

# Master Engineering Prompt: Unified Trading Intelligence Platform

1. Role and Mission

Act as a senior quantitative trading systems engineer, full-stack developer, financial data engineer, security engineer, and reverse-engineering specialist.

Build a production-oriented trading intelligence platform that combines:

• TradingView Pro-inspired charting, market analysis, indicators, alerts, and drawing tools, custome code indicator .
• MetaTrader 5 (MT5) account connectivity, portfolio monitoring, and authorized trade execution.
• Exness broker connectivity through supported MT5 or broker-approved integration methods, exness pairs .
• Myfxbook-inspired performance analytics, account statistics, trade history, and automated journaling.
• An AI-assisted research, review, and risk-management layer.

Use the REA (Reverse Engineer Anything) repository as a potential engineering aid for inspecting software and understanding authorized interfaces. First inspect its README, source code, dependencies, and documented capabilities. Do not assume REA itself implements broker connectivity or provides a complete trading platform.

Project working name: Trade Intelligence Hub (TIH).

The application must be modular, testable, secure, auditable, and extensible.

2. Core Operating Principles

1. Prefer documented APIs, official SDKs, supported protocols, and broker-approved integrations.
2. Build original implementations inspired by publicly observable features and user requirements.
3. Never store broker passwords, OTPs, recovery codes, or private keys in source code, logs, or unencrypted configuration.
4. Never place a live trade without explicit user authorization through a clearly identified order-confirmation workflow.
5. Do not claim broker connectivity, data accuracy, or feature parity unless it has been verified.
6. Never fabricate historical trades, market prices, account statistics, or backtest results.

3. Phase Zero: Repository and Environment Reconnaissance

Before implementing features:

• Inspect the REA repository, including its README, package manifests, source code, scripts, dependencies, and supported commands.
• Verify the runtime requirements and install dependencies in an isolated development environment.
• Identify the REA capabilities relevant to code inspection, runtime inspection, application analysis, and debugging.
• Document which capabilities are supported and which require additional tools.
• Identify the local operating system, Node.js version, Python availability, MT5 terminal availability, and browser environment.
• Identify available network access and any sandbox limitations.
• Establish a Git branch, test suite, dependency lockfile, and reproducible setup instructions.
• Create an implementation plan with milestones, acceptance criteria, and a list of unresolved integration requirements.

Do not modify the user's existing trading terminal, browser profile, or account settings without authorization.

Deliverable: a repository audit and an executable implementation plan.

4. TradingView-Inspired Charting Module

Create an original interactive charting interface with:

Charts

• Candlestick, OHLC, line, area, and volume charts.
• Multiple timeframes, from tick data where supported to monthly candles.
• Zooming, panning, crosshair, synchronized cursors, and price/time scales.
• Multiple chart layouts and saved chart workspaces to local.
• Watchlists, symbol search, and instrument details from exness.
• Configurable light and dark themes.

Technical analysis

• Moving averages, EMA, SMA, RSI, MACD, Bollinger Bands, ATR, VWAP, and volume indicators .
• Trend lines, horizontal levels, channels, Fibonacci retracements, and annotations.
• Custom indicator interface and versioned indicator settings.
• Configurable alerts for prices, indicator values, and user-defined conditions.
• Historical candle replay where the data source supports it.
  -should able to save their custome setting in local

Data integrity

• Display the market-data provider and timestamp.
• Identify delayed, live, missing, and stale data.
• Handle time zones, daylight-saving changes, trading sessions, and market closures.
• Keep broker bid/ask prices distinct from chart-provider prices.

Use a legally compatible charting library or an original chart implementation.

5. MT5 Account Integration

Create a dedicated MT5 integration layer for authorized accounts.

Connection methods

Investigate and choose the most reliable supported method:

• MetaTrader 5 Python integration on a compatible local Windows environment.
• An approved broker API or bridge, if available.
• A secure local connector that communicates with the MT5 terminal.
• Read-only import of MT5 reports or account history when live connectivity is unavailable.

Do not assume MT5 can be controlled directly from every operating system or cloud sandbox.

Account features

• Account login status and connection health.
• Broker server, account currency, leverage, and margin information.
• Balance, equity, free margin, used margin, and margin level.
• Open positions, pending orders, deal history, and closed trades.
• Symbol specifications, tick size, contract size, and volume limits.
• Spread, commission, swap, slippage, and realized/unrealized P&L.
• Reconnection handling and synchronization after outages.
• Account switching with explicit user selection and clear separation of account data.

Use read-only access by default. Do not store the MT5 password in the application database. Prefer the broker terminal's supported authentication flow or another approved credential mechanism.

6. Exness Broker Integration

Implement Exness connectivity only through a supported route available to the user's actual account.

First determine:

• Whether the user has an Exness MT5 account or another account type.
• The correct broker server and account environment.
• Whether the account is demo or live.
• Which API, terminal, or bridge is officially supported for that account.
• Whether the requested market data and trading operations are permitted.

Support account discovery, connectivity checks, and account synchronization only where technically and contractually supported.

Do not invent an Exness REST endpoint or scrape the broker's private web interface as a substitute for an official integration.

Provide a connection diagnostics screen showing:

• Connection state.
• Last successful synchronization.
• Broker server and account type.
• Data freshness.
• Missing permissions or unsupported operations.
• Sanitized error messages.

If direct connectivity is unavailable, provide an import workflow for supported MT5 reports and clearly label the application as disconnected from live account data.

7. Order Management and Risk Controls

After the read-only and paper-trading stages pass validation, implement optional order management.

Supported order types should include market, limit, stop, and stop-limit orders only where the connected broker supports them.

Before order submission:

• Display the instrument, side, volume, order type, entry price or trigger, stop-loss, and take-profit.
• Estimate spread, commission, swap exposure, margin impact, and potential loss when reliable inputs are available.
• Validate symbol trading permissions, volume steps, minimum stop distances, and margin requirements.
• Display the account and environment prominently: DEMO or LIVE.
• Require explicit confirmation for every live order.
• Prevent accidental duplicate submissions using idempotency controls where possible.
• Track order status and reconcile requests against actual broker responses.
• Record rejected, partially filled, cancelled, and completed orders.

Add configurable risk limits:

• Maximum risk per trade.
• Maximum daily realized and unrealized loss.
• Maximum total open exposure.
• Maximum number of concurrent positions.
• Maximum permitted leverage or margin utilization.
• A kill switch that disables new orders.

Risk calculations must account for instrument contract specifications, account currency, conversion rates, and execution uncertainty. Never promise a guaranteed loss limit.

8. Myfxbook-Inspired Analytics Engine

Create a comprehensive trade-performance dashboard using verified account history.

Performance overview

• Starting and ending balance.
• Equity curve and drawdown curve.
• Net profit and loss.
• Gross profit and gross loss.
• Return on balance and equity.
• Profit factor.
• Win rate and loss rate.
• Average winning and losing trade.
• Average risk-to-reward ratio where valid risk data exists.
• Expectancy per trade.
• Maximum drawdown in currency and percentage.
• Recovery factor.
• Sharpe and Sortino ratios when the underlying return series is suitable.
• Consecutive wins and losses.
• Average trade duration.
• Commission, swaps, and other costs.
• Deposits and withdrawals separated from trading performance.

Clearly define every formula and its assumptions. Distinguish balance-based returns, equity-based returns, realized P&L, and open-position P&L.

Trade breakdowns

Analyze performance by:

• Instrument and asset class.
• Long versus short positions.
• Trading session and day of week.
• Hour of entry and holding duration.
• Strategy and setup.
• Risk category and position size.
• Market regime and volatility.
• Broker and account.
• Manual versus automated execution.
• Planned versus actual entry, stop, and exit.

Equity and drawdown analysis

• Daily, weekly, monthly, quarterly, and annual performance.
• Peak-to-trough drawdown.
• Drawdown duration and recovery duration.
• Return distributions.
• Rolling performance statistics.
• Trade clustering and concentration risk.
• Comparison against a suitable benchmark where reliable data exists.

Use accurate trade identifiers and distinguish orders, deals, and positions. Avoid double-counting partial closes, commissions, or reversals.

9. Automatic Trading Journal

Create a journal entry for every trade or logical trading position.

Each entry should support:

• Trade ID and broker identifiers.
• Instrument, direction, quantity, and timestamps.
• Entry, exit, stop-loss, and take-profit values.
• Planned monetary risk and actual realized P&L.
• Setup, strategy, and timeframe.
• Market conditions and relevant indicator snapshots.
• Entry rationale and exit rationale.
• Planned versus actual execution.
• Screenshots captured with user permission.
• Emotional state and discipline checklist.
• Rule violations and lessons learned.
• User notes, tags, and attachments.
• AI-generated review with editable conclusions.

Journal automation

• Generate draft entries from synchronized trade history.
• Match partial fills and partial closes correctly.
• Detect missing stop-losses and deviations from planned risk.
• Identify recurring behavioral patterns.
• Compare results by setup, session, and market regime.
• Allow users to correct imported or AI-generated classifications.
• Preserve original broker records and journal edit history.

Never infer emotions, intent, or a strategy with certainty from price data alone. Label these as user-entered information or AI hypotheses.

9A. Trade copying mechanism

-able to multiple MT5 account
-able to copy trade from master account to secondary account on setup and for copy Stoploss and target use pip size Stoploss of master account

10. AI Trade Review and Research Assistant

Create an assistant that answers questions such as:

• Which setups have the strongest historical expectancy?
• Which instruments contribute most to drawdown?
• Are trading costs eroding my strategy's edge?
• Does my performance differ between trading sessions?
• Am I consistently deviating from my planned stop-loss?
• Which rules correlate with better or worse outcomes?
• What changed in my results over the past month?
• Which journal entries need review?

The assistant must:

• Query actual stored records and show the relevant date range.
• Explain the calculations behind conclusions.
• Cite trade IDs and journal entries when possible.
• Separate observed facts from interpretations.
• Disclose small sample sizes, missing data, and uncertainty.
• Avoid guaranteed-profit claims or unsupported predictions.
• Never place trades autonomously.

Include an optional strategy-testing module with out-of-sample testing, realistic spread and commission assumptions, slippage modeling, and safeguards against look-ahead bias and overfitting.

11. Application Architecture

Use a modular architecture with clearly separated services.

Suggested components:

• Frontend: React and TypeScript.
• Backend API: a suitable TypeScript or Python framework.
• Market data service: normalized candles, quotes, and instrument metadata.
• Broker connector: isolated MT5/Exness adapter.
• Trade ingestion service: orders, deals, positions, and account snapshots.
• Analytics engine: deterministic and unit-tested financial calculations.
• Journal service: notes, tags, attachments, and trade annotations.
• AI service: structured tool access to authorized, read-only trading data.
• Database: PostgreSQL for persistent records.
• Background jobs: synchronization, reconciliation, and analytics refresh.
• Secrets storage: operating-system credential store or another suitable secure mechanism.
• Observability: structured logs, metrics, and sanitized error reporting.

Define interfaces for market-data providers and broker connectors so another provider can be added without rewriting the application.

Choose dependencies based on current compatibility, licensing, maintenance, and security. Avoid unnecessary microservices during the initial implementation.

12. Data Model

Design normalized database entities for:

• Users and local application settings.
• Broker connections and account metadata.
• Instruments and symbol specifications.
• Historical candles and quotes, where storage rights permit.
• Orders, deals, positions, and position lifecycle events.
• Account snapshots and balance transactions.
• Trade plans and risk assessments.
• Journal entries, tags, and attachments.
• Strategies and setups.
• Analytics snapshots and report definitions.
• Alerts and user notifications.
• Audit events and application permissions.

Use stable identifiers, UTC timestamps, explicit account-currency fields, decimal-safe monetary calculations, and documented relationships.

Maintain import provenance and idempotent synchronization so repeated imports do not duplicate trades.

13. Security and Privacy

Implement:

• Encryption in transit and appropriate encryption at rest.
• Local-first operation where practical.
• Least-privilege permissions.
• No credentials in logs, screenshots, source code, or analytics exports.
• Input validation and parameterized database queries.
• Dependency vulnerability checks.
• Session management and explicit logout.
• Protected exports and configurable data retention.
• Redaction of account numbers and personally identifying information.
• An audit trail for account changes and live trading actions.

Do not transmit trading history or account information to an AI provider without explicit consent and clear disclosure.

14. User Interface

Build an original, professional trading workstation with these main screens:

1. Dashboard — equity, balance, drawdown, and recent activity.
2. Charts — interactive chart workspace and technical indicators.
3. Accounts — MT5/Exness connection status and account selector.
4. Positions — open trades, orders, exposure, and risk.
5. Trade history — searchable and filterable transactions.
6. Analytics — performance, drawdowns, distributions, and comparisons.
7. Journal — trade reviews, tags, screenshots, and notes.
8. Strategy lab — backtesting and strategy comparisons.
9. Alerts — price, risk, and performance alerts.
10. Settings — integrations, security, data imports, and preferences.

Support responsive layouts, keyboard accessibility, readable tables, explicit currency and time-zone formatting, and clear error states.

Do not imitate TradingView's or Myfxbook's logos or represent the application as affiliated with either service.

15. Testing and Acceptance Criteria

Write unit, integration, and end-to-end tests.

Required checks include:

• Correct P&L calculations for long and short trades.
• Commission, swap, and currency-conversion handling.
• Partial fills, partial closes, reversals, and duplicate imports.
• Time-zone and daylight-saving boundaries.
• Equity and drawdown calculations.
• Empty accounts and incomplete history.
• Broker disconnections and expired sessions.
• Invalid symbols and rejected orders.
• Risk-limit enforcement.
• Credential redaction and permission boundaries.
• Database migrations and recovery.
• Paper-trading order lifecycle.
• Explicit confirmation for live trading.

Do not mark a feature complete merely because its screen renders. Verify its data flow and behavior.

16. Development Milestones

Milestone 1 — Reconnaissance

Inspect REA, establish the environment, document dependencies, and verify available integration methods.

Milestone 2 — Working foundation

Create the application shell, database, authentication boundary, and automated tests.

Milestone 3 — Historical data and analytics

Import supported MT5 reports and deliver correct trade history, equity curves, drawdowns, and performance metrics.

Milestone 4 — Journal

Implement automatic journal drafts, tagging, annotations, and editable trade reviews.

Milestone 5 — Charting

Integrate an original charting interface with historical market data and technical indicators.

Milestone 6 — Read-only broker integration

Connect to a supported MT5/Exness route and verify synchronization against actual account records.

Milestone 7 — Paper trading and risk controls

Validate the order lifecycle, position sizing, risk limits, and reconciliation.

Milestone 8 — Optional live execution

Enable live trading only after explicit user opt-in, documented broker support, security review, and successful end-to-end testing.

Milestone 9 — AI assistant

Add grounded analytical queries, cited trade records, and journal summaries.

Milestone 10 — Release readiness

Run regression tests, security checks, backup/recovery tests, and produce deployment documentation.

17. Required Deliverables

Produce:

• A repository and environment audit.
• An architecture document and integration decision record.
• A working codebase with a reproducible setup.
• A documented database schema and migrations.
• Automated tests and test results.
• A sample dataset clearly labeled as synthetic.
• Setup and deployment instructions.
• A configuration example containing placeholders only.
• An integration matrix showing verified, unverified, unsupported, and blocked features.
• A security and risk-control checklist.
• A roadmap for remaining work.

At each milestone, report what was actually implemented, the commands executed, the tests that passed or failed, and any remaining blockers.

Final instruction: Begin with Milestone 1. Inspect the actual REA repository and execution environment before writing code. Build a functional, testable trading analytics application incrementally. Do not pretend to have broker access, account credentials, proprietary data feeds, or successful execution that has not been verified. Keep live trading disabled until all required checks and explicit authorization are complete.