arendi-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1459 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import "dotenv/config";
+
+// src/cli.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { homedir } from "os";
+import { Command } from "commander";
+
+// ../../packages/arendi/dist/types.js
+import { z } from "zod";
+var CATEGORIES = [
+  "books",
+  "business",
+  "education",
+  "entertainment",
+  "fashion",
+  "finance",
+  "fitness",
+  "food",
+  "gaming",
+  "health",
+  "lifestyle",
+  "marketing",
+  "music",
+  "pets",
+  "real-estate",
+  "saas",
+  "social-media",
+  "sports",
+  "technology",
+  "travel"
+];
+var PROVIDERS = ["openai", "anthropic", "google"];
+var OUTPUT_FORMATS = ["markdown", "json", "csv", "text"];
+var optionsSchema = z.object({
+  country: z.string().optional(),
+  city: z.string().optional(),
+  categories: z.array(z.string()).optional(),
+  limit: z.number().min(1).max(50).default(5),
+  keywords: z.array(z.string()).optional(),
+  provider: z.enum(PROVIDERS).default("openai"),
+  model: z.string().optional(),
+  apiKey: z.string().min(1, "LLM provider API key is required"),
+  tavilyApiKey: z.string().min(1, "Tavily API key is required"),
+  /** Optional ISO 3166-1 alpha-2 code for Google Trends (e.g. "US", "ID"). Auto-detected from `country` if omitted. */
+  geo: z.string().length(2).optional()
+});
+var tavilyResultSchema = z.object({
+  title: z.string(),
+  url: z.string(),
+  content: z.string(),
+  score: z.number()
+});
+var tavilyResponseSchema = z.object({
+  results: z.array(tavilyResultSchema)
+});
+var businessIdeaSchema = z.object({
+  title: z.string().describe("A concise, compelling title for the business idea"),
+  description: z.string().describe("A 2-3 sentence description of the business idea"),
+  category: z.string().describe("The primary category this idea falls under"),
+  targetAudience: z.string().describe("Who this business targets (demographics, psychographics)"),
+  painPoint: z.string().describe("The specific pain point or unmet need this addresses"),
+  opportunityType: z.enum(["trending", "pain-point", "gap", "trend-transfer"]).describe("How this opportunity was identified: trending topic, pain point, market gap, or trend transferred from another market"),
+  estimatedDifficulty: z.enum(["low", "medium", "high"]).describe("How difficult it is to start this business"),
+  potentialRevenue: z.enum(["low", "medium", "high"]).describe("Estimated revenue potential"),
+  reasoning: z.string().describe("Why this is a good opportunity right now, grounded in the research data"),
+  actionableSteps: z.array(z.string()).describe("3-5 concrete first steps to pursue this idea"),
+  references: z.array(z.string()).describe("URLs or sources that support this idea")
+});
+var arendiResultSchema = z.object({
+  ideas: z.array(businessIdeaSchema)
+});
+
+// ../../packages/arendi/dist/format.js
+function toMarkdown(ideas) {
+  const lines = [`# Business Ideas & Opportunities`, ""];
+  for (let i = 0; i < ideas.length; i++) {
+    const idea = ideas[i];
+    const num = i + 1;
+    lines.push(`## ${num}. ${idea.title}`);
+    lines.push("");
+    lines.push(idea.description);
+    lines.push("");
+    lines.push(`| Field | Value |`);
+    lines.push(`| --- | --- |`);
+    lines.push(`| **Category** | ${idea.category} |`);
+    lines.push(`| **Opportunity type** | ${idea.opportunityType} |`);
+    lines.push(`| **Target audience** | ${idea.targetAudience} |`);
+    lines.push(`| **Pain point** | ${idea.painPoint} |`);
+    lines.push(`| **Difficulty** | ${idea.estimatedDifficulty} |`);
+    lines.push(`| **Revenue potential** | ${idea.potentialRevenue} |`);
+    lines.push("");
+    lines.push(`### Why now?`);
+    lines.push("");
+    lines.push(idea.reasoning);
+    lines.push("");
+    lines.push(`### Actionable steps`);
+    lines.push("");
+    for (const step of idea.actionableSteps) {
+      lines.push(`1. ${step}`);
+    }
+    lines.push("");
+    if (idea.references.length > 0) {
+      lines.push(`### References`);
+      lines.push("");
+      for (const ref of idea.references) {
+        lines.push(`- ${ref}`);
+      }
+      lines.push("");
+    }
+    lines.push("---");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function toJson(ideas) {
+  return JSON.stringify(ideas, null, 2);
+}
+function escapeCsv(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function toCsv(ideas) {
+  const headers = [
+    "title",
+    "description",
+    "category",
+    "targetAudience",
+    "painPoint",
+    "opportunityType",
+    "estimatedDifficulty",
+    "potentialRevenue",
+    "reasoning",
+    "actionableSteps",
+    "references"
+  ];
+  const rows = ideas.map((idea) => [
+    escapeCsv(idea.title),
+    escapeCsv(idea.description),
+    escapeCsv(idea.category),
+    escapeCsv(idea.targetAudience),
+    escapeCsv(idea.painPoint),
+    escapeCsv(idea.opportunityType),
+    escapeCsv(idea.estimatedDifficulty),
+    escapeCsv(idea.potentialRevenue),
+    escapeCsv(idea.reasoning),
+    escapeCsv(idea.actionableSteps.join("; ")),
+    escapeCsv(idea.references.join("; "))
+  ].join(","));
+  return [headers.join(","), ...rows].join("\n");
+}
+function toText(ideas) {
+  const lines = [
+    "BUSINESS IDEAS & OPPORTUNITIES",
+    "=".repeat(40),
+    ""
+  ];
+  for (let i = 0; i < ideas.length; i++) {
+    const idea = ideas[i];
+    const num = i + 1;
+    lines.push(`${num}. ${idea.title.toUpperCase()}`);
+    lines.push("-".repeat(40));
+    lines.push(idea.description);
+    lines.push("");
+    lines.push(`  Category:          ${idea.category}`);
+    lines.push(`  Opportunity type:  ${idea.opportunityType}`);
+    lines.push(`  Target audience:   ${idea.targetAudience}`);
+    lines.push(`  Pain point:        ${idea.painPoint}`);
+    lines.push(`  Difficulty:        ${idea.estimatedDifficulty}`);
+    lines.push(`  Revenue potential: ${idea.potentialRevenue}`);
+    lines.push("");
+    lines.push(`  Why now?`);
+    lines.push(`  ${idea.reasoning}`);
+    lines.push("");
+    lines.push(`  Steps:`);
+    for (const step of idea.actionableSteps) {
+      lines.push(`    - ${step}`);
+    }
+    lines.push("");
+    if (idea.references.length > 0) {
+      lines.push(`  References:`);
+      for (const ref of idea.references) {
+        lines.push(`    - ${ref}`);
+      }
+      lines.push("");
+    }
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+function formatIdeas(ideas, format) {
+  switch (format) {
+    case "markdown":
+      return toMarkdown(ideas);
+    case "json":
+      return toJson(ideas);
+    case "csv":
+      return toCsv(ideas);
+    case "text":
+      return toText(ideas);
+  }
+}
+
+// ../../packages/arendi/dist/search.js
+import { createHash } from "crypto";
+
+// ../../packages/arendi/dist/trends.js
+import googleTrends from "google-trends-api";
+var COUNTRY_GEO_MAP = {
+  afghanistan: "AF",
+  albania: "AL",
+  algeria: "DZ",
+  argentina: "AR",
+  australia: "AU",
+  austria: "AT",
+  bangladesh: "BD",
+  belgium: "BE",
+  bolivia: "BO",
+  brazil: "BR",
+  cambodia: "KH",
+  cameroon: "CM",
+  canada: "CA",
+  chile: "CL",
+  china: "CN",
+  colombia: "CO",
+  "costa rica": "CR",
+  croatia: "HR",
+  "czech republic": "CZ",
+  czechia: "CZ",
+  denmark: "DK",
+  "dominican republic": "DO",
+  ecuador: "EC",
+  egypt: "EG",
+  "el salvador": "SV",
+  ethiopia: "ET",
+  finland: "FI",
+  france: "FR",
+  germany: "DE",
+  ghana: "GH",
+  greece: "GR",
+  guatemala: "GT",
+  honduras: "HN",
+  "hong kong": "HK",
+  hungary: "HU",
+  india: "IN",
+  indonesia: "ID",
+  iran: "IR",
+  iraq: "IQ",
+  ireland: "IE",
+  israel: "IL",
+  italy: "IT",
+  jamaica: "JM",
+  japan: "JP",
+  jordan: "JO",
+  kazakhstan: "KZ",
+  kenya: "KE",
+  "south korea": "KR",
+  korea: "KR",
+  kuwait: "KW",
+  laos: "LA",
+  lebanon: "LB",
+  libya: "LY",
+  malaysia: "MY",
+  mexico: "MX",
+  morocco: "MA",
+  myanmar: "MM",
+  nepal: "NP",
+  netherlands: "NL",
+  "new zealand": "NZ",
+  nicaragua: "NI",
+  nigeria: "NG",
+  norway: "NO",
+  oman: "OM",
+  pakistan: "PK",
+  panama: "PA",
+  paraguay: "PY",
+  peru: "PE",
+  philippines: "PH",
+  poland: "PL",
+  portugal: "PT",
+  qatar: "QA",
+  romania: "RO",
+  russia: "RU",
+  "saudi arabia": "SA",
+  senegal: "SN",
+  serbia: "RS",
+  singapore: "SG",
+  slovakia: "SK",
+  "south africa": "ZA",
+  spain: "ES",
+  "sri lanka": "LK",
+  sweden: "SE",
+  switzerland: "CH",
+  taiwan: "TW",
+  tanzania: "TZ",
+  thailand: "TH",
+  tunisia: "TN",
+  turkey: "TR",
+  turkiye: "TR",
+  uganda: "UG",
+  ukraine: "UA",
+  "united arab emirates": "AE",
+  uae: "AE",
+  "united kingdom": "GB",
+  uk: "GB",
+  "united states": "US",
+  usa: "US",
+  us: "US",
+  uruguay: "UY",
+  uzbekistan: "UZ",
+  venezuela: "VE",
+  vietnam: "VN",
+  zambia: "ZM",
+  zimbabwe: "ZW"
+};
+function countryToGeo(country) {
+  const trimmed = country.trim();
+  if (/^[A-Za-z]{2}$/.test(trimmed)) {
+    return trimmed.toUpperCase();
+  }
+  return COUNTRY_GEO_MAP[trimmed.toLowerCase()] ?? null;
+}
+async function fetchDailyTrends(geo) {
+  try {
+    const raw = await googleTrends.dailyTrends({ geo });
+    const parsed = JSON.parse(raw);
+    const days = parsed?.["default"];
+    const trendingDays = days?.["trendingSearchesDays"] ?? [];
+    const results = [];
+    for (const day of trendingDays) {
+      const searches = day["trendingSearches"] ?? [];
+      for (const search of searches) {
+        const title = search["title"]?.["query"] ?? "";
+        const traffic = search["formattedTraffic"] ?? "";
+        const relatedQueriesRaw = search["relatedQueries"] ?? [];
+        const relatedQueries = relatedQueriesRaw.map((q) => q["query"] ?? "").filter(Boolean);
+        if (title) {
+          results.push({ title, traffic, relatedQueries });
+        }
+      }
+    }
+    return results;
+  } catch (error) {
+    console.warn(`Warning: Failed to fetch daily trends for geo "${geo}":`, error instanceof Error ? error.message : String(error));
+    return [];
+  }
+}
+async function fetchRelatedQueries(keywords, geo) {
+  const ninetyDaysAgo = /* @__PURE__ */ new Date();
+  ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90);
+  const results = await Promise.all(keywords.map(async (keyword) => {
+    try {
+      const raw = await googleTrends.relatedQueries({
+        keyword,
+        startTime: ninetyDaysAgo,
+        geo: geo ?? ""
+      });
+      const parsed = JSON.parse(raw);
+      const rankedList = parsed?.["default"]?.["rankedList"];
+      if (!rankedList || rankedList.length === 0) {
+        return { keyword, rising: [], top: [] };
+      }
+      const topList = rankedList[0]?.["rankedKeyword"] ?? [];
+      const risingList = rankedList[1]?.["rankedKeyword"] ?? [];
+      const top = topList.map((item) => ({
+        query: item["query"] ?? "",
+        value: item["value"] ?? 0
+      })).filter((item) => item.query);
+      const rising = risingList.map((item) => ({
+        query: item["query"] ?? "",
+        value: item["formattedValue"] ?? item["value"] ?? 0
+      })).filter((item) => item.query);
+      return { keyword, rising, top };
+    } catch (error) {
+      console.warn(`Warning: Failed to fetch related queries for "${keyword}":`, error instanceof Error ? error.message : String(error));
+      return null;
+    }
+  }));
+  return results.filter((r) => r !== null);
+}
+async function fetchRelatedTopics(keywords, geo) {
+  const ninetyDaysAgo = /* @__PURE__ */ new Date();
+  ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90);
+  const results = await Promise.all(keywords.map(async (keyword) => {
+    try {
+      const raw = await googleTrends.relatedTopics({
+        keyword,
+        startTime: ninetyDaysAgo,
+        geo: geo ?? ""
+      });
+      const parsed = JSON.parse(raw);
+      const rankedList = parsed?.["default"]?.["rankedList"];
+      if (!rankedList || rankedList.length === 0) {
+        return { keyword, rising: [], top: [] };
+      }
+      const topList = rankedList[0]?.["rankedKeyword"] ?? [];
+      const risingList = rankedList[1]?.["rankedKeyword"] ?? [];
+      const top = topList.map((item) => {
+        const topic = item["topic"];
+        return {
+          title: topic?.["title"] ?? "",
+          type: topic?.["type"] ?? "",
+          value: item["value"] ?? 0
+        };
+      }).filter((item) => item.title);
+      const rising = risingList.map((item) => {
+        const topic = item["topic"];
+        return {
+          title: topic?.["title"] ?? "",
+          type: topic?.["type"] ?? "",
+          value: item["formattedValue"] ?? item["value"] ?? 0
+        };
+      }).filter((item) => item.title);
+      return { keyword, rising, top };
+    } catch (error) {
+      console.warn(`Warning: Failed to fetch related topics for "${keyword}":`, error instanceof Error ? error.message : String(error));
+      return null;
+    }
+  }));
+  return results.filter((r) => r !== null);
+}
+async function trendsResearch(options) {
+  const geo = options.geo ? options.geo.toUpperCase() : options.country ? countryToGeo(options.country) : null;
+  const keywords = options.keywords?.length ? [...options.keywords] : [];
+  if (options.categories?.length && keywords.length === 0) {
+    keywords.push(...options.categories);
+  }
+  const [dailyTrends, relatedQueries, relatedTopics] = await Promise.all([
+    geo ? fetchDailyTrends(geo) : Promise.resolve([]),
+    keywords.length > 0 ? fetchRelatedQueries(keywords, geo ?? void 0) : Promise.resolve([]),
+    keywords.length > 0 ? fetchRelatedTopics(keywords, geo ?? void 0) : Promise.resolve([])
+  ]);
+  return { dailyTrends, relatedQueries, relatedTopics };
+}
+function summarizeTrends(ctx) {
+  const sections = [];
+  if (ctx.dailyTrends.length > 0) {
+    const items = ctx.dailyTrends.slice(0, 20).map((t) => {
+      let line = `- **${t.title}**`;
+      if (t.traffic)
+        line += ` (${t.traffic} searches)`;
+      if (t.relatedQueries.length > 0) {
+        line += ` \u2014 related: ${t.relatedQueries.join(", ")}`;
+      }
+      return line;
+    }).join("\n");
+    sections.push(`### Daily Trending Searches
+
+These are the top trending search terms in the target market right now.
+
+${items}`);
+  }
+  const risingQueries = ctx.relatedQueries.filter((r) => r.rising.length > 0);
+  if (risingQueries.length > 0) {
+    const items = risingQueries.map((r) => {
+      const queries = r.rising.slice(0, 10).map((q) => {
+        const label = typeof q.value === "string" ? q.value : `+${q.value}%`;
+        return `  - "${q.query}" (${label})`;
+      }).join("\n");
+      return `- **${r.keyword}**:
+${queries}`;
+    }).join("\n");
+    sections.push(`### Rising Search Queries
+
+Queries with the biggest recent increase in search frequency. "Breakout" means massive growth from near-zero.
+
+${items}`);
+  }
+  const risingTopics = ctx.relatedTopics.filter((r) => r.rising.length > 0);
+  if (risingTopics.length > 0) {
+    const items = risingTopics.map((r) => {
+      const topics = r.rising.slice(0, 10).map((t) => {
+        const label = typeof t.value === "string" ? t.value : `+${t.value}%`;
+        return `  - ${t.title} (${t.type}) \u2014 ${label}`;
+      }).join("\n");
+      return `- **${r.keyword}**:
+${topics}`;
+    }).join("\n");
+    sections.push(`### Rising Related Topics
+
+Topics with the biggest recent increase in search interest.
+
+${items}`);
+  }
+  if (sections.length === 0)
+    return "";
+  return `## Google Trends Data
+
+Real-time search demand signals from Google Trends showing what people are actively searching for.
+
+${sections.join("\n\n")}`;
+}
+
+// ../../packages/arendi/dist/search.js
+var TAVILY_API_URL = "https://api.tavily.com/search";
+var TAVILY_CACHE_TTL_MS = 864e5;
+function buildCacheKey(query, includeDomains) {
+  const parts = [query];
+  if (includeDomains?.length) {
+    parts.push(...[...includeDomains].sort());
+  }
+  const hash = createHash("sha256").update(parts.join("|")).digest("hex");
+  return `tavily:${hash}`;
+}
+var GLOBAL_DOMAINS = /* @__PURE__ */ new Set([
+  "wikipedia.org",
+  "youtube.com",
+  "reddit.com",
+  "medium.com",
+  "facebook.com",
+  "twitter.com",
+  "x.com",
+  "linkedin.com",
+  "instagram.com",
+  "tiktok.com",
+  "quora.com",
+  "forbes.com",
+  "bloomberg.com",
+  "cnbc.com",
+  "bbc.com",
+  "cnn.com",
+  "reuters.com"
+]);
+async function tavilySearch(query, apiKey, options) {
+  const { cache, cacheStats } = options ?? {};
+  if (cache) {
+    const key = buildCacheKey(query, options?.includeDomains);
+    try {
+      const cached = await cache.get(key);
+      if (cached !== null) {
+        if (cacheStats)
+          cacheStats.hits++;
+        return JSON.parse(cached);
+      }
+    } catch {
+    }
+    if (cacheStats)
+      cacheStats.misses++;
+  }
+  const body = {
+    api_key: apiKey,
+    query,
+    search_depth: "advanced",
+    max_results: 5,
+    include_answer: false
+  };
+  if (options?.includeDomains?.length) {
+    body["include_domains"] = options.includeDomains;
+  }
+  const response = await fetch(TAVILY_API_URL, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`Tavily search failed (${response.status}): ${text}`);
+  }
+  const data = await response.json();
+  const parsed = tavilyResponseSchema.safeParse(data);
+  if (!parsed.success) {
+    console.warn(`Warning: Could not parse Tavily response for "${query}"`);
+    return [];
+  }
+  const results = parsed.data.results;
+  if (cache) {
+    const key = buildCacheKey(query, options?.includeDomains);
+    try {
+      await cache.set(key, JSON.stringify(results), TAVILY_CACHE_TTL_MS);
+    } catch {
+    }
+  }
+  return results;
+}
+async function discoverLocalSources(options, cacheStats) {
+  const locationParts = [];
+  if (options.city)
+    locationParts.push(options.city);
+  if (options.country)
+    locationParts.push(options.country);
+  const location = locationParts.join(", ");
+  if (!location)
+    return [];
+  const discoveryQueries = [
+    `top local business news websites in ${location}`,
+    `popular local media sources ${location} economy startups`,
+    `${location} local online newspapers business publications`
+  ];
+  const allResults = await Promise.all(discoveryQueries.map((q) => tavilySearch(q, options.tavilyApiKey, {
+    cache: options.cache,
+    cacheStats
+  })));
+  const domains = /* @__PURE__ */ new Set();
+  for (const results of allResults) {
+    for (const result of results) {
+      try {
+        const url = new URL(result.url);
+        const hostname = url.hostname.replace(/^www\./, "");
+        if (!GLOBAL_DOMAINS.has(hostname)) {
+          domains.add(hostname);
+        }
+      } catch {
+      }
+    }
+  }
+  return Array.from(domains);
+}
+function buildLocalSearchQueries(options) {
+  const locationParts = [];
+  if (options.city)
+    locationParts.push(options.city);
+  if (options.country)
+    locationParts.push(options.country);
+  const location = locationParts.join(" ");
+  if (!location)
+    return [];
+  const cats = options.categories?.join(", ") ?? "";
+  const kw = options.keywords?.join(", ") ?? "";
+  const year = (/* @__PURE__ */ new Date()).getFullYear();
+  const queries = [];
+  queries.push([`business opportunities trends`, cats, location, year].filter(Boolean).join(" "));
+  queries.push([`consumer needs problems`, cats, location, year].filter(Boolean).join(" "));
+  queries.push([`startup ecosystem market growth`, cats, location, year].filter(Boolean).join(" "));
+  if (kw) {
+    queries.push([kw, `market demand`, location, year].filter(Boolean).join(" "));
+  }
+  return queries;
+}
+function buildGlobalSearchQueries(options) {
+  const parts = [];
+  if (options.country)
+    parts.push(options.country);
+  if (options.city)
+    parts.push(options.city);
+  const location = parts.join(" ");
+  const cats = options.categories?.join(", ") ?? "";
+  const kw = options.keywords?.join(", ") ?? "";
+  const queries = [];
+  queries.push([
+    "trending business opportunities",
+    cats,
+    location,
+    (/* @__PURE__ */ new Date()).getFullYear()
+  ].filter(Boolean).join(" "));
+  queries.push(["consumer pain points", cats, location, (/* @__PURE__ */ new Date()).getFullYear()].filter(Boolean).join(" "));
+  queries.push(["market gaps underserved needs", cats, location].filter(Boolean).join(" "));
+  if (kw) {
+    queries.push(["emerging trends", kw, cats, "business", (/* @__PURE__ */ new Date()).getFullYear()].filter(Boolean).join(" "));
+  }
+  queries.push([
+    "successful business models trending globally",
+    cats,
+    (/* @__PURE__ */ new Date()).getFullYear()
+  ].filter(Boolean).join(" "));
+  return queries;
+}
+async function localResearch(options, localDomains, cacheStats) {
+  const queries = buildLocalSearchQueries(options);
+  if (queries.length === 0)
+    return [];
+  const searchOpts = {
+    includeDomains: localDomains.length > 0 ? localDomains : void 0,
+    cache: options.cache,
+    cacheStats
+  };
+  const results = await Promise.all(queries.map(async (query) => {
+    const res = await tavilySearch(query, options.tavilyApiKey, searchOpts);
+    return { query, results: res };
+  }));
+  return results;
+}
+async function globalResearch(options, cacheStats) {
+  const queries = buildGlobalSearchQueries(options);
+  const results = await Promise.all(queries.map(async (query) => {
+    const res = await tavilySearch(query, options.tavilyApiKey, {
+      cache: options.cache,
+      cacheStats
+    });
+    return { query, results: res };
+  }));
+  return results;
+}
+function summarizeContexts(contexts) {
+  return contexts.map((ctx) => {
+    const snippets = ctx.results.map((r) => `- [${r.title}](${r.url}): ${r.content}`).join("\n");
+    return `### Search: "${ctx.query}"
+${snippets || "No results found."}`;
+  }).join("\n\n");
+}
+function summarizeAllResearch(localContexts, globalContexts, trendsContext) {
+  const sections = [];
+  if (localContexts.length > 0) {
+    const localHasResults = localContexts.some((c) => c.results.length > 0);
+    if (localHasResults) {
+      sections.push(`## Local Sources
+
+These results come from local and regional media in the target market.
+
+${summarizeContexts(localContexts)}`);
+    }
+  }
+  if (globalContexts.length > 0) {
+    sections.push(`## Global Sources
+
+These results come from international and global publications.
+
+${summarizeContexts(globalContexts)}`);
+  }
+  if (trendsContext) {
+    const trendsSummary = summarizeTrends(trendsContext);
+    if (trendsSummary) {
+      sections.push(trendsSummary);
+    }
+  }
+  return sections.join("\n\n---\n\n");
+}
+
+// ../../packages/arendi/dist/generate.js
+import { generateObject } from "ai";
+
+// ../../packages/arendi/dist/provider.js
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+import { createGoogleGenerativeAI } from "@ai-sdk/google";
+var DEFAULT_MODELS = {
+  openai: "gpt-4o",
+  anthropic: "claude-sonnet-4-20250514",
+  google: "gemini-2.0-flash"
+};
+function createModel(provider, apiKey, model) {
+  const modelId = model ?? DEFAULT_MODELS[provider];
+  switch (provider) {
+    case "openai": {
+      const openai = createOpenAI({ apiKey });
+      return openai(modelId);
+    }
+    case "anthropic": {
+      const anthropic = createAnthropic({ apiKey });
+      return anthropic(modelId);
+    }
+    case "google": {
+      const google = createGoogleGenerativeAI({ apiKey });
+      return google(modelId);
+    }
+  }
+}
+
+// ../../packages/arendi/dist/generate.js
+function buildSystemPrompt() {
+  return `You are a world-class business strategist and market analyst. Your job is to
+analyze real-time research data and generate actionable, creative, and well-reasoned
+business ideas and opportunities.
+
+You will receive THREE types of research data:
+
+1. **Local Sources** \u2013 Information from local and regional media, news outlets, and
+   publications in the target market. These provide on-the-ground insights about what
+   is actually happening in the specific country, city, or region.
+2. **Global Sources** \u2013 Information from international publications and global trend
+   reports. These provide a broader view of worldwide trends, successful models, and
+   emerging opportunities.
+3. **Google Trends Data** \u2013 Real-time search demand signals from Google Trends showing
+   what people are actively searching for right now, which queries are spiking
+   ("Breakout" = massive growth from near-zero), and which topics are rising in
+   popularity. This data reveals actual consumer intent and demand.
+
+**Local sources should be your PRIMARY foundation.** Use them to understand the real
+conditions, needs, pain points, and cultural context of the target market. Then use
+global sources to identify transferable models, worldwide trends that could be
+localized, and broader market sizing data. Use Google Trends data to validate demand
+signals \u2014 rising search queries indicate real consumer interest and unmet needs.
+
+When analyzing the research data you MUST consider:
+
+1. **Local context first** \u2013 What do local sources say about the market? What problems
+   are people actually talking about on the ground?
+2. **Trending topics** \u2013 What is gaining popularity and momentum right now? Cross-
+   reference Google Trends rising queries with news articles for strongest signals.
+3. **Pain points** \u2013 What are consumers or businesses struggling with? What frustrations
+   exist that are not being adequately addressed?
+4. **Market gaps** \u2013 Where is there underserved demand? What products or services are
+   missing or poorly executed? Rising search queries with no clear market leader are
+   strong gap indicators.
+5. **Trend transfers** \u2013 What successful business models or trends in other countries,
+   cities, or industries could be adapted to the target market? Use local sources to
+   validate whether a transfer makes sense culturally and economically.
+
+For each idea you produce:
+- Ground it in the research data provided. Prefer citing local sources when available.
+- Be specific about the target audience (demographics, psychographics).
+- Explain WHY this is a good opportunity RIGHT NOW (timing, market conditions).
+  Reference Google Trends data where it supports the timing argument.
+- Provide realistic, concrete first steps someone could take this week.
+- Assess difficulty and revenue potential honestly.
+- Include source URLs from the research \u2014 prioritize local source URLs but include
+  global ones where they add supporting evidence.
+
+Aim for diversity across opportunity types. Do not produce generic ideas like
+"start a blog" or "become a freelancer" \u2014 be specific and creative.`;
+}
+function buildUserPrompt(options, researchSummary) {
+  const contextParts = [];
+  if (options.country)
+    contextParts.push(`Country: ${options.country}`);
+  if (options.city)
+    contextParts.push(`City: ${options.city}`);
+  if (options.categories?.length)
+    contextParts.push(`Categories: ${options.categories.join(", ")}`);
+  if (options.keywords?.length)
+    contextParts.push(`Keywords: ${options.keywords.join(", ")}`);
+  const context = contextParts.length > 0 ? `## Target Market
+${contextParts.join("\n")}` : "## Target Market\nNo specific market constraints provided \u2014 generate globally relevant ideas.";
+  return `${context}
+
+## Research Data
+
+The following research was gathered from the web just now. It is divided into
+**Local Sources** (from the target market's own media), **Global Sources**
+(from international publications), and **Google Trends Data** (real-time search
+demand signals). Prioritize local insights when forming ideas, use global sources
+for supporting evidence, and use Google Trends data to validate demand and timing.
+
+${researchSummary}
+
+## Task
+
+Generate exactly ${options.limit} business ideas or opportunities based on the research data
+and target market above. Make sure each idea is distinct and covers a different angle
+or opportunity type.
+
+When citing references, prefer local source URLs where applicable. Each idea should
+ideally reference at least one local source if the research data provides relevant ones.
+Where Google Trends data shows rising demand for a topic, mention it in the reasoning.`;
+}
+async function generate(options, researchSummary) {
+  const model = createModel(options.provider, options.apiKey, options.model);
+  const { object } = await generateObject({
+    model,
+    schema: arendiResultSchema,
+    system: buildSystemPrompt(),
+    prompt: buildUserPrompt(options, researchSummary)
+  });
+  return object.ideas;
+}
+
+// ../../packages/arendi/dist/index.js
+import { randomUUID } from "crypto";
+
+// ../../packages/arendi/dist/cache.js
+function createCacheStats() {
+  return { hits: 0, misses: 0 };
+}
+
+// ../../packages/arendi/dist/index.js
+async function generateIdeas(rawOptions, callbacks) {
+  const runId = randomUUID();
+  const runStart = performance.now();
+  const { cache, store, ...serializableOptions } = rawOptions;
+  const options = {
+    ...optionsSchema.parse(serializableOptions),
+    cache,
+    store
+  };
+  const cacheStats = createCacheStats();
+  callbacks?.onSourceDiscoveryStart?.();
+  const sourceDiscoveryStart = performance.now();
+  const localDomains = await discoverLocalSources(options, cacheStats);
+  const sourceDiscoveryDuration = performance.now() - sourceDiscoveryStart;
+  callbacks?.onSourceDiscoveryComplete?.(localDomains);
+  callbacks?.onLocalResearchStart?.();
+  callbacks?.onGlobalResearchStart?.();
+  callbacks?.onTrendsResearchStart?.();
+  const parallelStart = performance.now();
+  const [localContexts, globalContexts, trendsContext] = await Promise.all([
+    localResearch(options, localDomains, cacheStats),
+    globalResearch(options, cacheStats),
+    trendsResearch(options)
+  ]);
+  const parallelDuration = performance.now() - parallelStart;
+  const localResultCount = localContexts.reduce((sum, c) => sum + c.results.length, 0);
+  callbacks?.onLocalResearchComplete?.(localContexts.length, localResultCount);
+  const globalResultCount = globalContexts.reduce((sum, c) => sum + c.results.length, 0);
+  callbacks?.onGlobalResearchComplete?.(globalContexts.length, globalResultCount);
+  callbacks?.onTrendsResearchComplete?.(trendsContext);
+  const researchSummary = summarizeAllResearch(localContexts, globalContexts, trendsContext);
+  callbacks?.onGenerateStart?.();
+  const generateStart = performance.now();
+  const ideas = await generate(options, researchSummary);
+  const generateDuration = performance.now() - generateStart;
+  callbacks?.onGenerateComplete?.(ideas.length);
+  const totalDurationMs = Math.round(performance.now() - runStart);
+  if (store) {
+    const runData = {
+      id: runId,
+      createdAt: /* @__PURE__ */ new Date(),
+      options: {
+        country: options.country,
+        city: options.city,
+        categories: options.categories,
+        keywords: options.keywords,
+        limit: options.limit,
+        provider: options.provider,
+        model: options.model,
+        geo: options.geo
+      },
+      sourceDiscovery: {
+        domains: localDomains,
+        durationMs: Math.round(sourceDiscoveryDuration)
+      },
+      localResearch: {
+        contexts: localContexts,
+        durationMs: Math.round(parallelDuration)
+      },
+      globalResearch: {
+        contexts: globalContexts,
+        durationMs: Math.round(parallelDuration)
+      },
+      trendsResearch: {
+        context: trendsContext,
+        durationMs: Math.round(parallelDuration)
+      },
+      generation: {
+        ideas,
+        durationMs: Math.round(generateDuration)
+      },
+      researchSummary,
+      totalDurationMs,
+      cacheStats: { ...cacheStats }
+    };
+    store.save(runData).catch((err) => {
+      console.warn("Warning: Failed to save run data:", err instanceof Error ? err.message : String(err));
+    });
+  }
+  return { ideas, runId };
+}
+
+// ../../packages/sqlite/dist/index.js
+import Database from "better-sqlite3";
+
+// ../../packages/sqlite/dist/schema.js
+function initSchema(db) {
+  db.exec(`
+    -- Tavily search result cache
+    CREATE TABLE IF NOT EXISTS cache (
+      key        TEXT PRIMARY KEY,
+      value      TEXT NOT NULL,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch('now') * 1000),
+      expires_at INTEGER
+    );
+
+    -- Run metadata
+    CREATE TABLE IF NOT EXISTS runs (
+      id                TEXT PRIMARY KEY,
+      created_at        INTEGER NOT NULL,
+      options           TEXT NOT NULL,
+      research_summary  TEXT,
+      total_duration_ms INTEGER,
+      cache_hits        INTEGER DEFAULT 0,
+      cache_misses      INTEGER DEFAULT 0
+    );
+
+    -- Discovered local source domains
+    CREATE TABLE IF NOT EXISTS run_sources (
+      id      INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id  TEXT NOT NULL REFERENCES runs(id),
+      domain  TEXT NOT NULL
+    );
+
+    -- Individual Tavily searches executed during a run
+    CREATE TABLE IF NOT EXISTS run_searches (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id          TEXT NOT NULL REFERENCES runs(id),
+      phase           TEXT NOT NULL,
+      query           TEXT NOT NULL,
+      include_domains TEXT,
+      duration_ms     INTEGER,
+      cache_hit       INTEGER DEFAULT 0
+    );
+
+    -- Results returned by each Tavily search
+    CREATE TABLE IF NOT EXISTS run_search_results (
+      id        INTEGER PRIMARY KEY AUTOINCREMENT,
+      search_id INTEGER NOT NULL REFERENCES run_searches(id),
+      title     TEXT NOT NULL,
+      url       TEXT NOT NULL,
+      content   TEXT NOT NULL,
+      score     REAL
+    );
+
+    -- Google Trends data snapshots
+    CREATE TABLE IF NOT EXISTS run_trends (
+      id     INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id TEXT NOT NULL REFERENCES runs(id),
+      type   TEXT NOT NULL,
+      data   TEXT NOT NULL
+    );
+
+    -- Generated business ideas
+    CREATE TABLE IF NOT EXISTS run_ideas (
+      id                   INTEGER PRIMARY KEY AUTOINCREMENT,
+      run_id               TEXT NOT NULL REFERENCES runs(id),
+      title                TEXT NOT NULL,
+      description          TEXT NOT NULL,
+      category             TEXT,
+      target_audience      TEXT,
+      pain_point           TEXT,
+      opportunity_type     TEXT,
+      estimated_difficulty TEXT,
+      potential_revenue    TEXT,
+      reasoning            TEXT,
+      actionable_steps     TEXT,
+      refs                 TEXT
+    );
+
+    -- Indexes for common queries
+    CREATE INDEX IF NOT EXISTS idx_cache_expires ON cache(expires_at);
+    CREATE INDEX IF NOT EXISTS idx_runs_created ON runs(created_at);
+    CREATE INDEX IF NOT EXISTS idx_run_sources_run ON run_sources(run_id);
+    CREATE INDEX IF NOT EXISTS idx_run_searches_run ON run_searches(run_id);
+    CREATE INDEX IF NOT EXISTS idx_run_search_results_search ON run_search_results(search_id);
+    CREATE INDEX IF NOT EXISTS idx_run_trends_run ON run_trends(run_id);
+    CREATE INDEX IF NOT EXISTS idx_run_ideas_run ON run_ideas(run_id);
+  `);
+}
+
+// ../../packages/sqlite/dist/cache.js
+var SqliteCacheProvider = class {
+  db;
+  stmtGet;
+  stmtSet;
+  stmtDelete;
+  constructor(db) {
+    this.db = db;
+    this.stmtGet = this.db.prepare("SELECT value, expires_at FROM cache WHERE key = ?");
+    this.stmtSet = this.db.prepare("INSERT OR REPLACE INTO cache (key, value, created_at, expires_at) VALUES (?, ?, ?, ?)");
+    this.stmtDelete = this.db.prepare("DELETE FROM cache WHERE key = ?");
+  }
+  async get(key) {
+    const row = this.stmtGet.get(key);
+    if (!row)
+      return null;
+    if (row.expires_at !== null && Date.now() > row.expires_at) {
+      this.stmtDelete.run(key);
+      return null;
+    }
+    return row.value;
+  }
+  async set(key, value, ttlMs) {
+    const now = Date.now();
+    const expiresAt = ttlMs != null ? now + ttlMs : null;
+    this.stmtSet.run(key, value, now, expiresAt);
+  }
+  /**
+   * Remove all expired entries. Call periodically if the database grows large.
+   */
+  prune() {
+    const result = this.db.prepare("DELETE FROM cache WHERE expires_at IS NOT NULL AND expires_at < ?").run(Date.now());
+    return result.changes;
+  }
+};
+
+// ../../packages/sqlite/dist/store.js
+var SqliteRunStore = class {
+  db;
+  constructor(db) {
+    this.db = db;
+  }
+  // -------------------------------------------------------------------------
+  // save – persists a full RunData in a single transaction
+  // -------------------------------------------------------------------------
+  async save(run) {
+    const tx = this.db.transaction(() => {
+      this.db.prepare(`INSERT INTO runs (id, created_at, options, research_summary, total_duration_ms, cache_hits, cache_misses)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`).run(run.id, run.createdAt.getTime(), JSON.stringify(run.options), run.researchSummary, run.totalDurationMs, run.cacheStats.hits, run.cacheStats.misses);
+      const insertSource = this.db.prepare("INSERT INTO run_sources (run_id, domain) VALUES (?, ?)");
+      for (const domain of run.sourceDiscovery.domains) {
+        insertSource.run(run.id, domain);
+      }
+      const insertSearch = this.db.prepare(`INSERT INTO run_searches (run_id, phase, query, include_domains, duration_ms)
+         VALUES (?, ?, ?, ?, ?)`);
+      const insertResult = this.db.prepare(`INSERT INTO run_search_results (search_id, title, url, content, score)
+         VALUES (?, ?, ?, ?, ?)`);
+      const writeContexts = (contexts, phase, durationMs) => {
+        for (const ctx of contexts) {
+          const info = insertSearch.run(run.id, phase, ctx.query, null, durationMs);
+          const searchId = info.lastInsertRowid;
+          for (const r of ctx.results) {
+            insertResult.run(searchId, r.title, r.url, r.content, r.score);
+          }
+        }
+      };
+      writeContexts(run.localResearch.contexts, "local", run.localResearch.durationMs);
+      writeContexts(run.globalResearch.contexts, "global", run.globalResearch.durationMs);
+      const insertTrend = this.db.prepare("INSERT INTO run_trends (run_id, type, data) VALUES (?, ?, ?)");
+      const trends = run.trendsResearch.context;
+      if (trends.dailyTrends.length > 0) {
+        insertTrend.run(run.id, "daily", JSON.stringify(trends.dailyTrends));
+      }
+      if (trends.relatedQueries.length > 0) {
+        insertTrend.run(run.id, "related_queries", JSON.stringify(trends.relatedQueries));
+      }
+      if (trends.relatedTopics.length > 0) {
+        insertTrend.run(run.id, "related_topics", JSON.stringify(trends.relatedTopics));
+      }
+      const insertIdea = this.db.prepare(`INSERT INTO run_ideas
+           (run_id, title, description, category, target_audience, pain_point,
+            opportunity_type, estimated_difficulty, potential_revenue, reasoning,
+            actionable_steps, refs)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+      for (const idea of run.generation.ideas) {
+        insertIdea.run(run.id, idea.title, idea.description, idea.category, idea.targetAudience, idea.painPoint, idea.opportunityType, idea.estimatedDifficulty, idea.potentialRevenue, idea.reasoning, JSON.stringify(idea.actionableSteps), JSON.stringify(idea.references));
+      }
+    });
+    tx();
+  }
+  // -------------------------------------------------------------------------
+  // get – reconstructs a full RunData from the database
+  // -------------------------------------------------------------------------
+  async get(id) {
+    const row = this.db.prepare("SELECT * FROM runs WHERE id = ?").get(id);
+    if (!row)
+      return null;
+    return this.hydrateRun(row);
+  }
+  // -------------------------------------------------------------------------
+  // list – returns runs in reverse-chronological order
+  // -------------------------------------------------------------------------
+  async list(options) {
+    const limit = options?.limit ?? 20;
+    const offset = options?.offset ?? 0;
+    const rows = this.db.prepare("SELECT * FROM runs ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
+    return rows.map((row) => this.hydrateRun(row));
+  }
+  // -------------------------------------------------------------------------
+  // Private helpers
+  // -------------------------------------------------------------------------
+  hydrateRun(row) {
+    const id = row.id;
+    const sources = this.db.prepare("SELECT domain FROM run_sources WHERE run_id = ?").all(id);
+    const searches = this.db.prepare("SELECT * FROM run_searches WHERE run_id = ? ORDER BY id").all(id);
+    const localContexts = [];
+    const globalContexts = [];
+    let localDurationMs = 0;
+    let globalDurationMs = 0;
+    for (const s of searches) {
+      const results = this.db.prepare("SELECT title, url, content, score FROM run_search_results WHERE search_id = ? ORDER BY id").all(s.id);
+      const ctx = { query: s.query, results };
+      if (s.phase === "local") {
+        localContexts.push(ctx);
+        localDurationMs = s.duration_ms ?? 0;
+      } else if (s.phase === "global") {
+        globalContexts.push(ctx);
+        globalDurationMs = s.duration_ms ?? 0;
+      }
+    }
+    const trendRows = this.db.prepare("SELECT type, data FROM run_trends WHERE run_id = ?").all(id);
+    const trendsContext = {
+      dailyTrends: [],
+      relatedQueries: [],
+      relatedTopics: []
+    };
+    for (const t of trendRows) {
+      if (t.type === "daily") {
+        trendsContext.dailyTrends = JSON.parse(t.data);
+      } else if (t.type === "related_queries") {
+        trendsContext.relatedQueries = JSON.parse(t.data);
+      } else if (t.type === "related_topics") {
+        trendsContext.relatedTopics = JSON.parse(t.data);
+      }
+    }
+    const ideaRows = this.db.prepare("SELECT * FROM run_ideas WHERE run_id = ? ORDER BY id").all(id);
+    const ideas = ideaRows.map((i) => ({
+      title: i.title,
+      description: i.description,
+      category: i.category ?? "",
+      targetAudience: i.target_audience ?? "",
+      painPoint: i.pain_point ?? "",
+      opportunityType: i.opportunity_type ?? "trending",
+      estimatedDifficulty: i.estimated_difficulty ?? "medium",
+      potentialRevenue: i.potential_revenue ?? "medium",
+      reasoning: i.reasoning ?? "",
+      actionableSteps: i.actionable_steps ? JSON.parse(i.actionable_steps) : [],
+      references: i.refs ? JSON.parse(i.refs) : []
+    }));
+    return {
+      id: row.id,
+      createdAt: new Date(row.created_at),
+      options: JSON.parse(row.options),
+      sourceDiscovery: {
+        domains: sources.map((s) => s.domain),
+        durationMs: 0
+        // Not stored per-phase for discovery — captured in total
+      },
+      localResearch: {
+        contexts: localContexts,
+        durationMs: localDurationMs
+      },
+      globalResearch: {
+        contexts: globalContexts,
+        durationMs: globalDurationMs
+      },
+      trendsResearch: {
+        context: trendsContext,
+        durationMs: 0
+      },
+      generation: {
+        ideas,
+        durationMs: 0
+      },
+      researchSummary: row.research_summary ?? "",
+      totalDurationMs: row.total_duration_ms ?? 0,
+      cacheStats: {
+        hits: row.cache_hits ?? 0,
+        misses: row.cache_misses ?? 0
+      }
+    };
+  }
+};
+
+// ../../packages/sqlite/dist/index.js
+function createSqliteProviders(dbPath) {
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.pragma("foreign_keys = ON");
+  initSchema(db);
+  const cache = new SqliteCacheProvider(db);
+  const store = new SqliteRunStore(db);
+  return {
+    cache,
+    store,
+    close: () => db.close()
+  };
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("arendi").description(
+  "AI-powered business idea generator. Researches trending topics, pain points, and market gaps, then generates actionable business ideas."
+).version("0.1.0").option("--country <country>", "Target country (e.g., US, Indonesia)").option("--city <city>", "Target city (e.g., Jakarta, New York)").option(
+  "--categories <categories>",
+  `Comma-separated categories: ${CATEGORIES.join(", ")}`
+).option("--limit <number>", "Number of ideas to generate", "10").option("--keywords <keywords>", "Comma-separated keywords to focus on").option(
+  "--format <format>",
+  `Output format: ${OUTPUT_FORMATS.join(", ")}`,
+  "markdown"
+).option("--output <file>", "Write output to file instead of stdout").option(
+  "--provider <provider>",
+  `AI provider: ${PROVIDERS.join(", ")}`,
+  "openai"
+).option(
+  "--model <model>",
+  "Model name override (e.g., gpt-4o, claude-sonnet-4-20250514)"
+).option(
+  "--geo <code>",
+  "ISO 3166-1 alpha-2 country code for Google Trends (e.g., US, ID). Auto-detected from --country if omitted."
+).option(
+  "--db <path>",
+  "Path to the SQLite database for caching and run history",
+  resolve(homedir(), ".arendi", "arendi.db")
+).option("--no-cache", "Disable Tavily search result caching").option("--no-store", "Disable run history persistence");
+function getApiKey(provider) {
+  const envMap = {
+    openai: "OPENAI_API_KEY",
+    anthropic: "ANTHROPIC_API_KEY",
+    google: "GOOGLE_GENERATIVE_AI_API_KEY"
+  };
+  const envVar = envMap[provider];
+  const key = process.env[envVar];
+  if (!key) {
+    console.error(
+      `Error: Missing environment variable ${envVar} for provider "${provider}".`
+    );
+    console.error(`Set it via: export ${envVar}=your-key-here`);
+    process.exit(1);
+  }
+  return key;
+}
+function getTavilyApiKey() {
+  const key = process.env["TAVILY_API_KEY"];
+  if (!key) {
+    console.error("Error: Missing environment variable TAVILY_API_KEY.");
+    console.error("Get a free key at https://tavily.com and set it via:");
+    console.error("  export TAVILY_API_KEY=your-key-here");
+    process.exit(1);
+  }
+  return key;
+}
+program.action(async (opts) => {
+  const provider = opts["provider"] ?? "openai";
+  const format = opts["format"] ?? "markdown";
+  const limit = parseInt(String(opts["limit"] ?? "5"), 10);
+  if (!PROVIDERS.includes(provider)) {
+    console.error(
+      `Error: Invalid provider "${provider}". Choose from: ${PROVIDERS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  if (!OUTPUT_FORMATS.includes(format)) {
+    console.error(
+      `Error: Invalid format "${format}". Choose from: ${OUTPUT_FORMATS.join(", ")}`
+    );
+    process.exit(1);
+  }
+  if (isNaN(limit) || limit < 1 || limit > 50) {
+    console.error("Error: --limit must be a number between 1 and 50.");
+    process.exit(1);
+  }
+  const apiKey = getApiKey(provider);
+  const tavilyApiKey = getTavilyApiKey();
+  const categories = opts["categories"]?.split(",").map((c) => c.trim()).filter(Boolean);
+  const keywords = opts["keywords"]?.split(",").map((k) => k.trim()).filter(Boolean);
+  const dbPath = opts["db"];
+  const useCache = opts["cache"] !== false;
+  const useStore = opts["store"] !== false;
+  let cache;
+  let store;
+  let closeDb;
+  if (useCache || useStore) {
+    try {
+      mkdirSync(dirname(dbPath), { recursive: true });
+      const providers = createSqliteProviders(dbPath);
+      if (useCache) cache = providers.cache;
+      if (useStore) store = providers.store;
+      closeDb = providers.close;
+      console.error(`Database: ${dbPath}`);
+    } catch (err) {
+      console.warn(
+        "Warning: Could not open SQLite database, proceeding without cache/store:",
+        err instanceof Error ? err.message : String(err)
+      );
+    }
+  }
+  try {
+    const hasLocation = opts["country"] || opts["city"];
+    const { ideas, runId } = await generateIdeas(
+      {
+        country: opts["country"],
+        city: opts["city"],
+        categories,
+        limit,
+        keywords,
+        provider,
+        model: opts["model"],
+        apiKey,
+        tavilyApiKey,
+        geo: opts["geo"],
+        cache,
+        store
+      },
+      {
+        onSourceDiscoveryStart() {
+          if (hasLocation) {
+            console.error("Discovering local sources for the target market...");
+          }
+        },
+        onSourceDiscoveryComplete(sources) {
+          if (sources.length > 0) {
+            console.error(
+              `Found ${sources.length} local sources: ${sources.join(", ")}`
+            );
+          } else if (hasLocation) {
+            console.error(
+              "No local sources discovered \u2014 will rely on global research."
+            );
+          }
+        },
+        onLocalResearchStart() {
+          if (hasLocation) {
+            console.error("Researching local trends and opportunities...");
+          }
+        },
+        onLocalResearchComplete(queryCount, resultCount) {
+          if (hasLocation) {
+            console.error(
+              `Local research complete: ${queryCount} queries, ${resultCount} results.`
+            );
+          }
+        },
+        onGlobalResearchStart() {
+          console.error(
+            "Researching global trends, pain points, and market gaps..."
+          );
+        },
+        onGlobalResearchComplete(queryCount, resultCount) {
+          console.error(
+            `Global research complete: ${queryCount} queries, ${resultCount} results.`
+          );
+        },
+        onTrendsResearchStart() {
+          console.error(
+            "Fetching Google Trends data (daily trends, rising queries)..."
+          );
+        },
+        onTrendsResearchComplete(trendsContext) {
+          const parts = [];
+          if (trendsContext.dailyTrends.length > 0) {
+            parts.push(
+              `${trendsContext.dailyTrends.length} daily trending searches`
+            );
+          }
+          if (trendsContext.relatedQueries.length > 0) {
+            const risingCount = trendsContext.relatedQueries.reduce(
+              (sum, r) => sum + r.rising.length,
+              0
+            );
+            parts.push(`${risingCount} rising queries`);
+          }
+          if (trendsContext.relatedTopics.length > 0) {
+            const risingCount = trendsContext.relatedTopics.reduce(
+              (sum, r) => sum + r.rising.length,
+              0
+            );
+            parts.push(`${risingCount} rising topics`);
+          }
+          if (parts.length > 0) {
+            console.error(`Google Trends complete: ${parts.join(", ")}.`);
+          } else {
+            console.error(
+              "Google Trends: no data available (geo may not be supported)."
+            );
+          }
+        },
+        onGenerateStart() {
+          console.error(`Generating ${limit} business ideas...`);
+        },
+        onGenerateComplete(ideaCount) {
+          console.error(`Generated ${ideaCount} ideas.`);
+        }
+      }
+    );
+    if (store) {
+      console.error(`Run saved: ${runId}`);
+    }
+    const output = formatIdeas(ideas, format);
+    if (opts["output"]) {
+      const filePath = resolve(opts["output"]);
+      writeFileSync(filePath, output, "utf-8");
+      console.error(`Output written to ${filePath}`);
+    } else {
+      console.log(output);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exit(1);
+  } finally {
+    closeDb?.();
+  }
+});
+
+// src/index.ts
+program.parse();