react-native-gemma-agent 0.1.0

package/skills/deviceLocation.ts

@@ -0,0 +1,180 @@
+import { PermissionsAndroid, Platform } from 'react-native';
+import Geolocation from '@react-native-community/geolocation';
+import type { SkillManifest } from '../src/types';
+
+// --- Offline city database (haversine nearest-match) ---
+
+type City = [string, string, string, number, number];
+// [city, state/region, country, lat, lng]
+
+const CITIES: City[] = [
+  // India
+  ['Jodhpur', 'Rajasthan', 'India', 26.2389, 72.9668],
+  ['Jaipur', 'Rajasthan', 'India', 26.9124, 75.7873],
+  ['Udaipur', 'Rajasthan', 'India', 24.5854, 73.7125],
+  ['Jaisalmer', 'Rajasthan', 'India', 26.9157, 70.9083],
+  ['Ajmer', 'Rajasthan', 'India', 26.4499, 74.6399],
+  ['Mumbai', 'Maharashtra', 'India', 19.0760, 72.8777],
+  ['Delhi', 'Delhi', 'India', 28.6139, 77.2090],
+  ['Bangalore', 'Karnataka', 'India', 12.9716, 77.5946],
+  ['Hyderabad', 'Telangana', 'India', 17.3850, 78.4867],
+  ['Chennai', 'Tamil Nadu', 'India', 13.0827, 80.2707],
+  ['Kolkata', 'West Bengal', 'India', 22.5726, 88.3639],
+  ['Pune', 'Maharashtra', 'India', 18.5204, 73.8567],
+  ['Ahmedabad', 'Gujarat', 'India', 23.0225, 72.5714],
+  ['Surat', 'Gujarat', 'India', 21.1702, 72.8311],
+  ['Lucknow', 'Uttar Pradesh', 'India', 26.8467, 80.9462],
+  ['Kanpur', 'Uttar Pradesh', 'India', 26.4499, 80.3319],
+  ['Nagpur', 'Maharashtra', 'India', 21.1458, 79.0882],
+  ['Indore', 'Madhya Pradesh', 'India', 22.7196, 75.8577],
+  ['Bhopal', 'Madhya Pradesh', 'India', 23.2599, 77.4126],
+  ['Patna', 'Bihar', 'India', 25.6093, 85.1376],
+  ['Chandigarh', 'Chandigarh', 'India', 30.7333, 76.7794],
+  ['Guwahati', 'Assam', 'India', 26.1445, 91.7362],
+  ['Kochi', 'Kerala', 'India', 9.9312, 76.2673],
+  ['Coimbatore', 'Tamil Nadu', 'India', 11.0168, 76.9558],
+  ['Varanasi', 'Uttar Pradesh', 'India', 25.3176, 83.0064],
+  ['Amritsar', 'Punjab', 'India', 31.6340, 74.8723],
+  ['Agra', 'Uttar Pradesh', 'India', 27.1767, 78.0081],
+  ['Dehradun', 'Uttarakhand', 'India', 30.3165, 78.0322],
+  ['Goa', 'Goa', 'India', 15.2993, 74.1240],
+  ['Thiruvananthapuram', 'Kerala', 'India', 8.5241, 76.9366],
+  // Global
+  ['New York', 'NY', 'USA', 40.7128, -74.0060],
+  ['San Francisco', 'CA', 'USA', 37.7749, -122.4194],
+  ['Los Angeles', 'CA', 'USA', 34.0522, -118.2437],
+  ['Chicago', 'IL', 'USA', 41.8781, -87.6298],
+  ['London', '', 'UK', 51.5074, -0.1278],
+  ['Paris', '', 'France', 48.8566, 2.3522],
+  ['Berlin', '', 'Germany', 52.5200, 13.4050],
+  ['Tokyo', '', 'Japan', 35.6762, 139.6503],
+  ['Beijing', '', 'China', 39.9042, 116.4074],
+  ['Shanghai', '', 'China', 31.2304, 121.4737],
+  ['Singapore', '', 'Singapore', 1.3521, 103.8198],
+  ['Dubai', '', 'UAE', 25.2048, 55.2708],
+  ['Sydney', 'NSW', 'Australia', -33.8688, 151.2093],
+  ['Toronto', 'ON', 'Canada', 43.6532, -79.3832],
+  ['Seoul', '', 'South Korea', 37.5665, 126.9780],
+  ['Bangkok', '', 'Thailand', 13.7563, 100.5018],
+  ['Istanbul', '', 'Turkey', 41.0082, 28.9784],
+  ['Moscow', '', 'Russia', 55.7558, 37.6173],
+  ['São Paulo', '', 'Brazil', -23.5505, -46.6333],
+  ['Mexico City', '', 'Mexico', 19.4326, -99.1332],
+  ['Cairo', '', 'Egypt', 30.0444, 31.2357],
+  ['Lagos', '', 'Nigeria', 6.5244, 3.3792],
+  ['Nairobi', '', 'Kenya', -1.2921, 36.8219],
+  ['Karachi', 'Sindh', 'Pakistan', 24.8607, 67.0011],
+  ['Lahore', 'Punjab', 'Pakistan', 31.5497, 74.3436],
+  ['Dhaka', '', 'Bangladesh', 23.8103, 90.4125],
+  ['Colombo', '', 'Sri Lanka', 6.9271, 79.8612],
+  ['Kathmandu', '', 'Nepal', 27.7172, 85.3240],
+  ['Amsterdam', '', 'Netherlands', 52.3676, 4.9041],
+  ['Barcelona', '', 'Spain', 41.3874, 2.1686],
+  ['Rome', '', 'Italy', 41.9028, 12.4964],
+];
+
+function haversineKm(
+  lat1: number,
+  lon1: number,
+  lat2: number,
+  lon2: number,
+): number {
+  const R = 6371;
+  const dLat = ((lat2 - lat1) * Math.PI) / 180;
+  const dLon = ((lon2 - lon1) * Math.PI) / 180;
+  const a =
+    Math.sin(dLat / 2) ** 2 +
+    Math.cos((lat1 * Math.PI) / 180) *
+      Math.cos((lat2 * Math.PI) / 180) *
+      Math.sin(dLon / 2) ** 2;
+  return R * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+}
+
+function findNearestCity(
+  lat: number,
+  lng: number,
+): { name: string; distKm: number } | null {
+  let best: { name: string; distKm: number } | null = null;
+
+  for (const [city, region, country, cLat, cLng] of CITIES) {
+    const d = haversineKm(lat, lng, cLat, cLng);
+    if (!best || d < best.distKm) {
+      const parts = [city, region, country].filter(Boolean);
+      best = { name: parts.join(', '), distKm: d };
+    }
+  }
+
+  // Only return if within 50km of a known city
+  return best && best.distKm <= 50 ? best : null;
+}
+
+// --- Skill ---
+
+export const deviceLocationSkill: SkillManifest = {
+  name: 'device_location',
+  description:
+    'Get the current GPS location of the device including the city/area name. Works completely offline.',
+  version: '1.2.0',
+  type: 'native',
+  requiresNetwork: false,
+  parameters: {},
+  requiredParameters: [],
+  instructions:
+    'Use this when the user asks where they are, their current location, or anything about their physical position. No parameters needed. IMPORTANT: Always include ALL details from the result in your response — location name, coordinates, accuracy, and altitude. Do not summarize or omit fields.',
+  execute: async () => {
+    try {
+      if (Platform.OS === 'android') {
+        const granted = await PermissionsAndroid.request(
+          PermissionsAndroid.PERMISSIONS.ACCESS_FINE_LOCATION,
+          {
+            title: 'Location Permission',
+            message: 'This app needs access to your location.',
+            buttonPositive: 'OK',
+          },
+        );
+        if (granted !== PermissionsAndroid.RESULTS.GRANTED) {
+          return { error: 'Location permission denied by user.' };
+        }
+      }
+
+      const position = await new Promise<{
+        coords: {
+          latitude: number;
+          longitude: number;
+          altitude: number | null;
+          accuracy: number;
+          speed: number | null;
+        };
+      }>((resolve, reject) => {
+        Geolocation.getCurrentPosition(resolve, reject, {
+          enableHighAccuracy: true,
+          timeout: 15000,
+          maximumAge: 60000,
+        });
+      });
+
+      const { latitude, longitude, accuracy, altitude } = position.coords;
+
+      // Offline city lookup — no internet needed
+      const nearest = findNearestCity(latitude, longitude);
+
+      const parts: string[] = [];
+      if (nearest) {
+        parts.push(`Location: ${nearest.name}`);
+      }
+      parts.push(
+        `Coordinates: ${latitude.toFixed(6)}°N, ${longitude.toFixed(6)}°E`,
+      );
+      parts.push(`Accuracy: ${Math.round(accuracy)}m`);
+      if (altitude !== null) {
+        parts.push(`Altitude: ${Math.round(altitude)}m`);
+      }
+
+      return { result: parts.join('\n') };
+    } catch (err: unknown) {
+      const msg =
+        err instanceof Error ? err.message : 'Failed to get location';
+      return { error: `Location error: ${msg}` };
+    }
+  },
+};

