openpets 1.0.5 → 1.0.6

package/search-pets.ts

@@ -1,267 +0,0 @@
-import type { Pet } from "./types";
-
-const REMOTE_API_URL = "https://pets.studio/api.json";
-
-function isDevMode(): boolean {
-  if (typeof process !== 'undefined' && process.env) {
-    return process.env.PETS_DEV_MODE === "true" || process.env.PETS_DEV_MODE === "1";
-  }
-  if (typeof window !== 'undefined' && (window as any).PETS_DEV_MODE) {
-    return true;
-  }
-  return false;
-}
-
-export interface SearchResult {
-  id: string;
-  name: string;
-  description: string;
-  keywords: string[];
-  matchReason: string;
-  matchScore: number;
-}
-
-export interface PetApiData {
-  name: string;
-  description: string;
-  keywords?: string[];
-  title: string;
-  version?: string;
-  source_code_url?: string;
-  tools?: Array<{ name: string; description: string }>;
-  queries?: string[];
-  scenarios?: Record<string, string | string[]>;
-  [key: string]: any;
-}
-
-type SearchIndex = {
-  id: string;
-  nameLower: string;
-  descLower: string;
-  keywordsLower: string[];
-  toolsText: string;
-  queriesText: string;
-  scenariosText: string;
-  data: PetApiData;
-};
-
-let searchIndex: SearchIndex[] | null = null;
-let apiDataCache: Record<string, PetApiData> | null = null;
-
-async function fetchApiData(): Promise<Record<string, PetApiData>> {
-  if (apiDataCache) return apiDataCache;
-
-  if (isDevMode()) {
-    try {
-      const localApiData = await import("../../data/api.json");
-      apiDataCache = localApiData.default as Record<string, PetApiData>;
-      return apiDataCache;
-    } catch (error) {
-      console.warn("Failed to load local api.json, falling back to remote:", error);
-    }
-  }
-
-  try {
-    const response = await fetch(REMOTE_API_URL);
-    if (!response.ok) {
-      throw new Error(`Failed to fetch API data: ${response.status} ${response.statusText}`);
-    }
-    apiDataCache = await response.json();
-    return apiDataCache!;
-  } catch (error) {
-    console.error("Failed to fetch remote API data:", error);
-
-    if (!isDevMode()) {
-      try {
-        const localApiData = await import("../../data/api.json");
-        console.warn("Using local api.json as fallback");
-        apiDataCache = localApiData.default as Record<string, PetApiData>;
-        return apiDataCache;
-      } catch (fallbackError) {
-        console.error("Failed to load local api.json as fallback:", fallbackError);
-      }
-    }
-
-    throw new Error("Unable to load API data from remote or local sources");
-  }
-}
-
-async function buildSearchIndex(): Promise<SearchIndex[]> {
-  if (searchIndex) return searchIndex;
-
-  const apiData = await fetchApiData();
-
-  searchIndex = Object.entries(apiData).map(
-    ([petId, petData]) => {
-      const toolsText = petData.tools
-        ? petData.tools
-            .map((t) => `${t.name} ${t.description}`)
-            .join(" ")
-            .toLowerCase()
-        : "";
-
-      const queriesText = petData.queries
-        ? petData.queries.join(" ").toLowerCase()
-        : "";
-
-      const scenariosText = petData.scenarios
-        ? Object.values(petData.scenarios).flat().join(" ").toLowerCase()
-        : "";
-
-      const shortId = petId.replace("openpets/", "");
-
-      return {
-        id: shortId,
-        nameLower: petData.name.toLowerCase(),
-        descLower: petData.description.toLowerCase(),
-        keywordsLower: petData.keywords?.map((k) => k.toLowerCase()) || [],
-        toolsText,
-        queriesText,
-        scenariosText,
-        data: petData,
-      };
-    }
-  );
-
-  return searchIndex;
-}
-
-function calculateScore(
-  searchTerm: string,
-  index: SearchIndex
-): { score: number; fields: string[] } | null {
-  const fields: string[] = [];
-  let maxScore = 0;
-
-  if (index.nameLower.includes(searchTerm)) {
-    const isExact = index.nameLower === searchTerm;
-    const startsWithSearch = index.nameLower.startsWith(searchTerm);
-    fields.push("name");
-    maxScore = isExact ? 100 : startsWithSearch ? 95 : 85;
-  }
-
-  if (index.keywordsLower.some((k) => k.includes(searchTerm))) {
-    fields.push("keywords");
-    maxScore = Math.max(maxScore, 90);
-  }
-
-  if (index.descLower.includes(searchTerm)) {
-    fields.push("description");
-    maxScore = Math.max(maxScore, 75);
-  }
-
-  if (index.toolsText && index.toolsText.includes(searchTerm)) {
-    fields.push("tools");
-    maxScore = Math.max(maxScore, 70);
-  }
-
-  if (index.queriesText && index.queriesText.includes(searchTerm)) {
-    fields.push("queries");
-    maxScore = Math.max(maxScore, 60);
-  }
-
-  if (index.scenariosText && index.scenariosText.includes(searchTerm)) {
-    fields.push("scenarios");
-    maxScore = Math.max(maxScore, 50);
-  }
-
-  return fields.length > 0 ? { score: maxScore, fields } : null;
-}
-
-export async function searchPets(query: string): Promise<SearchResult[]> {
-  if (!query || query.trim().length === 0) {
-    return [];
-  }
-
-  const searchTerm = query.toLowerCase().trim();
-  const searchTerms = searchTerm.split(/\s+/).filter((t) => t.length > 0);
-  const index = await buildSearchIndex();
-  const results: SearchResult[] = [];
-
-  for (const item of index) {
-    let bestMatch: { score: number; fields: string[] } | null = null;
-
-    if (searchTerms.length === 1) {
-      bestMatch = calculateScore(searchTerm, item);
-    } else {
-      const matches = searchTerms
-        .map((term) => calculateScore(term, item))
-        .filter(Boolean);
-
-      if (matches.length === searchTerms.length) {
-        const allFields = new Set<string>();
-        let totalScore = 0;
-
-        matches.forEach((m) => {
-          if (m) {
-            m.fields.forEach((f) => allFields.add(f));
-            totalScore += m.score;
-          }
-        });
-
-        bestMatch = {
-          score: Math.min(100, Math.floor(totalScore / searchTerms.length)),
-          fields: Array.from(allFields),
-        };
-      } else if (matches.length > 0) {
-        const allFields = new Set<string>();
-        let maxScore = 0;
-
-        matches.forEach((m) => {
-          if (m) {
-            m.fields.forEach((f) => allFields.add(f));
-            maxScore = Math.max(maxScore, m.score);
-          }
-        });
-
-        bestMatch = {
-          score: Math.floor(maxScore * 0.7),
-          fields: Array.from(allFields),
-        };
-      }
-    }
-
-    if (bestMatch) {
-      results.push({
-        id: item.id,
-        name: item.data.name,
-        description: item.data.description,
-        keywords: item.data.keywords || [],
-        matchReason: `Matched in: ${bestMatch.fields.join(", ")}`,
-        matchScore: bestMatch.score,
-      });
-    }
-  }
-
-  return results.sort((a, b) => b.matchScore - a.matchScore);
-}
-
-export function clearSearchCache(): void {
-  searchIndex = null;
-  apiDataCache = null;
-}
-
-export function createPetFromApiData(petId: string, petData: PetApiData): Pet {
-  const shortId = petId.replace("openpets/", "");
-  const { tools, ...restData } = petData;
-  return {
-    id: shortId,
-    ...restData,
-    displayName: petData.title,
-    version: petData.version || "1.0.0",
-    source_code_url: petData.source_code_url || `https://github.com/raggle-ai/pets/tree/main/pets/${shortId}`,
-    queriesCount: petData.queries?.length || 0,
-    queries: petData.queries || [],
-    keywords: petData.keywords || [],
-    tools: tools?.map(t => ({ ...t, schema: {} })),
-    enabled: false,
-    opencodeJsonPath: "",
-  };
-}
-
-export async function getAllPets(): Promise<Pet[]> {
-  const apiData = await fetchApiData();
-  return Object.entries(apiData).map(
-    ([petId, petData]) => createPetFromApiData(petId, petData)
-  );
-}

