worldmonitor-intelligence-dashboard

What this skill does

# World Monitor Intelligence Dashboard

> Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection.

World Monitor is a real-time global intelligence dashboard combining AI-powered news aggregation (435+ feeds, 15 categories), dual map engine (3D globe + WebGL flat map with 45 data layers), geopolitical risk scoring, finance radar (92 exchanges), and cross-stream signal correlation — all from a single TypeScript/Vite codebase deployable as web, PWA, or native desktop (Tauri 2).

---

## Installation & Quick Start

```bash
git clone https://github.com/koala73/worldmonitor.git
cd worldmonitor
npm install
npm run dev          # Opens http://localhost:5173
```

No environment variables required for basic operation. All features work with local Ollama by default.

### Site Variants

```bash
npm run dev:tech       # tech.worldmonitor.app variant
npm run dev:finance    # finance.worldmonitor.app variant
npm run dev:commodity  # commodity.worldmonitor.app variant
npm run dev:happy      # happy.worldmonitor.app variant
```

### Production Build

```bash
npm run typecheck        # TypeScript validation
npm run build:full       # Build all variants
npm run build            # Build default (world) variant
```

---

## Project Structure

```
worldmonitor/
├── src/
│   ├── components/       # UI components (TypeScript)
│   ├── feeds/            # 435+ RSS/API feed definitions
│   ├── layers/           # Map data layers (deck.gl)
│   ├── ai/               # AI synthesis pipeline
│   ├── signals/          # Cross-stream correlation engine
│   ├── finance/          # Market data (92 exchanges)
│   ├── variants/         # Site variant configs (world/tech/finance/commodity/happy)
│   └── protos/           # Protocol Buffer definitions (92 protos, 22 services)
├── api/                  # Vercel Edge Functions (60+)
├── src-tauri/            # Tauri 2 desktop app (Rust)
├── docs/                 # Documentation source
└── vite.config.ts
```

---

## Environment Variables

Create a `.env.local` file (never commit secrets):

```bash
# AI Providers (all optional — Ollama works with no keys)
VITE_OLLAMA_BASE_URL=http://localhost:11434       # Local Ollama instance
VITE_GROQ_API_KEY=$GROQ_API_KEY                  # Groq cloud inference
VITE_OPENROUTER_API_KEY=$OPENROUTER_API_KEY      # OpenRouter multi-model

# Caching (optional, improves performance)
UPSTASH_REDIS_REST_URL=$UPSTASH_REDIS_REST_URL
UPSTASH_REDIS_REST_TOKEN=$UPSTASH_REDIS_REST_TOKEN

# Map tiles (optional, MapLibre GL)
VITE_MAPTILER_API_KEY=$MAPTILER_API_KEY

# Variant selection
VITE_SITE_VARIANT=world   # world | tech | finance | commodity | happy
```

---

## Core Concepts

### Feed Categories

World Monitor aggregates 435+ feeds across 15 categories:

```typescript
// src/feeds/categories.ts pattern
import type { FeedCategory } from './types';

const FEED_CATEGORIES: FeedCategory[] = [
  'geopolitics',
  'military',
  'economics',
  'technology',
  'climate',
  'energy',
  'health',
  'finance',
  'commodities',
  'infrastructure',
  'cyber',
  'space',
  'diplomacy',
  'disasters',
  'society',
];
```

### Country Intelligence Index

Composite risk scoring across 12 signal categories per country:

```typescript
// Example: accessing country risk scores
import { CountryIntelligence } from './signals/country-intelligence';

const intel = new CountryIntelligence();

// Get composite risk score for a country
const score = await intel.getCountryScore('UA');
console.log(score);
// {
//   composite: 0.82,
//   signals: {
//     military: 0.91,
//     economic: 0.74,
//     political: 0.88,
//     humanitarian: 0.79,
//     ...
//   },
//   trend: 'escalating',
//   updatedAt: '2026-03-17T08:00:00Z'
// }

// Subscribe to real-time updates
intel.subscribe('UA', (update) => {
  console.log('Risk update:', update);
});
```

### AI Synthesis Pipeline

