@surph_ai/cli 0.0.7 → 0.0.9

package/cli.js

@@ -183,6 +183,8 @@ program.command('manifest')
   try {
     const manifestJson = require('../../../manifest.json')
     const slug = Object.keys(manifestJson)[0]
+    // console.log('TEST: ' + JSON.stringify(manifestJson))
+    // console.log('FIRST KEY: ' + slug)
     const manifest = manifestJson[slug]
     if (!manifest) {
       throw new Error('manifest.json not found')
@@ -218,6 +220,8 @@ program.command('manifest')
     })
 
     const { response } = await resp.json()
+    console.log('SLUG: ' + slug)
+    console.log('MANIFEST: ' + JSON.stringify(response))
 		utils.write('manifest.json', JSON.stringify({[slug]: response}, null, 2) + '\n')
     console.log(colors.white('\n\nManifest updated. Check manifest.json for changes.\n'))
   } catch (error) {
@@ -437,6 +441,7 @@ program.command('deploy')
     }
     */
 
+    /*
     const { SURPH_TOOL = null } = dotenv.parse(utils.readFile('.env') ?? '')
 
     if (SURPH_TOOL === null) {
@@ -444,6 +449,16 @@ program.command('deploy')
     }
 
     await deploy.tool({ SURPH_TOOL_SLUG: SURPH_TOOL })
+    */
+
+    const manifest = require('../../../manifest.json')
+    if (!manifest) {
+      throw new Error('manifest.json not found')
+    }
+
+    const keys = Object.keys(manifest);
+    const SURPH_TOOL = keys[0]
+    await deploy.tool({ SURPH_TOOL_SLUG: SURPH_TOOL })
   } catch (error) {
     utils.printError(error)
     program.error(`Unexpected error: ${error}`, ERRORS.UNSPECIFIED)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@surph_ai/cli",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "",
   "main": "index.js",
   "types": "./types.d.ts",

package/scaffold/index.js

@@ -68,6 +68,22 @@ module.exports = (name, type = 'app') => {
     shell.mkdir('-p', 'tools')
     shell.cp('-R', path.join(__dirname, `tool/tools/index.ts`), 'tools/index.ts')
 
+    shell.mkdir('-p', 'examples')
+    shell.cp('-R', path.join(__dirname, `tool/examples/README.md`), 'examples/README.md')
+
+    shell.mkdir('-p', 'examples/population')
+    shell.cp('-R', path.join(__dirname, `tool/examples/population/index.ts`), 'examples/population/index.ts')
+    shell.cp('-R', path.join(__dirname, `tool/examples/population/manifest.json`), 'examples/population/manifest.json')
+
+    shell.mkdir('-p', 'examples/weather')
+    shell.cp('-R', path.join(__dirname, `tool/examples/weather/index.ts`), 'examples/weather/index.ts')
+    shell.cp('-R', path.join(__dirname, `tool/examples/weather/manifest.json`), 'examples/weather/manifest.json')
+
+    shell.mkdir('-p', 'examples/dealfinder')
+    shell.cp('-R', path.join(__dirname, `tool/examples/dealfinder/index.ts`), 'examples/dealfinder/index.ts')
+    shell.cp('-R', path.join(__dirname, `tool/examples/dealfinder/manifest.json`), 'examples/dealfinder/manifest.json')
+
+
     utils.write('manifest-example.json', JSON.stringify({
       name: 'youtube-transcript',
       slug: 'y2script',

package/scaffold/tool/examples/README.md

@@ -0,0 +1 @@
+README

package/scaffold/tool/examples/dealfinder/index.ts

@@ -0,0 +1,45 @@
+import type { ToolHandler } from '@surph_ai/sdk';
+import { surph } from '@surph_ai/sdk';
+
+// your custom tool args goes here
+type ToolArgs = {
+  preferences: string[]
+};
+
+const handler: ToolHandler<ToolArgs> = async ({ args, user, context }: Record<string, any>) => {
+  try {
+    if (!args) {
+      throw new Error('Args required.')
+    }
+
+    if (!context) {
+      throw new Error('Context required.')
+    }
+
+    const { preferences } = args; // string[]
+    const searchQuery = preferences.join(', ')
+
+    const searchResults = await surph.search(searchQuery, context)
+
+    const promptResponse = await surph.prompt({
+      instructions: `searchResults is a JSON array data feed of events and announcements. Your job is to sort each item into one of three categories: offering free food, free event, or free giveaway (such as raffles, prizes, etc.).`,
+      prompt: `Given this list of items, separate them into free food, free event, or free giveaway:\n\n${JSON.stringify(searchResults)}`,
+      output: {
+        name: 'deal_search_results',
+        description: 'The deal search results',
+        fields: [
+          { name: 'food', type: 'array', description: 'a list of events and announcements with free food.' },
+          { name: 'event',  type: 'array', description: 'a list of events that are free to attend.' },
+          { name: 'items', type: 'array', description: 'a list of events and announcements with free items.' }
+        ]
+      }
+    })
+
+    return promptResponse
+  } catch (error) {
+    throw error
+  }
+};
+
+export default handler;
+

package/scaffold/tool/examples/dealfinder/manifest.json

@@ -0,0 +1,21 @@
+{
+  "deal-finder-q9je7jou": {
+    "name": "deal-finder",
+    "slug": "deal-finder-q9je7jou",
+    "type": "custom",
+    "description": "Search the user's active Surph context for local deals, discounts, promotions, specials, sales, and related opportunities across food, drinks, restaurants, shops, events, entertainment, and other businesses or venues covered by the context. Use whenever the user asks to find, compare, filter, or recommend current or upcoming local deals—including requests for happy hours, meal specials, event discounts, retail sales, coupons, or promotions. Prefer this instead of webSearch when the requested local businesses, venues, events, or listings are represented in the active Surph context.",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "preferences": {
+          "type": "array",
+          "description": "Optional free-form preferences, categories, constraints, or deal criteria to prioritize, such as food, drinks, events, retail sales, happy hour, nearby neighborhoods, budget, dates, or specific businesses.",
+          "items": {
+            "type": "string"
+          }
+        }
+      },
+      "required": []
+    }
+  }
+}

package/scaffold/tool/examples/population/index.ts

@@ -0,0 +1,31 @@
+import type { ToolHandler } from '@surph_ai/sdk';
+
+const cities: Record<string, number> = {
+  'chicago': 3000000,
+  'new york': 8500000,
+  'los angeles': 4000000
+}
+
+// your custom tool args goes here
+type ToolArgs = {
+  city: string
+};
+
+const handler: ToolHandler<ToolArgs> = async ({ args, user, context }: Record<string, any>) => {
+  try {
+    // your custom tool code goes here
+    const { city } = args
+
+    const population: number = cities[city.toLowerCase()]
+    if (!population) {
+      throw new Error(`${city} population not found.`)
+    }
+
+    return population
+  } catch (error) {
+    throw error
+  }
+};
+
+export default handler;
+

package/scaffold/tool/examples/population/manifest.json

@@ -0,0 +1,20 @@
+{
+  "city-population-0d6v8oad": {
+    "name": "city-population",
+    "slug": "city-population-0d6v8oad",
+    "type": "custom",
+    "description": "Return the population of a specified city. Use this whenever the user asks for a city's population, including questions such as \"What is the population of Tokyo?\" or requests that provide a city name directly. The city input may include a country, state, or other region to disambiguate cities with the same name.",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "city": {
+          "type": "string",
+          "description": "The city whose population is requested, provided as a city name; it may optionally include a state, province, country, or other geographic qualifier, such as \"Paris, France\" or \"Springfield, Illinois\"."
+        }
+      },
+      "required": [
+        "city"
+      ]
+    }
+  }
+}

package/scaffold/tool/examples/weather/index.ts

@@ -0,0 +1,127 @@
+import type { ToolHandler } from '@surph_ai/sdk';
+
+// Define interfaces for API responses
+interface GeocodingResult {
+  id: number;
+  name: string;
+  latitude: number;
+  longitude: number;
+  country?: string;
+  country_code?: string;
+}
+
+interface GeocodingResponse {
+  results?: GeocodingResult[];
+}
+
+interface CurrentWeather {
+  time: string;
+  interval: number;
+  temperature_2m: number;
+  relative_humidity_2m: number;
+  apparent_temperature: number;
+  precipitation: number;
+  weather_code: number;
+  wind_speed_10m: number;
+}
+
+interface CurrentUnits {
+  temperature_2m: string;
+  relative_humidity_2m: string;
+  apparent_temperature: string;
+  precipitation: string;
+  wind_speed_10m: string;
+}
+
+interface WeatherResponse {
+  latitude: number;
+  longitude: number;
+  current?: CurrentWeather;
+  current_units?: CurrentUnits;
+}
+
+/**
+ * Fetches current weather conditions for a specified city name.
+ */
+async function getCityWeather(cityName: string): Promise<any> {
+  try {
+    // Step 1: Get coordinates for the city using the Geocoding API
+    const geoUrl = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(cityName)}&count=1`;
+    const geoRes = await fetch(geoUrl);
+    
+    if (!geoRes.ok) {
+      throw new Error(`Geocoding HTTP error! Status: ${geoRes.status}`);
+    }
+
+    const geoData = (await geoRes.json()) as GeocodingResponse;
+
+    if (!geoData.results || geoData.results.length === 0) {
+      console.log(`City "${cityName}" not found.`);
+      return;
+    }
+
+    const location = geoData.results[0];
+    const { latitude, longitude, name, country = '' } = location;
+
+    console.log(`Found: ${name}, ${country} (Lat: ${latitude}, Lon: ${longitude})`);
+
+    // Step 2: Get weather data using the retrieved coordinates
+    const weatherParams = new URLSearchParams({
+      latitude: latitude.toString(),
+      longitude: longitude.toString(),
+      current: 'temperature_2m,relative_humidity_2m,apparent_temperature,precipitation,weather_code,wind_speed_10m'
+    });
+
+    const weatherUrl = `https://api.open-meteo.com/v1/forecast?${weatherParams.toString()}`;
+    const weatherRes = await fetch(weatherUrl);
+
+    if (!weatherRes.ok) {
+      throw new Error(`Weather HTTP error! Status: ${weatherRes.status}`);
+    }
+
+    const weatherData = (await weatherRes.json()) as WeatherResponse;
+    const { current, current_units: units } = weatherData;
+
+    if (!current || !units) {
+      console.log('No current weather data available.');
+      return;
+    }
+
+    // Display the formatted results
+    console.log(`Current Temperature: ${current.temperature_2m} ${units.temperature_2m}`);
+    console.log(`Feels Like: ${current.apparent_temperature} ${units.apparent_temperature}`);
+    console.log(`Humidity: ${current.relative_humidity_2m} ${units.relative_humidity_2m}`);
+    console.log(`Wind Speed: ${current.wind_speed_10m} ${units.wind_speed_10m}`);
+
+    return {
+      temperature: `${current.temperature_2m} ${units.temperature_2m}`,
+      humidity: `${current.relative_humidity_2m} ${units.relative_humidity_2m}`,
+      wind: `${current.wind_speed_10m} ${units.wind_speed_10m}`,
+    }
+  } catch (error) {
+    console.error('Failed to fetch weather data:', error);
+  }
+}
+
+
+// your custom tool args goes here
+type ToolArgs = {
+  location: string
+};
+
+const handler: ToolHandler<ToolArgs> = async ({ args, user, context }: Record<string, any>) => {
+  try {
+    const { location } = args;
+    if (!location) {
+      throw new Error(`location argument required.`)
+    }
+
+    const weahter = await getCityWeather(location)
+    return weahter
+  } catch (error) {
+    throw error
+  }
+};
+
+export default handler;
+