package/types.ts

@@ -1,68 +0,0 @@
-export interface EnvVariable {
-  name: string
-  description: string
-  provider: string
-  priority: number
-  url?: string
-  setupUrl?: string
-  default?: string
-}
-
-export interface Provider {
-  name: string
-  description: string
-  priority: number
-  homepage?: string
-  envVariables?: EnvVariable[]
-}
-
-export interface EnvVariables {
-  required?: EnvVariable[]
-  optional?: EnvVariable[]
-  note?: string
-}
-
-export interface PetData {
-  name: string
-  description: string
-  keywords: string[]
-  source_code_url: string
-  homepage?: string
-  icon?: string
-  envVariables?: EnvVariables
-  queries: string[]
-  scenarios?: Record<string, string | string[]>
-  providers?: Provider[]
-  connected_pets?: string[]
-}
-
-export interface Tool {
-  name: string
-  description: string
-  schema: Record<string, any>
-}
-
-export interface Pet {
-  id: string
-  name: string
-  displayName: string
-  description: string
-  keywords: string[]
-  source_code_url: string
-  version: string
-  icon?: string
-  homepage?: string
-  envVariables?: EnvVariables
-  queries: string[]
-  queriesCount: number
-  tools?: Tool[]
-  scenarios?: Record<string, string | string[]>
-  providers?: Provider[]
-  connected_pets?: string[]
-  enabled: boolean
-  opencodeJsonPath: string
-}
-
-export interface PetRegistry {
-  [key: string]: PetData
-}