package/skills/index.ts

@@ -0,0 +1,3 @@
+export { calculatorSkill } from './calculator';
+export { queryWikipediaSkill } from './queryWikipedia';
+export { webSearchSkill } from './webSearch';

package/skills/queryWikipedia.ts

@@ -0,0 +1,96 @@
+import type { SkillManifest } from '../src/types';
+
+export const queryWikipediaSkill: SkillManifest = {
+  name: 'query_wikipedia',
+  description: 'Search Wikipedia for factual information about any topic.',
+  version: '1.1.0',
+  type: 'js',
+  requiresNetwork: true,
+  parameters: {
+    query: {
+      type: 'string',
+      description: 'The search query to send to Wikipedia',
+    },
+  },
+  requiredParameters: ['query'],
+  instructions:
+    'Use this when the user asks a factual question you are not confident about. Pass a clear, concise search query. Use the returned information to answer naturally.',
+  html: `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"></head>
+<body>
+<script>
+function stripLatex(text) {
+  if (!text) return text;
+  // Remove display math $$...$$
+  text = text.replace(/\\$\\$[^$]*\\$\\$/g, '');
+  // Remove inline math $...$  (but not dollar amounts like $5)
+  text = text.replace(/\\$[^$\\d][^$]*\\$/g, '');
+  // Replace \\frac{a}{b} with a/b
+  text = text.replace(/\\\\frac\\{([^}]*)\\}\\{([^}]*)\\}/g, '$1/$2');
+  // Replace \\text{...}, \\mathrm{...}, etc. with contents
+  text = text.replace(/\\\\(text|mathrm|mathbf|mathit|mathbb|mathcal|operatorname)\\{([^}]*)\\}/g, '$2');
+  // Replace \\sqrt{x} with sqrt(x)
+  text = text.replace(/\\\\sqrt\\{([^}]*)\\}/g, 'sqrt($1)');
+  // Remove \\displaystyle and similar
+  text = text.replace(/\\\\(displaystyle|textstyle|scriptstyle|left|right|Big|big)\\s*/g, '');
+  // Replace common symbols
+  text = text.replace(/\\\\times/g, 'x');
+  text = text.replace(/\\\\cdot/g, '*');
+  text = text.replace(/\\\\approx/g, '≈');
+  text = text.replace(/\\\\pm/g, '±');
+  text = text.replace(/\\\\leq/g, '<=');
+  text = text.replace(/\\\\geq/g, '>=');
+  text = text.replace(/\\\\neq/g, '!=');
+  text = text.replace(/\\\\infty/g, 'infinity');
+  text = text.replace(/\\\\sum/g, 'sum');
+  text = text.replace(/\\\\int/g, 'integral');
+  // Remove remaining \\command patterns
+  text = text.replace(/\\\\[a-zA-Z]+/g, '');
+  // Clean up leftover braces
+  text = text.replace(/[{}]/g, '');
+  // Clean up extra whitespace
+  text = text.replace(/\\s+/g, ' ').trim();
+  return text;
+}
+
+window['ai_edge_gallery_get_result'] = async function(jsonData) {
+  const params = JSON.parse(jsonData);
+  const query = params.query;
+  if (!query) {
+    return JSON.stringify({ error: 'No query provided' });
+  }
+
+  try {
+    const url = 'https://en.wikipedia.org/api/rest_v1/page/summary/'
+      + encodeURIComponent(query);
+    const res = await fetch(url);
+
+    if (!res.ok) {
+      // Try search API as fallback
+      const searchUrl = 'https://en.wikipedia.org/w/api.php?action=query&list=search&srsearch='
+        + encodeURIComponent(query) + '&format=json&origin=*&srlimit=3';
+      const searchRes = await fetch(searchUrl);
+      const searchData = await searchRes.json();
+      const results = searchData.query?.search;
+      if (!results || results.length === 0) {
+        return JSON.stringify({ error: 'No Wikipedia results found for: ' + query });
+      }
+      const snippets = results.map(function(r) {
+        return r.title + ': ' + stripLatex(r.snippet.replace(/<[^>]*>/g, ''));
+      }).join('\\n\\n');
+      return JSON.stringify({ result: snippets });
+    }
+
+    const data = await res.json();
+    const title = data.title || query;
+    const extract = stripLatex(data.extract || 'No summary available.');
+    return JSON.stringify({ result: title + ': ' + extract });
+  } catch (e) {
+    return JSON.stringify({ error: 'Wikipedia lookup failed: ' + e.message });
+  }
+};
+</script>
+</body>
+</html>`,
+};

