@happyvertical/smrt-places 0.30.0

package/dist/types.d.ts

@@ -0,0 +1,172 @@
+import { SmrtObjectOptions } from '@happyvertical/smrt-core';
+
+/**
+ * Options for `PlaceCollection.discoverNearby`. Mirrors the inputs to
+ * `@happyvertical/geo`'s `findPoisNear` plus a couple of persistence knobs
+ * (PlaceType override, parent linkage) to match `lookupOrCreate`'s shape.
+ */
+export declare interface DiscoverNearbyOptions {
+    /** Which geo provider to use. Defaults to openstreetmap. */
+    geoProvider?: 'google' | 'openstreetmap';
+    /**
+     * POI category filter, forwarded to the provider. See
+     * `@happyvertical/geo`'s `PoiSearchOptions.types` for provider-specific
+     * interpretation.
+     */
+    types?: string[];
+    /** Free-text keyword filter (provider-dependent; Google only). */
+    keyword?: string;
+    /** Max results per provider call. Default 20. */
+    limit?: number;
+    /** Preferred language for place names (Google only). */
+    language?: string;
+    /** Override the PlaceType slug assigned to created rows. */
+    typeSlug?: string;
+    /** Set parent place on created rows. */
+    parentId?: string | null;
+}
+
+/**
+ * Geographic data structure
+ * All fields optional to support both real-world and abstract places
+ */
+export declare interface GeoData {
+    latitude: number | null;
+    longitude: number | null;
+    streetNumber?: string;
+    streetName?: string;
+    city?: string;
+    region?: string;
+    country?: string;
+    postalCode?: string;
+    countryCode?: string;
+    timezone?: string;
+}
+
+/**
+ * Options for lookupOrCreate method
+ */
+export declare interface LookupOrCreateOptions {
+    /**
+     * Which geo provider to use for lookups
+     */
+    geoProvider?: 'google' | 'openstreetmap';
+    /**
+     * Force a specific place type
+     */
+    typeSlug?: string;
+    /**
+     * Set parent place if known
+     */
+    parentId?: string | null;
+    /**
+     * Whether to create if not found (default: true)
+     */
+    createIfNotFound?: boolean;
+    /**
+     * Coordinates for reverse geocoding
+     */
+    coords?: {
+        lat: number;
+        lng: number;
+    };
+}
+
+/**
+ * Place hierarchy structure
+ */
+export declare interface PlaceHierarchy {
+    ancestors: any[];
+    current: any;
+    descendants: any[];
+}
+
+/**
+ * Options for creating/updating a Place
+ */
+export declare interface PlaceOptions extends SmrtObjectOptions {
+    id?: string;
+    tenantId?: string | null;
+    typeId?: string;
+    parentId?: string | null;
+    name?: string;
+    description?: string;
+    latitude?: number | null;
+    longitude?: number | null;
+    streetNumber?: string;
+    streetName?: string;
+    city?: string;
+    region?: string;
+    country?: string;
+    postalCode?: string;
+    countryCode?: string;
+    timezone?: string;
+    externalId?: string;
+    source?: string;
+    metadata?: Record<string, any> | string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+
+/**
+ * Options for creating/updating a PlaceType
+ */
+export declare interface PlaceTypeOptions extends SmrtObjectOptions {
+    id?: string;
+    slug?: string;
+    name?: string;
+    description?: string;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+
+/**
+ * Options for `PlaceCollection.resolveTrackPlaces`. Extends
+ * `DiscoverNearbyOptions` with per-track knobs that control how the track
+ * is bucketed + throttled before hitting the geo provider.
+ */
+export declare interface ResolveTrackPlacesOptions extends DiscoverNearbyOptions {
+    /**
+     * Per-point POI search radius in meters. Default 50.
+     */
+    radiusMeters?: number;
+    /**
+     * Collapse points within this distance (m) into a single bucket so we
+     * don't re-query the same ~50m area dozens of times for a slow drive-by.
+     * Default 50.
+     */
+    bucketMeters?: number;
+    /**
+     * Minimum delay between provider requests. Default 1100ms — safely above
+     * OSM's 1 req/sec community limit. Google can usually handle faster; set
+     * to 100ms or less for paid tiers.
+     */
+    throttleMs?: number;
+}
+
+/**
+ * Result of `PlaceCollection.resolveTrackPlaces`. Tracks are typically
+ * long-running operations so the return payload includes counters that let
+ * callers surface progress or estimate cost without re-walking.
+ */
+export declare interface TrackPlacesResult {
+    /** De-duplicated Place rows touched during resolution. */
+    places: any[];
+    /** Number of provider requests issued. */
+    requestCount: number;
+    /** Number of bucketed points that reused existing Place rows. */
+    cacheHitCount: number;
+    /** Number of distinct geographic buckets walked. */
+    bucketCount: number;
+}
+
+/**
+ * A single point along a track. Matches the `{ lat, lng }` convention used
+ * by `LookupOrCreateOptions.coords` so callers don't have to shuffle shapes.
+ */
+export declare interface TrackPoint {
+    lat: number;
+    lng: number;
+}
+
+export { }

package/dist/types.js

@@ -0,0 +1,2 @@
+
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/dist/utils.d.ts

@@ -0,0 +1,113 @@
+import { Location } from '@happyvertical/geo';
+
+/**
+ * Check if two coordinates are within a threshold distance
+ *
+ * @param lat1 - First latitude
+ * @param lng1 - First longitude
+ * @param lat2 - Second latitude
+ * @param lng2 - Second longitude
+ * @param thresholdKm - Distance threshold in kilometers
+ * @returns True if coordinates are within threshold
+ */
+export declare function areCoordinatesNear(lat1: number, lng1: number, lat2: number, lng2: number, thresholdKm?: number): boolean;
+
+/**
+ * Calculate distance between two coordinates using Haversine formula
+ *
+ * @param lat1 - First latitude
+ * @param lng1 - First longitude
+ * @param lat2 - Second latitude
+ * @param lng2 - Second longitude
+ * @returns Distance in kilometers
+ */
+export declare function calculateDistance(lat1: number, lng1: number, lat2: number, lng2: number): number;
+
+/**
+ * Format coordinates as string
+ *
+ * @param latitude - Latitude value
+ * @param longitude - Longitude value
+ * @param precision - Number of decimal places (default: 6)
+ * @returns Formatted coordinate string
+ */
+export declare function formatCoordinates(latitude: number, longitude: number, precision?: number): string;
+
+/**
+ * Generate a display name from address components
+ *
+ * @param components - Address components
+ * @returns Formatted display name
+ */
+export declare function generateDisplayName(components: Partial<GeoData>): string;
+
+/**
+ * Geographic data structure
+ * All fields optional to support both real-world and abstract places
+ */
+declare interface GeoData {
+    latitude: number | null;
+    longitude: number | null;
+    streetNumber?: string;
+    streetName?: string;
+    city?: string;
+    region?: string;
+    country?: string;
+    postalCode?: string;
+    countryCode?: string;
+    timezone?: string;
+}
+
+/**
+ * Convert Location from @happyvertical/geo to GeoData
+ *
+ * @param location - Location from geocoding
+ * @returns GeoData object
+ */
+export declare function locationToGeoData(location: Location): GeoData;
+
+/**
+ * Map Location type from @happyvertical/geo to PlaceType slug
+ *
+ * @param locationType - Location type from geocoding provider
+ * @returns PlaceType slug
+ */
+export declare function mapLocationTypeToPlaceType(locationType: string): string;
+
+/**
+ * Normalize address components by trimming and removing empty values
+ *
+ * @param components - Address components
+ * @returns Normalized components
+ */
+export declare function normalizeAddressComponents(components: Partial<GeoData>): Partial<GeoData>;
+
+/**
+ * Parse coordinate string to lat/lng
+ *
+ * Supports formats:
+ * - "lat, lng"
+ * - "lat,lng"
+ * - "lat lng"
+ *
+ * @param coordString - Coordinate string
+ * @returns Object with lat and lng, or null if invalid
+ */
+export declare function parseCoordinates(coordString: string): {
+    lat: number;
+    lng: number;
+} | null;
+
+/**
+ * Validate geographic coordinates
+ *
+ * @param latitude - Latitude value
+ * @param longitude - Longitude value
+ * @returns Object with valid flag and optional error message
+ */
+export declare function validateCoordinates(latitude: number, longitude: number): {
+    valid: boolean;
+    error?: string;
+};
+
+export { }

package/dist/utils.js

@@ -0,0 +1,110 @@
+function mapLocationTypeToPlaceType(locationType) {
+  const typeMap = {
+    // Standard types
+    country: "country",
+    region: "region",
+    city: "city",
+    address: "address",
+    point_of_interest: "point_of_interest",
+    // Additional mappings
+    state: "region",
+    province: "region",
+    town: "city",
+    village: "city",
+    building: "building",
+    room: "room",
+    zone: "zone"
+  };
+  return typeMap[locationType.toLowerCase()] || "address";
+}
+function locationToGeoData(location) {
+  const components = location.addressComponents || {};
+  return {
+    latitude: location.latitude,
+    longitude: location.longitude,
+    streetNumber: components.streetNumber,
+    streetName: components.streetName,
+    city: components.city,
+    region: components.region,
+    country: components.country,
+    postalCode: components.postalCode,
+    countryCode: location.countryCode,
+    timezone: location.timezone
+  };
+}
+function validateCoordinates(latitude, longitude) {
+  if (latitude < -90 || latitude > 90) {
+    return { valid: false, error: "Invalid latitude (must be -90 to 90)" };
+  }
+  if (longitude < -180 || longitude > 180) {
+    return { valid: false, error: "Invalid longitude (must be -180 to 180)" };
+  }
+  return { valid: true };
+}
+function calculateDistance(lat1, lng1, lat2, lng2) {
+  const R = 6371;
+  const dLat = toRad(lat2 - lat1);
+  const dLng = toRad(lng2 - lng1);
+  const a = Math.sin(dLat / 2) * Math.sin(dLat / 2) + Math.cos(toRad(lat1)) * Math.cos(toRad(lat2)) * Math.sin(dLng / 2) * Math.sin(dLng / 2);
+  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+  return R * c;
+}
+function toRad(degrees) {
+  return degrees * (Math.PI / 180);
+}
+function formatCoordinates(latitude, longitude, precision = 6) {
+  return `${latitude.toFixed(precision)}, ${longitude.toFixed(precision)}`;
+}
+function parseCoordinates(coordString) {
+  const parts = coordString.trim().replace(/\s+/g, " ").replace(/,\s*/g, ",").split(/[,\s]+/);
+  if (parts.length !== 2) return null;
+  const lat = parseFloat(parts[0]);
+  const lng = parseFloat(parts[1]);
+  if (Number.isNaN(lat) || Number.isNaN(lng)) return null;
+  const validation = validateCoordinates(lat, lng);
+  if (!validation.valid) return null;
+  return { lat, lng };
+}
+function normalizeAddressComponents(components) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(components)) {
+    if (value === null || value === void 0) continue;
+    if (typeof value === "string") {
+      const trimmed = value.trim();
+      if (trimmed) {
+        normalized[key] = trimmed;
+      }
+    } else {
+      normalized[key] = value;
+    }
+  }
+  return normalized;
+}
+function generateDisplayName(components) {
+  const parts = [];
+  if (components.streetNumber && components.streetName) {
+    parts.push(`${components.streetNumber} ${components.streetName}`);
+  } else if (components.streetName) {
+    parts.push(components.streetName);
+  }
+  if (components.city) parts.push(components.city);
+  if (components.region) parts.push(components.region);
+  if (components.country) parts.push(components.country);
+  return parts.join(", ");
+}
+function areCoordinatesNear(lat1, lng1, lat2, lng2, thresholdKm = 0.1) {
+  const distance = calculateDistance(lat1, lng1, lat2, lng2);
+  return distance <= thresholdKm;
+}
+export {
+  areCoordinatesNear,
+  calculateDistance,
+  formatCoordinates,
+  generateDisplayName,
+  locationToGeoData,
+  mapLocationTypeToPlaceType,
+  normalizeAddressComponents,
+  parseCoordinates,
+  validateCoordinates
+};
+//# sourceMappingURL=utils.js.map

