@framers/agentos-ext-weather 1.0.0 → 1.1.0

package/src/index.ts

@@ -1,60 +0,0 @@
-import type {
-  ExtensionPackContext,
-  ExtensionPack,
-  ExtensionLifecycleContext,
-} from '@framers/agentos';
-
-import { WeatherService } from './services/weatherService.js';
-import { WeatherLookupTool } from './tools/weatherLookup.js';
-
-export interface WeatherExtensionOptions {
-  weatherApiKey?: string;
-  priority?: number;
-}
-
-export function createExtensionPack(context: ExtensionPackContext): ExtensionPack {
-  const options = (context.options ?? {}) as WeatherExtensionOptions;
-
-  const weatherApiKey =
-    options.weatherApiKey ||
-    context.getSecret?.('weather.weatherApiKey') ||
-    process.env.WEATHERAPI_KEY;
-
-  const service = new WeatherService(weatherApiKey);
-  const tool = new WeatherLookupTool(service);
-
-  return {
-    name: '@framers/agentos-ext-weather',
-    version: '1.0.0',
-    descriptors: [
-      {
-        id: tool.name,
-        kind: 'tool',
-        priority: options.priority ?? 50,
-        payload: tool,
-        requiredSecrets: [{ id: 'weather.weatherApiKey', optional: true }],
-      },
-    ],
-    onActivate: async (lc?: ExtensionLifecycleContext) => {
-      const provider = service.hasWeatherApiKey
-        ? 'WeatherAPI.com (preferred) + Open-Meteo fallback'
-        : 'Open-Meteo only (set WEATHERAPI_KEY for WeatherAPI.com)';
-      lc?.logger?.info(`Weather Extension activated — ${provider}`);
-    },
-    onDeactivate: async (lc?: ExtensionLifecycleContext) => {
-      lc?.logger?.info('Weather Extension deactivated');
-    },
-  };
-}
-
-export { WeatherService } from './services/weatherService.js';
-export { WeatherLookupTool } from './tools/weatherLookup.js';
-export type {
-  WeatherResult,
-  GeoLocation,
-  CurrentWeather,
-  ForecastDay,
-  WeatherAlert,
-} from './services/weatherService.js';
-export type { WeatherLookupInput } from './tools/weatherLookup.js';
-export default createExtensionPack;

package/src/services/weatherService.ts