package/scaffold/tool/examples/weather/manifest.json

@@ -0,0 +1,20 @@
+{
+  "weather-forecast-q9je7jou": {
+    "name": "weather-forecast",
+    "slug": "weather-forecast-q9je7jou",
+    "type": "custom",
+    "description": "Return current weather conditions and the forecast for a specified location. Use this whenever the user asks about the weather, temperature, conditions, rain, snow, wind, or upcoming forecast for a place, including when the location is provided as a city, region, country, postal code, address, or coordinates.",
+    "parameters": {
+      "type": "object",
+      "properties": {
+        "location": {
+          "type": "string",
+          "description": "The location to retrieve weather for. Accept a city or town, region/state and country, postal or ZIP code, street address, landmark, or latitude/longitude coordinates."
+        }
+      },
+      "required": [
+        "location"
+      ]
+    }
+  }
+}

package/toolserver/routes/tool.js

@@ -70,9 +70,10 @@ router.get('/', async (req, res, next) => {
 
 router.get('/test', async (req, res, next) => {
   try {
-    if (Object.keys(req.query).length === 0) {
-      throw new Error('No arguments provided.')
-    }
+    // this should be enforced at the tool level, not here:
+    // if (Object.keys(req.query).length === 0) {
+    //   throw new Error('No arguments provided.')
+    // }
 
     const context = req.query._context || null
     const user = req.query._user || null
@@ -94,9 +95,9 @@ router.get('/test', async (req, res, next) => {
 router.post('/custom', async (req, res, next) => {
   try {
     const { name, args, tool, user = null, context = null } = req.body;
-    if (process.env.SURPH_TOOL !== tool.slug) {
-      throw new Error(`Invalid tool ${tool.slug}. Check .env file.`)
-    }
+    // if (process.env.SURPH_TOOL !== tool.slug) {
+    //   throw new Error(`Invalid tool ${tool.slug}. Check .env file.`)
+    // }
 
     const toolRunner = await loadTool()
     const response = await handler({ args, context, user }, toolRunner)