```typescript
// src/ai/synthesize.ts pattern
import { AISynthesizer } from './ai/synthesizer';

const synth = new AISynthesizer({
  provider: 'ollama',           // 'ollama' | 'groq' | 'openrouter'
  model: 'llama3.2',            // any Ollama-compatible model
  baseUrl: process.env.VITE_OLLAMA_BASE_URL,
});

// Synthesize a news brief from multiple feed items
const brief = await synth.synthesize({
  items: feedItems,             // FeedItem[]
  category: 'geopolitics',
  region: 'Europe',
  maxTokens: 500,
  language: 'en',
});

console.log(brief.summary);    // AI-generated synthesis
console.log(brief.signals);    // Extracted signals array
console.log(brief.confidence); // 0-1 confidence score
```

### Cross-Stream Signal Correlation

```typescript
// src/signals/correlator.ts pattern
import { SignalCorrelator } from './signals/correlator';

const correlator = new SignalCorrelator();

// Detect convergence across military, economic, disaster signals
const convergence = await correlator.detectConvergence({
  streams: ['military', 'economic', 'disaster', 'escalation'],
  timeWindow: '6h',
  threshold: 0.7,
  region: 'Middle East',
});

if (convergence.detected) {
  console.log('Convergence signals:', convergence.signals);
  console.log('Escalation probability:', convergence.probability);
  console.log('Contributing events:', convergence.events);
}
```

---

## Map Engine Integration

### 3D Globe (globe.gl)

```typescript
// src/components/globe/GlobeView.ts
import Globe from 'globe.gl';
import { getCountryRiskData } from '../signals/country-intelligence';

export function initGlobe(container: HTMLElement) {
  const globe = Globe()(container)
    .globeImageUrl('//unpkg.com/three-globe/example/img/earth-dark.jpg')
    .backgroundImageUrl('//unpkg.com/three-globe/example/img/night-sky.png');

  // Load country risk layer
  const riskData = await getCountryRiskData();

  globe
    .polygonsData(riskData.features)
    .polygonCapColor(feat => riskToColor(feat.properties.riskScore))
    .polygonSideColor(() => 'rgba(0, 100, 0, 0.15)')
    .polygonLabel(({ properties: d }) =>
      `<b>${d.name}</b><br/>Risk: ${(d.riskScore * 100).toFixed(0)}%`
    );

  return globe;
}

function riskToColor(score: number): string {
  if (score > 0.8) return 'rgba(220, 38, 38, 0.8)';   // critical
  if (score > 0.6) return 'rgba(234, 88, 12, 0.7)';   // high
  if (score > 0.4) return 'rgba(202, 138, 4, 0.6)';   // elevated
  if (score > 0.2) return 'rgba(22, 163, 74, 0.5)';   // low
  return 'rgba(15, 118, 110, 0.4)';                    // minimal
}
```

### WebGL Flat Map (deck.gl + MapLibre GL)

```typescript
// src/components/map/DeckMap.ts
import { Deck } from '@deck.gl/core';
import { ScatterplotLayer, ArcLayer, HeatmapLayer } from '@deck.gl/layers';
import maplibregl from 'maplibre-gl';

export function initDeckMap(container: HTMLElement) {
  const map = new maplibregl.Map({
    container,
    style: 'https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json',
    center: [0, 20],
    zoom: 2,
  });

  const deck = new Deck({
    canvas: 'deck-canvas',
    initialViewState: { longitude: 0, latitude: 20, zoom: 2 },
    controller: true,
    layers: [
      // Event scatter layer
      new ScatterplotLayer({
        id: 'events',
        data: getActiveEvents(),
        getPosition: d => [d.lng, d.lat],
        getRadius: d => d.severity * 50000,
        getFillColor: d => severityToRGBA(d.severity),
        pickable: true,
      }),
      // Supply chain arc layer
      new ArcLayer({
        id: 'supply-chains',
        data: getSupplyChainData(),
        getSourcePosition: d => d.source,
        getTargetPosition: d => d.target,
        getSourceColor: [0, 128, 200],
        getTargetColor: [200, 0, 80],
        getWidth: 2,
      }),
    ],
  });

  return { map, deck };
}
```

---

## Finance Radar

```typescript
// src/finance/radar.ts pattern
import { FinanceRadar } from './finance/radar';

const radar = new FinanceRadar();

// Get market composite (7-signal)
const composite = await radar.getMarketComposite();
console.log(composite);
// {
//   score: 0.62,
//   s