movie-agent 1.0.0

package/dist/filters.js

@@ -0,0 +1,97 @@
+"use strict";
+// src/filters.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterByPlatforms = filterByPlatforms;
+exports.filterByRuntime = filterByRuntime;
+exports.filterByYear = filterByYear;
+exports.applyFilters = applyFilters;
+/**
+ * Filter a movie by checking if it's available on any of the user's platforms
+ * @param movie The movie object with available platforms
+ * @param userPlatforms Array of platform names the user has access to
+ * @returns true if the movie is available on at least one of the user's platforms
+ */
+function filterByPlatforms(movie, userPlatforms) {
+    if (!movie.platforms || movie.platforms.length === 0) {
+        return false;
+    }
+    if (!userPlatforms || userPlatforms.length === 0) {
+        return false;
+    }
+    // Check if any of the movie's platforms match any of the user's platforms
+    return movie.platforms.some(platform => userPlatforms.includes(platform));
+}
+/**
+ * Filter a movie by runtime constraints
+ * @param movie The movie object with runtime information
+ * @param constraints Runtime constraints (min and/or max)
+ * @returns true if the movie's runtime satisfies the constraints
+ */
+function filterByRuntime(movie, constraints) {
+    // If runtime is not specified, we can't filter
+    if (movie.runtime === undefined || movie.runtime === null) {
+        return false;
+    }
+    const { min, max } = constraints;
+    // Check minimum runtime constraint
+    if (min !== undefined && movie.runtime < min) {
+        return false;
+    }
+    // Check maximum runtime constraint
+    if (max !== undefined && movie.runtime > max) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Filter a movie by release year
+ * @param movie The movie object with release_date
+ * @param year Either a specific year (number) or a year range object
+ * @returns true if the movie's release year matches the criteria
+ */
+function filterByYear(movie, year) {
+    if (!movie.release_date) {
+        return false;
+    }
+    // Extract year from release_date (format: YYYY-MM-DD)
+    const releaseYear = parseInt(movie.release_date.split('-')[0], 10);
+    if (isNaN(releaseYear)) {
+        return false;
+    }
+    // If year is a number, check for exact match
+    if (typeof year === 'number') {
+        return releaseYear === year;
+    }
+    // If year is a range, check if release year falls within range
+    const { from, to } = year;
+    if (from !== undefined && releaseYear < from) {
+        return false;
+    }
+    if (to !== undefined && releaseYear > to) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Apply multiple filters to an array of movies
+ * @param movies Array of movies to filter
+ * @param options Filter options to apply
+ * @returns Filtered array of movies that pass all specified filters
+ */
+function applyFilters(movies, options) {
+    let filtered = movies;
+    // Apply platform filter if specified
+    if (options.platforms && options.platforms.length > 0) {
+        filtered = filtered.filter(movie => filterByPlatforms(movie, options.platforms));
+    }
+    // Apply runtime filter if specified
+    if (options.runtime) {
+        filtered = filtered.filter(movie => filterByRuntime(movie, options.runtime));
+    }
+    // Apply year filter if specified
+    if (options.year !== undefined) {
+        filtered = filtered.filter(movie => filterByYear(movie, options.year));
+    }
+    return filtered;
+}
+//# sourceMappingURL=filters.js.map

package/dist/filters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filters.js","sourceRoot":"","sources":["../src/filters.ts"],"names":[],"mappings":"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"}

package/dist/format.d.ts

@@ -0,0 +1,33 @@
+import { MovieRecommendation, StreamingPlatform, AgentResponse, ResponseMetadata } from './types';
+/**
+ * Builds a concise, non-spoiler description (50-100 words)
+ * @param overview - The movie overview from TMDb
+ * @returns Formatted description within word count constraints
+ */
+export declare function buildDescription(overview: string): string;
+/**
+ * Formats a movie with streaming providers into a MovieRecommendation
+ * @param movie - TMDb movie object with id, title, release_date, runtime, overview, genres
+ * @param providers - Streaming provider information
+ * @param reason - Why this movie was recommended
+ * @returns Formatted MovieRecommendation
+ */
+export declare function toRecommendation(movie: {
+    id: number;
+    title: string;
+    release_date: string;
+    runtime: number;
+    overview: string;
+    genres: Array<{
+        id: number;
+        name: string;
+    }>;
+}, providers: StreamingPlatform[], reason: string): MovieRecommendation;
+/**
+ * Formats the complete agent response with recommendations and metadata
+ * @param recommendations - Array of MovieRecommendation objects (3-5 items)
+ * @param metadata - Request metadata including input parameters
+ * @returns Complete AgentResponse object
+ */
+export declare function formatResponse(recommendations: MovieRecommendation[], metadata: Omit<ResponseMetadata, 'requestTimestamp' | 'totalResults'>): AgentResponse;
+//# sourceMappingURL=format.d.ts.map

package/dist/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,gBAAgB,EACjB,MAAM,SAAS,CAAC;AAEjB;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuCzD;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE;IACL,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC7C,EACD,SAAS,EAAE,iBAAiB,EAAE,EAC9B,MAAM,EAAE,MAAM,GACb,mBAAmB,CAcrB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,eAAe,EAAE,mBAAmB,EAAE,EACtC,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,kBAAkB,GAAG,cAAc,CAAC,GACpE,aAAa,CAkBf"}

package/dist/format.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildDescription = buildDescription;
+exports.toRecommendation = toRecommendation;
+exports.formatResponse = formatResponse;
+/**
+ * Builds a concise, non-spoiler description (50-100 words)
+ * @param overview - The movie overview from TMDb
+ * @returns Formatted description within word count constraints
+ */
+function buildDescription(overview) {
+    // TODO: Implement intelligent description builder
+    // - Truncate to 50-100 words
+    // - Avoid spoilers (could use AI or heuristics)
+    // - Ensure complete sentences
+    if (!overview) {
+        return 'No description available.';
+    }
+    const words = overview.split(/\s+/);
+    const minWords = 50;
+    const maxWords = 100;
+    if (words.length <= maxWords) {
+        return overview;
+    }
+    // Truncate to max words and try to end at a sentence boundary
+    const truncated = words.slice(0, maxWords).join(' ');
+    // Find the last sentence-ending punctuation within our limit
+    const lastPeriod = truncated.lastIndexOf('.');
+    const lastExclamation = truncated.lastIndexOf('!');
+    const lastQuestion = truncated.lastIndexOf('?');
+    const lastSentenceEnd = Math.max(lastPeriod, lastExclamation, lastQuestion);
+    if (lastSentenceEnd > 0) {
+        // Check if we have enough words before this point
+        const beforeSentenceEnd = truncated.substring(0, lastSentenceEnd + 1);
+        const beforeWords = beforeSentenceEnd.split(/\s+/).length;
+        if (beforeWords >= minWords) {
+            return beforeSentenceEnd;
+        }
+    }
+    // If we can't find a good sentence boundary, add ellipsis
+    return truncated + '...';
+}
+/**
+ * Formats a movie with streaming providers into a MovieRecommendation
+ * @param movie - TMDb movie object with id, title, release_date, runtime, overview, genres
+ * @param providers - Streaming provider information
+ * @param reason - Why this movie was recommended
+ * @returns Formatted MovieRecommendation
+ */
+function toRecommendation(movie, providers, reason) {
+    const releaseYear = new Date(movie.release_date).getFullYear();
+    const description = buildDescription(movie.overview);
+    const genres = movie.genres.map(g => g.name);
+    return {
+        title: movie.title,
+        releaseYear,
+        runtime: movie.runtime,
+        description,
+        genres,
+        streamingPlatforms: providers,
+        matchReason: reason,
+    };
+}
+/**
+ * Formats the complete agent response with recommendations and metadata
+ * @param recommendations - Array of MovieRecommendation objects (3-5 items)
+ * @param metadata - Request metadata including input parameters
+ * @returns Complete AgentResponse object
+ */
+function formatResponse(recommendations, metadata) {
+    // Enforce 3-5 recommendations
+    if (recommendations.length < 3 || recommendations.length > 5) {
+        throw new Error(`Expected 3-5 recommendations, got ${recommendations.length}`);
+    }
+    const response = {
+        recommendations,
+        metadata: {
+            requestTimestamp: new Date().toISOString(),
+            totalResults: recommendations.length,
+            inputParameters: metadata.inputParameters,
+        },
+    };
+    return response;
+}
+//# sourceMappingURL=format.js.map

package/dist/format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.js","sourceRoot":"","sources":["../src/format.ts"],"names":[],"mappings":";;AAYA,4CAuCC;AASD,4CAyBC;AAQD,wCAqBC;AA3GD;;;;GAIG;AACH,SAAgB,gBAAgB,CAAC,QAAgB;IAC/C,kDAAkD;IAClD,6BAA6B;IAC7B,gDAAgD;IAChD,8BAA8B;IAE9B,IAAI,CAAC,QAAQ,EAAE,CAAC;QACd,OAAO,2BAA2B,CAAC;IACrC,CAAC;IAED,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACpC,MAAM,QAAQ,GAAG,EAAE,CAAC;IACpB,MAAM,QAAQ,GAAG,GAAG,CAAC;IAErB,IAAI,KAAK,CAAC,MAAM,IAAI,QAAQ,EAAE,CAAC;QAC7B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,8DAA8D;IAC9D,MAAM,SAAS,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAErD,6DAA6D;IAC7D,MAAM,UAAU,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAC9C,MAAM,eAAe,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACnD,MAAM,YAAY,GAAG,SAAS,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAChD,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,EAAE,eAAe,EAAE,YAAY,CAAC,CAAC;IAE5E,IAAI,eAAe,GAAG,CAAC,EAAE,CAAC;QACxB,kDAAkD;QAClD,MAAM,iBAAiB,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC,EAAE,eAAe,GAAG,CAAC,CAAC,CAAC;QACtE,MAAM,WAAW,GAAG,iBAAiB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC;QAE1D,IAAI,WAAW,IAAI,QAAQ,EAAE,CAAC;YAC5B,OAAO,iBAAiB,CAAC;QAC3B,CAAC;IACH,CAAC;IAED,0DAA0D;IAC1D,OAAO,SAAS,GAAG,KAAK,CAAC;AAC3B,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,gBAAgB,CAC9B,KAOC,EACD,SAA8B,EAC9B,MAAc;IAEd,MAAM,WAAW,GAAG,IAAI,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC,WAAW,EAAE,CAAC;IAC/D,MAAM,WAAW,GAAG,gBAAgB,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACrD,MAAM,MAAM,GAAG,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;IAE7C,OAAO;QACL,KAAK,EAAE,KAAK,CAAC,KAAK;QAClB,WAAW;QACX,OAAO,EAAE,KAAK,CAAC,OAAO;QACtB,WAAW;QACX,MAAM;QACN,kBAAkB,EAAE,SAAS;QAC7B,WAAW,EAAE,MAAM;KACpB,CAAC;AACJ,CAAC;AAED;;;;;GAKG;AACH,SAAgB,cAAc,CAC5B,eAAsC,EACtC,QAAqE;IAErE,8BAA8B;IAC9B,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,IAAI,eAAe,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAC7D,MAAM,IAAI,KAAK,CACb,qCAAqC,eAAe,CAAC,MAAM,EAAE,CAC9D,CAAC;IACJ,CAAC;IAED,MAAM,QAAQ,GAAkB;QAC9B,eAAe;QACf,QAAQ,EAAE;YACR,gBAAgB,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;YAC1C,YAAY,EAAE,eAAe,CAAC,MAAM;YACpC,eAAe,EAAE,QAAQ,CAAC,eAAe;SAC1C;KACF,CAAC;IAEF,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { MovieAgent } from './agent';
+export { MovieAgentFactory, MovieAgentConfig } from './factory';
+export { UserInput, AgentResponse, MovieRecommendation, StreamingPlatform, ErrorResponse, } from './types';
+export { default as TmdbApiClient } from './tmdbApi';
+export { MovieAgentFactory as default } from './factory';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGrC,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAGhE,OAAO,EACL,SAAS,EACT,aAAa,EACb,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,GACd,MAAM,SAAS,CAAC;AAGjB,OAAO,EAAE,OAAO,IAAI,aAAa,EAAE,MAAM,WAAW,CAAC;AAGrD,OAAO,EAAE,iBAAiB,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// src/index.ts - Main entry point for the movie-agent package
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.TmdbApiClient = exports.MovieAgentFactory = exports.MovieAgent = void 0;
+// Export the main MovieAgent class
+var agent_1 = require("./agent");
+Object.defineProperty(exports, "MovieAgent", { enumerable: true, get: function () { return agent_1.MovieAgent; } });
+// Export the factory for easy configuration
+var factory_1 = require("./factory");
+Object.defineProperty(exports, "MovieAgentFactory", { enumerable: true, get: function () { return factory_1.MovieAgentFactory; } });
+// Export TMDb API client for advanced use cases
+var tmdbApi_1 = require("./tmdbApi");
+Object.defineProperty(exports, "TmdbApiClient", { enumerable: true, get: function () { return __importDefault(tmdbApi_1).default; } });
+// Default export is the factory for convenience
+var factory_2 = require("./factory");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return factory_2.MovieAgentFactory; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,8DAA8D;;;;;;AAE9D,mCAAmC;AACnC,iCAAqC;AAA5B,mGAAA,UAAU,OAAA;AAEnB,4CAA4C;AAC5C,qCAAgE;AAAvD,4GAAA,iBAAiB,OAAA;AAW1B,gDAAgD;AAChD,qCAAqD;AAA5C,yHAAA,OAAO,OAAiB;AAEjC,gDAAgD;AAChD,qCAAyD;AAAhD,kGAAA,iBAAiB,OAAW"}

package/dist/mood.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Maps a mood to an array of movie genres.
+ * @param mood - The mood to map.
+ * @returns Array of genres, or [] if unknown mood.
+ */
+export declare function moodToGenres(mood: string): string[];
+//# sourceMappingURL=mood.d.ts.map

package/dist/mood.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mood.d.ts","sourceRoot":"","sources":["../src/mood.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAWnD"}

package/dist/mood.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.moodToGenres = moodToGenres;
+/**
+ * Maps a mood to an array of movie genres.
+ * @param mood - The mood to map.
+ * @returns Array of genres, or [] if unknown mood.
+ */
+function moodToGenres(mood) {
+    const mapping = {
+        happy: ['Comedy', 'Family', 'Musical'],
+        thoughtful: ['Drama', 'Documentary', 'Biography'],
+        excited: ['Action', 'Adventure', 'Thriller'],
+        relaxed: ['Romance', 'Comedy', 'Animation'],
+        scared: ['Horror', 'Thriller', 'Mystery'],
+    };
+    const genres = mapping[mood.toLowerCase()] || [];
+    // Ensure uniqueness
+    return Array.from(new Set(genres));
+}
+//# sourceMappingURL=mood.js.map

package/dist/mood.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mood.js","sourceRoot":"","sources":["../src/mood.ts"],"names":[],"mappings":";;AAKA,oCAWC;AAhBD;;;;GAIG;AACH,SAAgB,YAAY,CAAC,IAAY;IACvC,MAAM,OAAO,GAA6B;QACxC,KAAK,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,CAAC;QACtC,UAAU,EAAE,CAAC,OAAO,EAAE,aAAa,EAAE,WAAW,CAAC;QACjD,OAAO,EAAE,CAAC,QAAQ,EAAE,WAAW,EAAE,UAAU,CAAC;QAC5C,OAAO,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,WAAW,CAAC;QAC3C,MAAM,EAAE,CAAC,QAAQ,EAAE,UAAU,EAAE,SAAS,CAAC;KAC1C,CAAC;IACF,MAAM,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC;IACjD,oBAAoB;IACpB,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;AACrC,CAAC"}

package/dist/providers.d.ts

@@ -0,0 +1,10 @@
+import TmdbApiClient from './tmdbApi';
+/**
+ * Fetch and normalize Canadian watch providers for a movie.
+ * @param movieId TMDb movie ID
+ * @param region Region code (default: "CA")
+ * @param client Optional TmdbApiClient for testing
+ * @returns Array of normalized platform names
+ */
+export declare function getCanadianProviders(movieId: number | string, region?: string, client?: TmdbApiClient): Promise<string[]>;
+//# sourceMappingURL=providers.d.ts.map

package/dist/providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.d.ts","sourceRoot":"","sources":["../src/providers.ts"],"names":[],"mappings":"AACA,OAAO,aAAa,MAAM,WAAW,CAAC;AAmBtC;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,GAAG,MAAM,EACxB,MAAM,SAAO,EACb,MAAM,CAAC,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,EAAE,CAAC,CAwCnB"}

package/dist/providers.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCanadianProviders = getCanadianProviders;
+// src/providers.ts
+const tmdbApi_1 = __importDefault(require("./tmdbApi"));
+const cache_1 = require("./cache");
+const config_1 = __importDefault(require("./config"));
+// Allowed platforms mapping (add more as needed)
+const PLATFORM_MAP = {
+    Netflix: 'Netflix',
+    'Amazon Prime Video': 'Prime Video',
+    'Disney Plus': 'Disney+',
+    Crave: 'Crave',
+    'Apple TV Plus': 'Apple TV+',
+    'Paramount Plus': 'Paramount+',
+    'CBC Gem': 'CBC Gem',
+    MUBI: 'MUBI',
+    hayu: 'hayu',
+    fuboTV: 'fuboTV',
+    // Add more mappings as needed
+};
+/**
+ * Fetch and normalize Canadian watch providers for a movie.
+ * @param movieId TMDb movie ID
+ * @param region Region code (default: "CA")
+ * @param client Optional TmdbApiClient for testing
+ * @returns Array of normalized platform names
+ */
+async function getCanadianProviders(movieId, region = 'CA', client) {
+    try {
+        // Check cache first
+        const cache = (0, cache_1.getCache)(config_1.default.CACHE_TTL);
+        const cacheKey = (0, cache_1.generateProvidersCacheKey)(movieId, region);
+        const cachedResult = cache.get(cacheKey);
+        if (cachedResult) {
+            return cachedResult;
+        }
+        // Cache miss - fetch from API
+        const apiClient = client ?? new tmdbApi_1.default();
+        const data = await apiClient.getWatchProviders(Number(movieId));
+        if (!data || !data.results || !data.results[region]) {
+            // Cache empty result to avoid repeated API calls
+            cache.set(cacheKey, []);
+            return [];
+        }
+        const regionData = data.results[region];
+        // Only consider 'flatrate' (subscription) providers
+        const flatrate = regionData.flatrate || [];
+        if (!Array.isArray(flatrate) || flatrate.length === 0) {
+            cache.set(cacheKey, []);
+            return [];
+        }
+        // Map provider names to allowed platforms
+        const platforms = flatrate
+            .map((p) => PLATFORM_MAP[p.provider_name])
+            .filter(Boolean);
+        // Remove duplicates
+        const result = Array.from(new Set(platforms));
+        // Store in cache
+        cache.set(cacheKey, result);
+        return result;
+    }
+    catch {
+        return [];
+    }
+}
+//# sourceMappingURL=providers.js.map

package/dist/providers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"providers.js","sourceRoot":"","sources":["../src/providers.ts"],"names":[],"mappings":";;;;;AA2BA,oDA4CC;AAvED,mBAAmB;AACnB,wDAAsC;AACtC,mCAA8D;AAC9D,sDAA8B;AAE9B,iDAAiD;AACjD,MAAM,YAAY,GAA2B;IAC3C,OAAO,EAAE,SAAS;IAClB,oBAAoB,EAAE,aAAa;IACnC,aAAa,EAAE,SAAS;IACxB,KAAK,EAAE,OAAO;IACd,eAAe,EAAE,WAAW;IAC5B,gBAAgB,EAAE,YAAY;IAC9B,SAAS,EAAE,SAAS;IACpB,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,QAAQ;IAChB,8BAA8B;CAC/B,CAAC;AAEF;;;;;;GAMG;AACI,KAAK,UAAU,oBAAoB,CACxC,OAAwB,EACxB,MAAM,GAAG,IAAI,EACb,MAAsB;IAEtB,IAAI,CAAC;QACH,oBAAoB;QACpB,MAAM,KAAK,GAAG,IAAA,gBAAQ,EAAC,gBAAM,CAAC,SAAS,CAAC,CAAC;QACzC,MAAM,QAAQ,GAAG,IAAA,iCAAyB,EAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAC5D,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAW,QAAQ,CAAC,CAAC;QAEnD,IAAI,YAAY,EAAE,CAAC;YACjB,OAAO,YAAY,CAAC;QACtB,CAAC;QAED,8BAA8B;QAC9B,MAAM,SAAS,GAAG,MAAM,IAAI,IAAI,iBAAa,EAAE,CAAC;QAChD,MAAM,IAAI,GAAG,MAAM,SAAS,CAAC,iBAAiB,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;YACpD,iDAAiD;YACjD,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YACxB,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;QACxC,oDAAoD;QACpD,MAAM,QAAQ,GAAG,UAAU,CAAC,QAAQ,IAAI,EAAE,CAAC;QAC3C,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtD,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;YACxB,OAAO,EAAE,CAAC;QACZ,CAAC;QACD,0CAA0C;QAC1C,MAAM,SAAS,GAAG,QAAQ;aACvB,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,YAAY,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC;aAC9C,MAAM,CAAC,OAAO,CAAC,CAAC;QACnB,oBAAoB;QACpB,MAAM,MAAM,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC;QAE9C,iBAAiB;QACjB,KAAK,CAAC,GAAG,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;QAE5B,OAAO,MAAM,CAAC;IAChB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC"}

package/dist/ranking.d.ts

@@ -0,0 +1,57 @@
+import { MovieDetails } from './tmdbApi';
+/**
+ * User input for ranking context
+ */
+export interface RankingInput {
+    /** User's mood to match against genres */
+    mood?: string;
+    /** Explicit genre preferences */
+    genres?: string[];
+    /** User's available streaming platforms */
+    platforms?: string[];
+    /** Runtime constraints */
+    runtime?: {
+        min?: number;
+        max?: number;
+    };
+    /** Release year preferences */
+    year?: {
+        preferred?: number;
+        from?: number;
+        to?: number;
+    };
+}
+/**
+ * Extended movie type with platforms information
+ */
+export interface RankableMovie extends MovieDetails {
+    platforms?: string[];
+}
+/**
+ * Scoring context derived from input
+ */
+export interface ScoringContext {
+    targetGenres: string[];
+    userPlatforms: string[];
+    runtimeMin?: number;
+    runtimeMax?: number;
+    preferredYear?: number;
+    yearFrom?: number;
+    yearTo?: number;
+}
+/**
+ * Calculate overall score for a movie
+ * @param movie - Movie to score
+ * @param input - User input for ranking
+ * @param context - Optional pre-built scoring context
+ * @returns Overall score (0-100)
+ */
+export declare function scoreMovie(movie: RankableMovie, input: RankingInput, context?: ScoringContext): number;
+/**
+ * Rank movies by score
+ * @param movies - Array of movies to rank
+ * @param input - User input for ranking
+ * @returns Sorted array of movies (highest score first)
+ */
+export declare function rankMovies(movies: RankableMovie[], input: RankingInput): RankableMovie[];
+//# sourceMappingURL=ranking.d.ts.map

package/dist/ranking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ranking.d.ts","sourceRoot":"","sources":["../src/ranking.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAGzC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,0CAA0C;IAC1C,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,iCAAiC;IACjC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,2CAA2C;IAC3C,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,0BAA0B;IAC1B,OAAO,CAAC,EAAE;QACR,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,GAAG,CAAC,EAAE,MAAM,CAAC;KACd,CAAC;IACF,+BAA+B;IAC/B,IAAI,CAAC,EAAE;QACL,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,CAAC;CACH;AAED;;GAEG;AACH,MAAM,WAAW,aAAc,SAAQ,YAAY;IACjD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;CACtB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAoMD;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,KAAK,EAAE,aAAa,EACpB,KAAK,EAAE,YAAY,EACnB,OAAO,CAAC,EAAE,cAAc,GACvB,MAAM,CAkBR;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,aAAa,EAAE,EACvB,KAAK,EAAE,YAAY,GAClB,aAAa,EAAE,CAejB"}

package/dist/ranking.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scoreMovie = scoreMovie;
+exports.rankMovies = rankMovies;
+const mood_1 = require("./mood");
+/**
+ * Scoring weights for different criteria
+ */
+const WEIGHTS = {
+    GENRE_MATCH: 40, // Mood/genre alignment
+    PLATFORM_MATCH: 30, // Platform availability
+    RUNTIME_MATCH: 15, // Runtime compatibility
+    YEAR_MATCH: 10, // Release year preference
+    POPULARITY: 5, // Popularity as tiebreaker
+};
+/**
+ * Build scoring context from user input
+ * @param input - User ranking input
+ * @returns Scoring context
+ */
+function buildScoringContext(input) {
+    // Determine target genres from mood or explicit genres
+    let targetGenres = [];
+    if (input.genres && input.genres.length > 0) {
+        targetGenres = input.genres;
+    }
+    else if (input.mood) {
+        targetGenres = (0, mood_1.moodToGenres)(input.mood);
+    }
+    return {
+        targetGenres,
+        userPlatforms: input.platforms || [],
+        runtimeMin: input.runtime?.min,
+        runtimeMax: input.runtime?.max,
+        preferredYear: input.year?.preferred,
+        yearFrom: input.year?.from,
+        yearTo: input.year?.to,
+    };
+}
+/**
+ * Calculate genre match score (0-1)
+ * @param movie - Movie to score
+ * @param context - Scoring context
+ * @returns Score between 0 and 1
+ */
+function scoreGenreMatch(movie, context) {
+    if (context.targetGenres.length === 0) {
+        return 0.5; // Neutral score if no genre preference
+    }
+    if (!movie.genres || movie.genres.length === 0) {
+        return 0;
+    }
+    const movieGenreNames = movie.genres.map(g => g.name);
+    const matchCount = context.targetGenres.filter(targetGenre => movieGenreNames.includes(targetGenre)).length;
+    // Score is the ratio of matched genres to target genres
+    return matchCount / context.targetGenres.length;
+}
+/**
+ * Calculate platform availability score (0-1)
+ * @param movie - Movie to score
+ * @param context - Scoring context
+ * @returns Score between 0 and 1
+ */
+function scorePlatformMatch(movie, context) {
+    if (context.userPlatforms.length === 0) {
+        return 0.5; // Neutral score if no platform preference
+    }
+    if (!movie.platforms || movie.platforms.length === 0) {
+        return 0; // Not available on any platform
+    }
+    // Check if movie is available on any user platform
+    const isAvailable = movie.platforms.some(platform => context.userPlatforms.includes(platform));
+    return isAvailable ? 1 : 0;
+}
+/**
+ * Calculate runtime compatibility score (0-1)
+ * @param movie - Movie to score
+ * @param context - Scoring context
+ * @returns Score between 0 and 1
+ */
+function scoreRuntimeMatch(movie, context) {
+    if (context.runtimeMin === undefined && context.runtimeMax === undefined) {
+        return 0.5; // Neutral score if no runtime preference
+    }
+    if (movie.runtime === undefined || movie.runtime === null) {
+        return 0; // Can't score without runtime info
+    }
+    const { runtimeMin, runtimeMax } = context;
+    // Perfect match if within range
+    if ((runtimeMin === undefined || movie.runtime >= runtimeMin) &&
+        (runtimeMax === undefined || movie.runtime <= runtimeMax)) {
+        return 1;
+    }
+    // Calculate how far outside the range
+    let distance = 0;
+    if (runtimeMin !== undefined && movie.runtime < runtimeMin) {
+        distance = runtimeMin - movie.runtime;
+    }
+    else if (runtimeMax !== undefined && movie.runtime > runtimeMax) {
+        distance = movie.runtime - runtimeMax;
+    }
+    // Penalize based on distance (exponential decay)
+    // Movies 30+ minutes outside range get very low scores
+    return Math.max(0, Math.exp(-distance / 30));
+}
+/**
+ * Calculate release year preference score (0-1)
+ * @param movie - Movie to score
+ * @param context - Scoring context
+ * @returns Score between 0 and 1
+ */
+function scoreYearMatch(movie, context) {
+    if (context.preferredYear === undefined &&
+        context.yearFrom === undefined &&
+        context.yearTo === undefined) {
+        return 0.5; // Neutral score if no year preference
+    }
+    if (!movie.release_date) {
+        return 0; // Can't score without release date
+    }
+    const releaseYear = parseInt(movie.release_date.split('-')[0], 10);
+    if (isNaN(releaseYear)) {
+        return 0;
+    }
+    // Perfect match for preferred year
+    if (context.preferredYear !== undefined) {
+        if (releaseYear === context.preferredYear) {
+            return 1;
+        }
+        // Decay score based on distance from preferred year
+        const distance = Math.abs(releaseYear - context.preferredYear);
+        return Math.max(0, Math.exp(-distance / 5));
+    }
+    // Check if within acceptable range
+    if ((context.yearFrom === undefined || releaseYear >= context.yearFrom) &&
+        (context.yearTo === undefined || releaseYear <= context.yearTo)) {
+        return 1;
+    }
+    // Outside range
+    return 0;
+}
+/**
+ * Normalize popularity score (0-1)
+ * @param movie - Movie to score
+ * @returns Normalized score between 0 and 1
+ */
+function scorePopularity(movie) {
+    if (movie.popularity === undefined || movie.popularity === null) {
+        return 0;
+    }
+    // TMDb popularity typically ranges from 0-1000+
+    // Use logarithmic scale to normalize
+    const maxPopularity = 1000;
+    const normalized = Math.min(movie.popularity, maxPopularity) / maxPopularity;
+    return normalized;
+}
+/**
+ * Calculate overall score for a movie
+ * @param movie - Movie to score
+ * @param input - User input for ranking
+ * @param context - Optional pre-built scoring context
+ * @returns Overall score (0-100)
+ */
+function scoreMovie(movie, input, context) {
+    const ctx = context || buildScoringContext(input);
+    const genreScore = scoreGenreMatch(movie, ctx);
+    const platformScore = scorePlatformMatch(movie, ctx);
+    const runtimeScore = scoreRuntimeMatch(movie, ctx);
+    const yearScore = scoreYearMatch(movie, ctx);
+    const popularityScore = scorePopularity(movie);
+    // Calculate weighted total
+    const totalScore = genreScore * WEIGHTS.GENRE_MATCH +
+        platformScore * WEIGHTS.PLATFORM_MATCH +
+        runtimeScore * WEIGHTS.RUNTIME_MATCH +
+        yearScore * WEIGHTS.YEAR_MATCH +
+        popularityScore * WEIGHTS.POPULARITY;
+    return totalScore;
+}
+/**
+ * Rank movies by score
+ * @param movies - Array of movies to rank
+ * @param input - User input for ranking
+ * @returns Sorted array of movies (highest score first)
+ */
+function rankMovies(movies, input) {
+    // Build context once for efficiency
+    const context = buildScoringContext(input);
+    // Score all movies
+    const scoredMovies = movies.map(movie => ({
+        movie,
+        score: scoreMovie(movie, input, context),
+    }));
+    // Sort by score (descending)
+    scoredMovies.sort((a, b) => b.score - a.score);
+    // Return sorted movies
+    return scoredMovies.map(item => item.movie);
+}
+//# sourceMappingURL=ranking.js.map