@@ -1,275 +0,0 @@
-/**
- * Dual-provider weather service.
- *
- * Provider priority:
- *   1. WeatherAPI.com — preferred when WEATHERAPI_KEY is configured
- *   2. Open-Meteo     — always-available fallback (no key required)
- *
- * Geocoding is handled by the Open-Meteo Geocoding API (free, no key).
- */
-
-// ── Types ──────────────────────────────────────────────────────────────────
-
-export interface GeoLocation {
-  name: string;
-  region: string;
-  country: string;
-  lat: number;
-  lon: number;
-  timezone: string;
-}
-
-export interface CurrentWeather {
-  temp_f: number;
-  temp_c: number;
-  condition: string;
-  humidity: number;
-  wind_mph: number;
-  wind_dir: string;
-  uv: number;
-  feels_like_f: number;
-}
-
-export interface ForecastDay {
-  date: string;
-  max_f: number;
-  min_f: number;
-  max_c: number;
-  min_c: number;
-  condition: string;
-  precip_chance: number;
-  wind_max_mph: number;
-  uv_max: number;
-}
-
-export interface WeatherAlert {
-  headline: string;
-  severity: string;
-  description: string;
-}
-
-export interface WeatherResult {
-  provider: 'weatherapi' | 'open-meteo';
-  location: GeoLocation;
-  current?: CurrentWeather;
-  forecast: ForecastDay[];
-  alerts?: WeatherAlert[];
-}
-
-// ── WMO weather code → human-readable condition ────────────────────────────
-
-const WMO_CODES: Record<number, string> = {
-  0: 'Clear sky',
-  1: 'Mainly clear',
-  2: 'Partly cloudy',
-  3: 'Overcast',
-  45: 'Fog',
-  48: 'Depositing rime fog',
-  51: 'Light drizzle',
-  53: 'Moderate drizzle',
-  55: 'Dense drizzle',
-  56: 'Light freezing drizzle',
-  57: 'Dense freezing drizzle',
-  61: 'Slight rain',
-  63: 'Moderate rain',
-  65: 'Heavy rain',
-  66: 'Light freezing rain',
-  67: 'Heavy freezing rain',
-  71: 'Slight snow',
-  73: 'Moderate snow',
-  75: 'Heavy snow',
-  77: 'Snow grains',
-  80: 'Slight rain showers',
-  81: 'Moderate rain showers',
-  82: 'Violent rain showers',
-  85: 'Slight snow showers',
-  86: 'Heavy snow showers',
-  95: 'Thunderstorm',
-  96: 'Thunderstorm with slight hail',
-  99: 'Thunderstorm with heavy hail',
-};
-
-function wmoToCondition(code: number): string {
-  return WMO_CODES[code] ?? `Unknown (${code})`;
-}
-
-/** Convert Fahrenheit to Celsius, rounded to 1 decimal. */
-function fToC(f: number): number {
-  return Math.round(((f - 32) * 5) / 9 * 10) / 10;
-}
-
-// ── Service ────────────────────────────────────────────────────────────────
-
-export class WeatherService {
-  constructor(private readonly weatherApiKey?: string) {}
-
-  get hasWeatherApiKey(): boolean {
-    return !!this.weatherApiKey;
-  }
-
-  /** Geocode a location string to coordinates via Open-Meteo. */
-  async geocode(location: string): Promise<GeoLocation> {
-    const url = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(location)}&count=1&language=en&format=json`;
-    const res = await fetch(url);
-    if (!res.ok) {
-      throw new Error(`Geocoding failed (${res.status}): ${res.statusText}`);
-    }
-
-    const data = (await res.json()) as any;
-    const results = data.results;
-    if (!results || results.length === 0) {
-      throw new Error(`Location not found: "${location}"`);
-    }
-
-    const r = results[0];
-    return {
-      name: r.name,
-      region: r.admin1 ?? '',
-      country: r.country ?? '',
-      lat: r.latitude,
-      lon: r.longitude,
-      timezone: r.timezone ?? 'UTC',
-    };
-  }
-
-  /** Main entry: get weather for a location string. */
-  async getWeather(location: string, days: number = 3): Promise<WeatherResult> {
-    const geo = await this.geocode(location);
-
-    // Try WeatherAPI.com first if key is available
-    if (this.weatherApiKey) {
-      try {
-        return await this.fetchWeatherApi(geo, days);
-      } catch {
-        // Fall through to Open-Meteo
-      }
-    }
-
-    return this.fetchOpenMeteo(geo, days);
-  }
-
-  // ── WeatherAPI.com ─────────────────────────────────────────────────────
-
-  private async fetchWeatherApi(geo: GeoLocation, days: number): Promise<WeatherResult> {
-    const clampedDays = Math.min(days, 3); // free tier = 3 days max
-    const q = `${geo.lat},${geo.lon}`;
-    const url = `https://api.weatherapi.com/v1/forecast.json?key=${this.weatherApiKey}&q=${q}&days=${clampedDays}&aqi=no&alerts=yes`;
-
-    const res = await fetch(url);
-    if (!res.ok) {
-      const body = await res.text().catch(() => '');
-      throw new Error(`WeatherAPI error (${res.status}): ${body}`);
-    }
-
-    const data = (await res.json()) as any;
-    const loc = data.location ?? {};
-    const cur = data.current ?? {};
-    const forecastDays: ForecastDay[] = (data.forecast?.forecastday ?? []).map((fd: any) => ({
-      date: fd.date,
-      max_f: fd.day?.maxtemp_f ?? 0,
-      min_f: fd.day?.mintemp_f ?? 0,
-      max_c: fd.day?.maxtemp_c ?? 0,
-      min_c: fd.day?.mintemp_c ?? 0,
-      condition: fd.day?.condition?.text ?? 'Unknown',
-      precip_chance: fd.day?.daily_chance_of_rain ?? 0,
-      wind_max_mph: fd.day?.maxwind_mph ?? 0,
-      uv_max: fd.day?.uv ?? 0,
-    }));
-
-    const alerts: WeatherAlert[] = (data.alerts?.alert ?? []).map((a: any) => ({
-      headline: a.headline ?? '',
-      severity: a.severity ?? '',
-      description: a.desc ?? a.event ?? '',
-    }));
-
-    return {
-      provider: 'weatherapi',
-      location: {
-        name: loc.name ?? geo.name,
-        region: loc.region ?? geo.region,
-        country: loc.country ?? geo.country,
-        lat: loc.lat ?? geo.lat,
-        lon: loc.lon ?? geo.lon,
-        timezone: loc.tz_id ?? geo.timezone,
-      },
-      current: {
-        temp_f: cur.temp_f ?? 0,
-        temp_c: cur.temp_c ?? 0,
-        condition: cur.condition?.text ?? 'Unknown',
-        humidity: cur.humidity ?? 0,
-        wind_mph: cur.wind_mph ?? 0,
-        wind_dir: cur.wind_dir ?? '',
-        uv: cur.uv ?? 0,
-        feels_like_f: cur.feelslike_f ?? 0,
-      },
-      forecast: forecastDays,
-      alerts: alerts.length > 0 ? alerts : undefined,
-    };
-  }
-
-  // ── Open-Meteo ─────────────────────────────────────────────────────────
-
-  private async fetchOpenMeteo(geo: GeoLocation, days: number): Promise<WeatherResult> {
-    const clampedDays = Math.min(days, 16);
-    const hourlyVars = 'temperature_2m,relative_humidity_2m,wind_speed_10m,precipitation_probability,weather_code';
-    const dailyVars = 'weather_code,temperature_2m_max,temperature_2m_min,precipitation_sum,precipitation_probability_max,wind_speed_10m_max,uv_index_max';
-    const url =
-      `https://api.open-meteo.com/v1/forecast` +
-      `?latitude=${geo.lat}&longitude=${geo.lon}` +
-      `&hourly=${hourlyVars}` +
-      `&daily=${dailyVars}` +
-      `&current=temperature_2m,relative_humidity_2m,wind_speed_10m,wind_direction_10m,weather_code` +
-      `&temperature_unit=fahrenheit` +
-      `&wind_speed_unit=mph` +
-      `&timezone=auto` +
-      `&forecast_days=${clampedDays}`;
-
-    const res = await fetch(url);
-    if (!res.ok) {
-      throw new Error(`Open-Meteo error (${res.status}): ${res.statusText}`);
-    }
-
-    const data = (await res.json()) as any;
-    const cur = data.current ?? {};
-    const daily = data.daily ?? {};
-
-    const forecastDays: ForecastDay[] = [];
-    const dates: string[] = daily.time ?? [];
-    for (let i = 0; i < dates.length; i++) {
-      const maxF = daily.temperature_2m_max?.[i] ?? 0;
-      const minF = daily.temperature_2m_min?.[i] ?? 0;
-      forecastDays.push({
-        date: dates[i],
-        max_f: maxF,
-        min_f: minF,
-        max_c: fToC(maxF),
-        min_c: fToC(minF),
-        condition: wmoToCondition(daily.weather_code?.[i] ?? 0),
-        precip_chance: daily.precipitation_probability_max?.[i] ?? 0,
-        wind_max_mph: daily.wind_speed_10m_max?.[i] ?? 0,
-        uv_max: daily.uv_index_max?.[i] ?? 0,
-      });
-    }
-
-    const tempF = cur.temperature_2m ?? 0;
-    const windDir = cur.wind_direction_10m ?? 0;
-    const cardinals = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE', 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
-    const windDirStr = cardinals[Math.round(windDir / 22.5) % 16];
-
-    return {
-      provider: 'open-meteo',
-      location: geo,
-      current: {
-        temp_f: tempF,
-        temp_c: fToC(tempF),
-        condition: wmoToCondition(cur.weather_code ?? 0),
-        humidity: cur.relative_humidity_2m ?? 0,
-        wind_mph: cur.wind_speed_10m ?? 0,
-        wind_dir: windDirStr,
-        uv: forecastDays[0]?.uv_max ?? 0,
-        feels_like_f: tempF, // Open-Meteo free doesn't provide feels-like
-      },
-      forecast: forecastDays,
-    };
-  }
-}