package/dist/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../src/utils.ts"],"sourcesContent":["/**\n * Utility functions for @have/places package\n */\n\nimport type { Location } from '@happyvertical/geo';\nimport type { GeoData } from './types';\n\n/**\n * Map Location type from @happyvertical/geo to PlaceType slug\n *\n * @param locationType - Location type from geocoding provider\n * @returns PlaceType slug\n */\nexport function mapLocationTypeToPlaceType(locationType: string): string {\n  const typeMap: Record<string, string> = {\n    // Standard types\n    country: 'country',\n    region: 'region',\n    city: 'city',\n    address: 'address',\n    point_of_interest: 'point_of_interest',\n\n    // Additional mappings\n    state: 'region',\n    province: 'region',\n    town: 'city',\n    village: 'city',\n    building: 'building',\n    room: 'room',\n    zone: 'zone',\n  };\n\n  return typeMap[locationType.toLowerCase()] || 'address';\n}\n\n/**\n * Convert Location from @happyvertical/geo to GeoData\n *\n * @param location - Location from geocoding\n * @returns GeoData object\n */\nexport function locationToGeoData(location: Location): GeoData {\n  const components = location.addressComponents || {};\n\n  return {\n    latitude: location.latitude,\n    longitude: location.longitude,\n    streetNumber: components.streetNumber,\n    streetName: components.streetName,\n    city: components.city,\n    region: components.region,\n    country: components.country,\n    postalCode: components.postalCode,\n    countryCode: location.countryCode,\n    timezone: location.timezone,\n  };\n}\n\n/**\n * Validate geographic coordinates\n *\n * @param latitude - Latitude value\n * @param longitude - Longitude value\n * @returns Object with valid flag and optional error message\n */\nexport function validateCoordinates(\n  latitude: number,\n  longitude: number,\n): { valid: boolean; error?: string } {\n  if (latitude < -90 || latitude > 90) {\n    return { valid: false, error: 'Invalid latitude (must be -90 to 90)' };\n  }\n\n  if (longitude < -180 || longitude > 180) {\n    return { valid: false, error: 'Invalid longitude (must be -180 to 180)' };\n  }\n\n  return { valid: true };\n}\n\n/**\n * Calculate distance between two coordinates using Haversine formula\n *\n * @param lat1 - First latitude\n * @param lng1 - First longitude\n * @param lat2 - Second latitude\n * @param lng2 - Second longitude\n * @returns Distance in kilometers\n */\nexport function calculateDistance(\n  lat1: number,\n  lng1: number,\n  lat2: number,\n  lng2: number,\n): number {\n  const R = 6371; // Earth radius in km\n  const dLat = toRad(lat2 - lat1);\n  const dLng = toRad(lng2 - lng1);\n\n  const a =\n    Math.sin(dLat / 2) * Math.sin(dLat / 2) +\n    Math.cos(toRad(lat1)) *\n      Math.cos(toRad(lat2)) *\n      Math.sin(dLng / 2) *\n      Math.sin(dLng / 2);\n\n  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));\n  return R * c;\n}\n\n/**\n * Convert degrees to radians\n */\nfunction toRad(degrees: number): number {\n  return degrees * (Math.PI / 180);\n}\n\n/**\n * Format coordinates as string\n *\n * @param latitude - Latitude value\n * @param longitude - Longitude value\n * @param precision - Number of decimal places (default: 6)\n * @returns Formatted coordinate string\n */\nexport function formatCoordinates(\n  latitude: number,\n  longitude: number,\n  precision: number = 6,\n): string {\n  return `${latitude.toFixed(precision)}, ${longitude.toFixed(precision)}`;\n}\n\n/**\n * Parse coordinate string to lat/lng\n *\n * Supports formats:\n * - \"lat, lng\"\n * - \"lat,lng\"\n * - \"lat lng\"\n *\n * @param coordString - Coordinate string\n * @returns Object with lat and lng, or null if invalid\n */\nexport function parseCoordinates(\n  coordString: string,\n): { lat: number; lng: number } | null {\n  // Remove extra whitespace and split\n  const parts = coordString\n    .trim()\n    .replace(/\\s+/g, ' ')\n    .replace(/,\\s*/g, ',')\n    .split(/[,\\s]+/);\n\n  if (parts.length !== 2) return null;\n\n  const lat = parseFloat(parts[0]);\n  const lng = parseFloat(parts[1]);\n\n  if (Number.isNaN(lat) || Number.isNaN(lng)) return null;\n\n  const validation = validateCoordinates(lat, lng);\n  if (!validation.valid) return null;\n\n  return { lat, lng };\n}\n\n/**\n * Normalize address components by trimming and removing empty values\n *\n * @param components - Address components\n * @returns Normalized components\n */\nexport function normalizeAddressComponents(\n  components: Partial<GeoData>,\n): Partial<GeoData> {\n  const normalized: Partial<GeoData> = {};\n\n  for (const [key, value] of Object.entries(components)) {\n    if (value === null || value === undefined) continue;\n\n    if (typeof value === 'string') {\n      const trimmed = value.trim();\n      if (trimmed) {\n        normalized[key as keyof GeoData] = trimmed as any;\n      }\n    } else {\n      normalized[key as keyof GeoData] = value as any;\n    }\n  }\n\n  return normalized;\n}\n\n/**\n * Generate a display name from address components\n *\n * @param components - Address components\n * @returns Formatted display name\n */\nexport function generateDisplayName(components: Partial<GeoData>): string {\n  const parts: string[] = [];\n\n  if (components.streetNumber && components.streetName) {\n    parts.push(`${components.streetNumber} ${components.streetName}`);\n  } else if (components.streetName) {\n    parts.push(components.streetName);\n  }\n\n  if (components.city) parts.push(components.city);\n  if (components.region) parts.push(components.region);\n  if (components.country) parts.push(components.country);\n\n  return parts.join(', ');\n}\n\n/**\n * Check if two coordinates are within a threshold distance\n *\n * @param lat1 - First latitude\n * @param lng1 - First longitude\n * @param lat2 - Second latitude\n * @param lng2 - Second longitude\n * @param thresholdKm - Distance threshold in kilometers\n * @returns True if coordinates are within threshold\n */\nexport function areCoordinatesNear(\n  lat1: number,\n  lng1: number,\n  lat2: number,\n  lng2: number,\n  thresholdKm: number = 0.1,\n): boolean {\n  const distance = calculateDistance(lat1, lng1, lat2, lng2);\n  return distance <= thresholdKm;\n}\n"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@happyvertical/smrt-places",
+  "version": "0.30.0",
+  "description": "Hierarchical place management with geo integration and SMRT framework support",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "CLAUDE.md",
+    "AGENTS.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./utils": {
+      "types": "./dist/utils.d.ts",
+      "import": "./dist/utils.js"
+    },
+    "./manifest": "./dist/manifest.json",
+    "./manifest.json": "./dist/manifest.json"
+  },
+  "dependencies": {
+    "@happyvertical/ai": "^0.74.7",
+    "@happyvertical/cache": "^0.74.7",
+    "@happyvertical/files": "^0.74.7",
+    "@happyvertical/geo": "^0.74.7",
+    "@happyvertical/logger": "^0.74.7",
+    "@happyvertical/sql": "^0.74.7",
+    "@happyvertical/utils": "^0.74.7",
+    "@happyvertical/smrt-assets": "0.30.0",
+    "@happyvertical/smrt-core": "0.30.0",
+    "@happyvertical/smrt-tenancy": "0.30.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.9",
+    "fast-glob": "3.3.3",
+    "typescript": "^5.9.3",
+    "vite": "^7.3.1",
+    "vitest": "^4.0.17",
+    "@happyvertical/smrt-vitest": "0.30.0"
+  },
+  "keywords": [
+    "ai",
+    "agents",
+    "places",
+    "locations",
+    "geocoding",
+    "geography",
+    "hierarchy",
+    "smrt"
+  ],
+  "author": "HappyVertical",
+  "license": "MIT",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/happyvertical/smrt.git",
+    "directory": "packages/places"
+  },
+  "scripts": {
+    "build": "vite build --mode library",
+    "build:fresh": "npm run clean && npm run build",
+    "build:watch": "vite build --mode library --watch",
+    "clean": "rm -rf dist",
+    "dev": "vite dev",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  }
+}