@surph_ai/cli 0.0.7 → 0.0.8

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.8",
   "description": "",
   "main": "index.js",
   "types": "./types.d.ts",

package/scaffold/index.js

@@ -68,6 +68,19 @@ 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')
+
+
+
     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/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)