package/src/tools/weatherLookup.ts

@@ -1,77 +0,0 @@
-import type {
-  ITool,
-  ToolExecutionContext,
-  ToolExecutionResult,
-  JSONSchemaObject,
-} from '@framers/agentos';
-
-import { WeatherService } from '../services/weatherService.js';
-import type { WeatherResult } from '../services/weatherService.js';
-
-export interface WeatherLookupInput {
-  location: string;
-  days?: number;
-}
-
-export class WeatherLookupTool implements ITool<WeatherLookupInput, WeatherResult> {
-  readonly id = 'weather-lookup-v1';
-  readonly name = 'weather_lookup';
-  readonly displayName = 'Weather Lookup';
-  readonly description =
-    'Get current weather conditions and forecasts for any location. Returns temperature (F/C), humidity, wind, precipitation, UV index, and severe weather alerts.';
-  readonly category = 'research';
-  readonly version = '1.0.0';
-  readonly hasSideEffects = false;
-
-  readonly inputSchema: JSONSchemaObject = {
-    type: 'object',
-    required: ['location'],
-    properties: {
-      location: {
-        type: 'string',
-        description: 'City name, zip code, or lat,lon coordinates (e.g. "Las Vegas", "90210", "36.17,-115.14")',
-      },
-      days: {
-        type: 'integer',
-        minimum: 1,
-        maximum: 14,
-        default: 3,
-        description: 'Number of forecast days (1-14, default 3)',
-      },
-    },
-    additionalProperties: false,
-  };
-
-  readonly requiredCapabilities = ['capability:web_access'];
-
-  constructor(private readonly service: WeatherService) {}
-
-  async execute(
-    args: WeatherLookupInput,
-    _context: ToolExecutionContext,
-  ): Promise<ToolExecutionResult<WeatherResult>> {
-    if (!args.location || args.location.trim().length === 0) {
-      return { success: false, error: 'Location is required.' };
-    }
-
-    try {
-      const result = await this.service.getWeather(args.location.trim(), args.days ?? 3);
-      return { success: true, output: result };
-    } catch (err: any) {
-      return { success: false, error: `Weather lookup failed: ${err.message}` };
-    }
-  }
-
-  validateArgs(input: Record<string, any>): { isValid: boolean; errors?: any[] } {
-    const errors: string[] = [];
-    if (!input.location || typeof input.location !== 'string') {
-      errors.push('location is required and must be a string');
-    }
-    if (input.days !== undefined) {
-      if (typeof input.days !== 'number' || input.days < 1 || input.days > 14) {
-        errors.push('days must be an integer between 1 and 14');
-      }
-    }
-    return { isValid: errors.length === 0, errors: errors.length ? errors : undefined };
-  }
-}

