mia-code 0.2.0

package/samples/copilot/session-state/be76abaa-a27f-4725-b2a9-22fb45f7e0f7/plan.md

@@ -0,0 +1,243 @@
+# JGT Data Service - Docker Container Architecture Plan
+
+## 📋 Problem Statement
+
+Create a Docker-containerized data service layer that:
+1. Manages market data (PDS/CDS/TTF/MLF) with filesystem persistence
+2. Self-refreshes based on timeframe schedules (H1 at :00, m15 at :15/:30/:45/:00, m5 every 5min)
+3. Exposes a versatile REST API for data distribution
+4. Supports broker configuration
+5. Provides MCP wrapper for jgt-code and agent integration
+6. Remains compatible with future jgtml/FDBScanner container
+
+---
+
+## 🎯 Proposed Approach: JGT Data Server (`jgt-data-server`)
+
+A single Docker Compose stack with two services:
+1. **jgt-data-server** - Python FastAPI service (data refresh + API)
+2. **jgt-data-mcp** - Node.js MCP server (wraps the API for agent access)
+
+### Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  Docker Compose Stack: jgt-data-server                              │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  ┌─────────────────────────────────┐  ┌───────────────────────────┐ │
+│  │  jgt-data-server (Python)       │  │  jgt-data-mcp (Node.js)   │ │
+│  │  - FastAPI on :8080             │  │  - MCP Server on :8090    │ │
+│  │  - Scheduler (timeframe-based)  │◄─│  - Wraps API for agents   │ │
+│  │  - Processor (jgtpy/jgtfxcon)   │  │  - jgt-code compatible    │ │
+│  └─────────────────────────────────┘  └───────────────────────────┘ │
+│                ▼                                                    │
+│  ┌─────────────────────────────────────────────────────────────────┐│
+│  │  Mounted Volumes                                                 ││
+│  │  /data/current → pds/, cds/, ttf/, mlf/                         ││
+│  │  /config → config.json, .env                                    ││
+│  └─────────────────────────────────────────────────────────────────┘│
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 📡 API Design
+
+### Base Routes
+```
+GET  /api/v1/health
+GET  /api/v1/status
+GET  /api/v1/instruments
+GET  /api/v1/timeframes
+```
+
+### Data Access (per instrument/timeframe)
+```
+GET  /api/v1/pds/{instrument}/{timeframe}        # Price data
+GET  /api/v1/cds/{instrument}/{timeframe}        # Signals/indicators
+GET  /api/v1/ttf/{instrument}/{timeframe}        # Cross-timeframe features
+GET  /api/v1/mlf/{instrument}/{timeframe}        # Meta lag features
+
+# Latest record
+GET  /api/v1/{type}/{instrument}/{timeframe}/latest
+
+# With query params: ?limit=100&format=json|csv
+```
+
+### Perspective Compositions
+```
+GET  /api/v1/perspective/{instrument}            # Full multi-TF view for charting
+GET  /api/v1/perspective/{instrument}/{timeframes}  # Specific TF composition
+
+# Response includes all data types across requested timeframes
+```
+
+### Service Control
+```
+POST /api/v1/refresh                             # Trigger manual refresh
+POST /api/v1/refresh/{instrument}/{timeframe}    # Specific refresh
+
+GET  /api/v1/scheduler/status                    # Scheduler state
+GET  /api/v1/scheduler/next                      # Next scheduled refresh times
+```
+
+---
+
+## 📁 Directory Structure
+
+```
+jgt-data-server/
+├── docker-compose.yml
+├── .env.example
+├── README.md
+│
+├── server/                          # Python FastAPI service
+│   ├── Dockerfile
+│   ├── requirements.txt
+│   ├── pyproject.toml
+│   ├── src/
+│   │   ├── main.py                  # Entry point
+│   │   ├── config.py                # Configuration
+│   │   ├── api/
+│   │   │   ├── __init__.py
+│   │   │   ├── routes.py            # API routes
+│   │   │   ├── perspectives.py      # Composition endpoints
+│   │   │   └── scheduler_routes.py
+│   │   ├── scheduler/
+│   │   │   ├── __init__.py
+│   │   │   └── timeframe_scheduler.py
+│   │   └── processor/
+│   │       ├── __init__.py
+│   │       └── data_processor.py
+│   └── tests/
+│
+├── mcp/                             # Node.js MCP wrapper
+│   ├── Dockerfile
+│   ├── package.json
+│   ├── tsconfig.json
+│   └── src/
+│       ├── index.ts                 # MCP server
+│       ├── tools.ts                 # Tool definitions
+│       └── client.ts                # API client
+│
+└── config/                          # Example configuration
+    └── config.example.json
+```
+
+---
+
+## ⏰ Scheduler Logic
+
+```python
+TIMEFRAME_REFRESH_TIMES = {
+    'm1':  every_minute,
+    'm5':  [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55],
+    'm15': [0, 15, 30, 45],
+    'm30': [0, 30],
+    'H1':  [0],          # Every hour at :00
+    'H4':  [0],          # Every 4 hours (0:00, 4:00, 8:00, etc.)
+    'D1':  [0],          # Daily at midnight
+    'W1':  [0],          # Weekly (Sunday midnight)
+    'M1':  [0],          # Monthly (1st at midnight)
+}
+```
+
+---
+
+## 🔧 Configuration
+
+### Environment Variables
+```bash
+# Broker
+JGT_CONFIG_JSON_SECRET='{"user_id":"...","password":"...","url":"...","connection":"Demo"}'
+# Or mount config file
+JGT_CONFIG_PATH=/config/config.json
+
+# Data paths
+JGTPY_DATA=/data/current
+JGTPY_DATA_FULL=/data/full
+
+# Service
+JGTPY_SERVICE_INSTRUMENTS=EUR/USD,XAU/USD,SPX500
+JGTPY_SERVICE_TIMEFRAMES=m5,m15,H1,H4,D1
+JGTPY_SERVICE_PARALLEL_WORKERS=4
+JGTPY_SERVICE_WEB_PORT=8080
+
+# Upload (optional)
+JGTPY_DROPBOX_APP_TOKEN=...
+```
+
+---
+
+## 🔌 MCP Integration
+
+MCP tools exposed to jgt-code and other agents:
+
+```typescript
+// Tools
+get_market_data({ instrument, timeframe, type: 'pds'|'cds'|'ttf'|'mlf', limit? })
+get_perspective({ instrument, timeframes?: string[] })
+trigger_refresh({ instruments?: string[], timeframes?: string[] })
+get_latest_signals({ instrument, timeframe })
+get_scheduler_status()
+```
+
+---
+
+## 📝 Workplan
+
+### Phase 1: Core Infrastructure
+- [ ] Create directory structure at `/b/trading/jgt-data-server/`
+- [ ] Create Docker Compose configuration
+- [ ] Create server Dockerfile (based on existing jgtpy/jgtfxcon patterns)
+- [ ] Create MCP service Dockerfile
+
+### Phase 2: Python API Server
+- [ ] Implement main.py entry point
+- [ ] Implement config.py (from JGTServiceConfig patterns)
+- [ ] Implement API routes (extend existing api.py)
+- [ ] Implement perspective composition endpoints
+- [ ] Implement scheduler (from existing scheduler.py patterns)
+- [ ] Implement processor (reuse existing processor.py)
+
+### Phase 3: MCP Wrapper
+- [ ] Create MCP package.json and TypeScript config
+- [ ] Implement MCP server with tools
+- [ ] Implement API client for data server
+- [ ] Test integration with jgt-code
+
+### Phase 4: Integration & Testing
+- [ ] Create example configuration
+- [ ] Create README with usage instructions
+- [ ] Test full workflow (startup, refresh, API access, MCP)
+- [ ] Validate compatibility with jgt-code patterns
+
+---
+
+## 🔗 Future Compatibility (jgtml/FDBScanner)
+
+The architecture is designed for extension:
+
+```yaml
+# Future addition to docker-compose.yml
+jgt-ml-server:
+  build: ../jgtml-server
+  depends_on:
+    - jgt-data-server
+  volumes:
+    - jgt-data:/data  # Shared with data server
+  environment:
+    - JGT_DATA_API=http://jgt-data-server:8080
+```
+
+jgtml will consume data from jgt-data-server's API rather than filesystem directly.
+
+---
+
+## ✅ Notes
+
+1. **Reusing existing code**: Maximum reuse from jgtpy/service/ (api.py, scheduler.py, processor.py, base.py)
+2. **Broker config**: Using established JGT_CONFIG_JSON_SECRET pattern from jgtutils/jgtcommon.py
+3. **jgt-code compatibility**: MCP wrapper follows same patterns as coaia-client.ts
+4. **Volume design**: Data mounted at /data, config at /config - cleanly separable

package/samples/copilot/session-state/be76abaa-a27f-4725-b2a9-22fb45f7e0f7/workspace.yaml

@@ -0,0 +1,5 @@
+id: be76abaa-a27f-4725-b2a9-22fb45f7e0f7
+summary_count: 0
+created_at: 2026-01-23T12:45:07.084Z
+updated_at: 2026-01-23T12:49:44.989Z
+summary: we will want our whole layer that deals with updating prices, indicators and signals (most likely @j...