package/skills/readCalendar.ts

@@ -0,0 +1,74 @@
+import RNCalendarEvents from 'react-native-calendar-events';
+import type { SkillManifest } from '../src/types';
+
+export const readCalendarSkill: SkillManifest = {
+  name: 'read_calendar',
+  description:
+    "Read events from the device calendar for a specific day. Returns event titles, times, and locations. Works completely offline — reads directly from the device's local calendar.",
+  version: '1.0.0',
+  type: 'native',
+  requiresNetwork: false,
+  parameters: {
+    date: {
+      type: 'string',
+      description:
+        'Date to check in YYYY-MM-DD format. Defaults to today if not specified.',
+    },
+  },
+  instructions:
+    "Use this when the user asks about their schedule, calendar, meetings, appointments, or what's planned for a day. Omit the date parameter to get today's events.",
+  execute: async (params) => {
+    try {
+      const status = await RNCalendarEvents.requestPermissions();
+      if (status !== 'authorized') {
+        return { error: 'Calendar permission denied by user.' };
+      }
+
+      const now = new Date();
+      const dateStr = params.date
+        ? String(params.date)
+        : `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`;
+
+      const startDate = new Date(`${dateStr}T00:00:00`).toISOString();
+      const endDate = new Date(`${dateStr}T23:59:59`).toISOString();
+
+      const events = await RNCalendarEvents.fetchAllEvents(startDate, endDate);
+
+      if (!events || events.length === 0) {
+        return { result: `No events found for ${dateStr}.` };
+      }
+
+      const formatted = events
+        .sort(
+          (a, b) =>
+            new Date(a.startDate).getTime() - new Date(b.startDate).getTime(),
+        )
+        .map((e) => {
+          const start = new Date(e.startDate);
+          const end = new Date(e.endDate);
+          const startTime = start.toLocaleTimeString([], {
+            hour: '2-digit',
+            minute: '2-digit',
+          });
+          const endTime = end.toLocaleTimeString([], {
+            hour: '2-digit',
+            minute: '2-digit',
+          });
+          let line = `${startTime}–${endTime}: ${e.title}`;
+          if (e.location) {
+            line += ` (at ${e.location})`;
+          }
+          return line;
+        })
+        .join('\n');
+
+      return {
+        result: `Calendar events for ${dateStr} (${events.length} events):\n${formatted}`,
+      };
+    } catch (err: unknown) {
+      const msg =
+        err instanceof Error ? err.message : 'Failed to read calendar';
+      return { error: `Calendar error: ${msg}` };
+    }
+  },
+};