package/test/weatherLookup.spec.ts

@@ -1,270 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-const mockFetch = vi.fn();
-vi.stubGlobal('fetch', mockFetch);
-
-// Dynamic import after stubbing fetch
-const { WeatherService } = await import('../src/services/weatherService.js');
-const { WeatherLookupTool } = await import('../src/tools/weatherLookup.js');
-const { createExtensionPack } = await import('../src/index.js');
-
-// ── Fixtures ──────────────────────────────────────────────────────────────
-
-const GEOCODE_RESPONSE = {
-  results: [
-    {
-      name: 'Las Vegas',
-      admin1: 'Nevada',
-      country: 'United States',
-      latitude: 36.175,
-      longitude: -115.1372,
-      timezone: 'America/Los_Angeles',
-    },
-  ],
-};
-
-const WEATHERAPI_RESPONSE = {
-  location: {
-    name: 'Las Vegas',
-    region: 'Nevada',
-    country: 'United States of America',
-    lat: 36.17,
-    lon: -115.14,
-    tz_id: 'America/Los_Angeles',
-  },
-  current: {
-    temp_f: 95.0,
-    temp_c: 35.0,
-    condition: { text: 'Sunny' },
-    humidity: 12,
-    wind_mph: 8.1,
-    wind_dir: 'SW',
-    uv: 9.0,
-    feelslike_f: 93.0,
-  },
-  forecast: {
-    forecastday: [
-      {
-        date: '2026-02-23',
-        day: {
-          maxtemp_f: 97.0,
-          mintemp_f: 72.0,
-          maxtemp_c: 36.1,
-          mintemp_c: 22.2,
-          condition: { text: 'Sunny' },
-          daily_chance_of_rain: 0,
-          maxwind_mph: 12.5,
-          uv: 9.0,
-        },
-      },
-    ],
-  },
-  alerts: { alert: [] },
-};
-
-const OPENMETEO_RESPONSE = {
-  latitude: 36.175,
-  longitude: -115.1372,
-  timezone: 'America/Los_Angeles',
-  current: {
-    temperature_2m: 92.0,
-    relative_humidity_2m: 15,
-    wind_speed_10m: 7.5,
-    wind_direction_10m: 225,
-    weather_code: 0,
-  },
-  daily: {
-    time: ['2026-02-23', '2026-02-24', '2026-02-25'],
-    weather_code: [0, 1, 3],
-    temperature_2m_max: [96.0, 94.0, 90.0],
-    temperature_2m_min: [71.0, 70.0, 68.0],
-    precipitation_sum: [0, 0, 0.1],
-    precipitation_probability_max: [0, 5, 20],
-    wind_speed_10m_max: [12.0, 10.0, 15.0],
-    uv_index_max: [9.0, 8.5, 7.0],
-  },
-};
-
-// ── Tests ─────────────────────────────────────────────────────────────────
-
-describe('WeatherService', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('geocode', () => {
-    it('resolves a city name to coordinates', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => GEOCODE_RESPONSE,
-      });
-
-      const service = new WeatherService();
-      const geo = await service.geocode('Las Vegas');
-
-      expect(geo.name).toBe('Las Vegas');
-      expect(geo.lat).toBe(36.175);
-      expect(geo.lon).toBe(-115.1372);
-      expect(geo.region).toBe('Nevada');
-    });
-
-    it('throws on empty results', async () => {
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => ({ results: [] }),
-      });
-
-      const service = new WeatherService();
-      await expect(service.geocode('xyznonexistent')).rejects.toThrow('Location not found');
-    });
-  });
-
-  describe('getWeather with WeatherAPI.com', () => {
-    it('uses WeatherAPI when key is provided', async () => {
-      // geocode call
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => GEOCODE_RESPONSE,
-      });
-      // weatherapi call
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => WEATHERAPI_RESPONSE,
-      });
-
-      const service = new WeatherService('test-key-123');
-      const result = await service.getWeather('Las Vegas', 3);
-
-      expect(result.provider).toBe('weatherapi');
-      expect(result.current?.temp_f).toBe(95.0);
-      expect(result.current?.condition).toBe('Sunny');
-      expect(result.forecast).toHaveLength(1);
-      expect(result.forecast[0].max_f).toBe(97.0);
-    });
-
-    it('falls back to Open-Meteo when WeatherAPI fails', async () => {
-      // geocode call
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => GEOCODE_RESPONSE,
-      });
-      // weatherapi fails
-      mockFetch.mockResolvedValueOnce({
-        ok: false,
-        status: 403,
-        text: async () => 'Forbidden',
-      });
-      // open-meteo call
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => OPENMETEO_RESPONSE,
-      });
-
-      const service = new WeatherService('bad-key');
-      const result = await service.getWeather('Las Vegas', 3);
-
-      expect(result.provider).toBe('open-meteo');
-      expect(result.current?.temp_f).toBe(92.0);
-      expect(result.forecast).toHaveLength(3);
-    });
-  });
-
-  describe('getWeather with Open-Meteo fallback', () => {
-    it('uses Open-Meteo when no key is provided', async () => {
-      // geocode call
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => GEOCODE_RESPONSE,
-      });
-      // open-meteo call
-      mockFetch.mockResolvedValueOnce({
-        ok: true,
-        json: async () => OPENMETEO_RESPONSE,
-      });
-
-      const service = new WeatherService();
-      const result = await service.getWeather('Las Vegas', 3);
-
-      expect(result.provider).toBe('open-meteo');
-      expect(result.location.name).toBe('Las Vegas');
-      expect(result.current?.humidity).toBe(15);
-      expect(result.current?.wind_dir).toBe('SW');
-      expect(result.forecast).toHaveLength(3);
-      expect(result.forecast[0].condition).toBe('Clear sky');
-      expect(result.forecast[1].condition).toBe('Mainly clear');
-      expect(result.forecast[2].condition).toBe('Overcast');
-    });
-  });
-});
-
-describe('WeatherLookupTool', () => {
-  let tool: InstanceType<typeof WeatherLookupTool>;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    const service = new WeatherService('test-key');
-    tool = new WeatherLookupTool(service);
-  });
-
-  it('has correct metadata', () => {
-    expect(tool.id).toBe('weather-lookup-v1');
-    expect(tool.name).toBe('weather_lookup');
-    expect(tool.category).toBe('research');
-    expect(tool.hasSideEffects).toBe(false);
-  });
-
-  it('has valid input schema', () => {
-    expect(tool.inputSchema.type).toBe('object');
-    expect(tool.inputSchema.required).toContain('location');
-    expect(tool.inputSchema.properties).toHaveProperty('location');
-    expect(tool.inputSchema.properties).toHaveProperty('days');
-  });
-
-  it('validates args correctly', () => {
-    expect(tool.validateArgs({ location: 'Las Vegas' }).isValid).toBe(true);
-    expect(tool.validateArgs({ location: 'NYC', days: 5 }).isValid).toBe(true);
-    expect(tool.validateArgs({}).isValid).toBe(false);
-    expect(tool.validateArgs({ location: 'NYC', days: 20 }).isValid).toBe(false);
-  });
-
-  it('returns error for empty location', async () => {
-    const result = await tool.execute({ location: '' }, {} as any);
-    expect(result.success).toBe(false);
-    expect(result.error).toContain('required');
-  });
-
-  it('executes successfully with mocked service', async () => {
-    // geocode
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => GEOCODE_RESPONSE,
-    });
-    // weatherapi
-    mockFetch.mockResolvedValueOnce({
-      ok: true,
-      json: async () => WEATHERAPI_RESPONSE,
-    });
-
-    const result = await tool.execute({ location: 'Las Vegas', days: 3 }, {} as any);
-    expect(result.success).toBe(true);
-    expect(result.output?.provider).toBe('weatherapi');
-    expect(result.output?.location.name).toBe('Las Vegas');
-  });
-});
-
-describe('createExtensionPack', () => {
-  it('creates pack with correct metadata', () => {
-    const pack = createExtensionPack({
-      options: { weatherApiKey: 'test' },
-    } as any);
-    expect(pack.name).toBe('@framers/agentos-ext-weather');
-    expect(pack.descriptors).toHaveLength(1);
-    expect(pack.descriptors[0].id).toBe('weather_lookup');
-    expect(pack.descriptors[0].kind).toBe('tool');
-  });
-
-  it('works without API key', () => {
-    const pack = createExtensionPack({ options: {} } as any);
-    expect(pack.descriptors).toHaveLength(1);
-  });
-});

package/tsconfig.json

@@ -1,21 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "lib": ["ES2022"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noEmitOnError": false,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "Bundler"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "test"]
-}