package/skills/webSearch.ts

@@ -0,0 +1,75 @@
+import type { SkillManifest } from '../src/types';
+
+export const webSearchSkill: SkillManifest = {
+  name: 'web_search',
+  description: 'Search the web for current information using SearXNG.',
+  version: '2.0.0',
+  type: 'js',
+  requiresNetwork: true,
+  parameters: {
+    query: {
+      type: 'string',
+      description: 'The search query',
+    },
+  },
+  requiredParameters: ['query'],
+  instructions:
+    'Use this when the user asks about recent events, current information, or topics you are not sure about. Returns search results from the web.',
+  html: `<!DOCTYPE html>
+<html>
+<head><meta charset="utf-8"></head>
+<body>
+<script>
+window['ai_edge_gallery_get_result'] = async function(jsonData) {
+  var params = JSON.parse(jsonData);
+  var query = params.query;
+  if (!query) {
+    return JSON.stringify({ error: 'No query provided' });
+  }
+
+  // SearXNG public instances to try in order
+  var instances = [
+    'https://searx.be',
+    'https://search.bus-hit.me',
+    'https://searx.tiekoetter.com'
+  ];
+
+  for (var idx = 0; idx < instances.length; idx++) {
+    try {
+      var url = instances[idx] + '/search?q=' + encodeURIComponent(query)
+        + '&format=json&language=en&safesearch=0';
+      var res = await fetch(url, {
+        headers: { 'Accept': 'application/json' }
+      });
+
+      if (!res.ok) continue;
+
+      var data = await res.json();
+
+      if (!data.results || data.results.length === 0) {
+        // Try next instance if this one returned empty
+        if (idx < instances.length - 1) continue;
+        return JSON.stringify({
+          result: 'No results found for "' + query + '". Try rephrasing the query.'
+        });
+      }
+
+      var results = data.results.slice(0, 5).map(function(r) {
+        var snippet = r.content || '';
+        return r.title + ' (' + r.url + ')' + (snippet ? ': ' + snippet : '');
+      }).join('\\n\\n');
+
+      return JSON.stringify({ result: results });
+    } catch (e) {
+      // Try next instance on failure
+      if (idx < instances.length - 1) continue;
+      return JSON.stringify({ error: 'Web search failed: ' + e.message });
+    }
+  }
+
+  return JSON.stringify({ error: 'All search instances unavailable.' });
+};
+</script>
+</body>
+</html>`,
+};