geo-data-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mohammed
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,225 @@
+# 🌍 geo-data
+
+Copy only the countries you need. No bloat.
+
+## The Problem
+
+```bash
+# Installing country data for your app?
+npm install country-city-multilanguage  # 6MB of world data 😱
+```
+
+You only need Saudi Arabia and UAE, but you're shipping data for 250 countries.
+
+## The Solution
+
+```bash
+npx geo-data add sa ae    # ~65KB instead of 6MB ✨
+```
+
+## Quick Start
+
+```bash
+# 1. Initialize in your project
+npx geo-data init
+
+# 2. Add countries you need
+npx geo-data add sa ae qa
+
+# 3. Use in your code
+```
+
+```tsx
+import { getCities, getLocalizedName } from './src/data/geo';
+
+const cities = getCities('SA');
+// → [{ name: { en: "Riyadh", ar: "الرياض" }, ... }]
+
+// With i18n
+const cityName = getLocalizedName(city, 'ar'); // → "الرياض"
+```
+
+## Features
+
+- 🎯 **Only what you need** — install 1 country, not 250
+- 🌐 **Multilingual** — English, Arabic, French, Spanish, and 13 more languages
+- 📦 **No runtime dependency** — data lives in your project
+- 🔧 **Fully customizable** — it's just JSON, edit as needed
+- ⚡ **TypeScript ready** — full type safety out of the box
+- 🔄 **Offline support** — works offline after first download
+- 🗑️ **Easy management** — add, update, or remove countries anytime
+
+## Commands
+
+```bash
+# Initialize configuration
+npx geo-data init
+
+# Add countries
+npx geo-data add sa qa ae
+npx geo-data add sa --force        # Overwrite existing
+npx geo-data add sa --dry-run      # Preview changes
+
+# List countries
+npx geo-data list                   # All available (218 countries)
+npx geo-data list --installed       # Only installed
+
+# Update installed countries
+npx geo-data update                 # Re-download with current config
+npx geo-data update --dry-run       # Preview what would update
+
+# Remove countries
+npx geo-data remove sa              # Remove with confirmation
+npx geo-data rm sa --force          # Remove without confirmation
+
+# Manage cache
+npx geo-data cache                  # Show cache info
+npx geo-data cache clear            # Clear offline cache
+```
+
+## Configuration
+
+After `init`, you'll have a `geo-data.json`:
+
+```json
+{
+  "$schema": "https://geo-data.dev/schema.json",
+  "outputDir": "./src/data/geo",
+  "languages": ["en", "ar"],
+  "includeCoordinates": true,
+  "typescript": true
+}
+```
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `outputDir` | Where to put the data files | `./src/data/geo` |
+| `languages` | Languages to include | `["en"]` |
+| `includeCoordinates` | Include lat/lng for cities | `true` |
+| `typescript` | Generate TypeScript types | `true` |
+
+### Available Languages
+
+`en`, `ar`, `de`, `es`, `fr`, `hi`, `it`, `ja`, `ko`, `nl`, `pl`, `pt`, `pt-BR`, `ru`, `tr`, `uk`, `zh`
+
+## Data Schema
+
+Each country file contains:
+
+```json
+{
+  "code": "SA",
+  "name": { "en": "Saudi Arabia", "ar": "المملكة العربية السعودية" },
+  "phone": "+966",
+  "currency": "SAR",
+  "timezone": "Asia/Riyadh",
+  "flag": "🇸🇦",
+  "regions": [
+    {
+      "code": "SA-01",
+      "name": { "en": "Riyadh Region", "ar": "منطقة الرياض" },
+      "cities": [
+        {
+          "name": { "en": "Riyadh", "ar": "الرياض" },
+          "latitude": 24.7136,
+          "longitude": 46.6753
+        }
+      ]
+    }
+  ]
+}
+```
+
+## Generated Helpers
+
+The CLI generates an `index.ts` with helpful functions:
+
+```typescript
+import {
+  countries,
+  getCountry,
+  getRegions,
+  getCities,
+  getAllCities,
+  getLocalizedName,
+  getCountryCodes,
+  isValidCountryCode
+} from './src/data/geo';
+
+// Get all cities in a country
+const cities = getCities('SA');
+
+// Get cities in a specific region
+const riyadhCities = getCities('SA', 'SA-01');
+
+// Get localized name
+const name = getLocalizedName(city, 'ar'); // "الرياض"
+
+// Type-safe country codes
+type CountryCode = 'SA' | 'AE' | 'QA'; // Based on what you installed
+
+// Validation
+if (isValidCountryCode(userInput)) {
+  const country = getCountry(userInput);
+}
+```
+
+## Framework Examples
+
+### React
+
+```tsx
+import { getCities, getLocalizedName } from '@/data/geo';
+import { useTranslation } from 'react-i18next';
+
+function CitySelect({ country }: { country: 'SA' | 'AE' }) {
+  const { i18n } = useTranslation();
+  const cities = getCities(country);
+
+  return (
+    <select>
+      {cities.map(city => (
+        <option key={city.name.en} value={city.name.en}>
+          {getLocalizedName(city, i18n.language)}
+        </option>
+      ))}
+    </select>
+  );
+}
+```
+
+### Vue
+
+```vue
+<script setup lang="ts">
+import { computed } from 'vue';
+import { getCities, getLocalizedName } from '@/data/geo';
+import { useI18n } from 'vue-i18n';
+
+const props = defineProps<{ country: 'SA' | 'AE' }>();
+const { locale } = useI18n();
+const cities = computed(() => getCities(props.country));
+</script>
+
+<template>
+  <select>
+    <option v-for="city in cities" :key="city.name.en" :value="city.name.en">
+      {{ getLocalizedName(city, locale) }}
+    </option>
+  </select>
+</template>
+```
+
+## Data Sources
+
+This package combines data from:
+- [dr5hn/countries-states-cities-database](https://github.com/dr5hn/countries-states-cities-database) — Base country/city data
+- [GeoNames](https://www.geonames.org/) — Arabic translations for cities worldwide
+
+## Contributing
+
+Found incorrect data? PRs welcome! Each country is a separate JSON file in `registry/countries/`.
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1021 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createRequire } from "module";
+import chalk3 from "chalk";
+import { Command } from "commander";
+
+// src/commands/add.ts
+import fs5 from "fs-extra";
+import path4 from "path";
+import { findBestMatch } from "string-similarity";
+
+// src/utils/codegen.ts
+import fs3 from "fs-extra";
+import path2 from "path";
+
+// src/utils/helpers.ts
+import fs2 from "fs-extra";
+
+// src/utils/ui.ts
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import figlet from "figlet";
+import gradient from "gradient-string";
+var brandGradient = gradient(["#a855f7", "#6366f1", "#06b6d4"]);
+function banner() {
+  console.log();
+  console.log(brandGradient(figlet.textSync("geodata", { font: "Big" })));
+  console.log();
+}
+function intro2(message) {
+  console.log();
+  p.intro(chalk.bgHex("#6366f1").white(` ${message || "geo-data"} `));
+}
+function outro2(message) {
+  p.outro(chalk.hex("#a855f7")(message));
+}
+function cancel2(message = "Operation cancelled.") {
+  p.cancel(message);
+}
+
+// src/utils/config.ts
+import * as p2 from "@clack/prompts";
+import fs from "fs-extra";
+import path from "path";
+
+// src/utils/schemas.ts
+import { z } from "zod";
+var CitySchema = z.object({
+  name: z.record(z.string(), z.string()),
+  latitude: z.number().optional(),
+  longitude: z.number().optional()
+});
+var RegionSchema = z.object({
+  code: z.string(),
+  name: z.record(z.string(), z.string()),
+  cities: z.array(CitySchema)
+});
+var CountryDataSchema = z.object({
+  code: z.string(),
+  iso3: z.string().optional(),
+  name: z.record(z.string(), z.string()),
+  phone: z.string(),
+  currency: z.string(),
+  timezone: z.string(),
+  flag: z.string(),
+  regions: z.array(RegionSchema)
+});
+var RegistryIndexSchema = z.object({
+  version: z.string(),
+  countries: z.record(
+    z.string(),
+    z.object({
+      name: z.object({ en: z.string(), ar: z.string().optional() }),
+      flag: z.string(),
+      languages: z.array(z.string())
+    })
+  )
+});
+var VALID_LANGUAGES = [
+  "en",
+  "ar",
+  "de",
+  "es",
+  "fr",
+  "hi",
+  "it",
+  "ja",
+  "ko",
+  "nl",
+  "pl",
+  "pt",
+  "pt-BR",
+  "ru",
+  "tr",
+  "uk",
+  "zh"
+];
+var ConfigSchema = z.object({
+  $schema: z.string().optional(),
+  outputDir: z.string().min(1, "outputDir must be a non-empty string"),
+  languages: z.array(z.string()).min(1, "languages must be a non-empty array"),
+  includeCoordinates: z.boolean(),
+  typescript: z.boolean()
+});
+
+// src/utils/config.ts
+var CONFIG_FILE = "geo-data.json";
+function validateConfig(config) {
+  const result = ConfigSchema.safeParse(config);
+  if (!result.success) {
+    throw new Error(result.error.issues[0]?.message ?? "Invalid config");
+  }
+  for (const lang of result.data.languages) {
+    if (!VALID_LANGUAGES.includes(lang)) {
+      p2.log.warn(`Unknown language code "${lang}"`);
+    }
+  }
+  return result.data;
+}
+async function getConfigResult() {
+  const configPath = path.resolve(process.cwd(), CONFIG_FILE);
+  if (!await fs.pathExists(configPath)) {
+    return { status: "not_found" };
+  }
+  try {
+    const raw = await fs.readJson(configPath);
+    const config = validateConfig(raw);
+    return { status: "ok", config };
+  } catch (error) {
+    return { status: "invalid", error: errorMessage(error) };
+  }
+}
+async function getConfig() {
+  const result = await getConfigResult();
+  if (result.status === "ok") return result.config;
+  if (result.status === "invalid") {
+    p2.log.error(`Error reading ${CONFIG_FILE}: ${result.error}`);
+  }
+  return null;
+}
+
+// src/utils/helpers.ts
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function requireConfig(commandName) {
+  const result = await getConfigResult();
+  if (result.status === "ok") return result.config;
+  intro2(commandName);
+  if (result.status === "not_found") {
+    p.log.error("No geo-data.json found. Run 'npx geo-data init' first.");
+  } else {
+    p.log.error(`Invalid geo-data.json: ${result.error}`);
+  }
+  console.log();
+  return null;
+}
+async function getInstalledCountries(outputDir) {
+  const files = await fs2.readdir(outputDir).catch(() => []);
+  return files.filter((f) => f.endsWith(".json") && f !== "index.json").map((f) => f.replace(".json", ""));
+}
+function formatCountryDisplay(code, info) {
+  if (info) {
+    return `${info.flag} ${code.toUpperCase()} - ${info.name.en}`;
+  }
+  return code.toUpperCase();
+}
+
+// src/utils/codegen.ts
+async function generateIndex(config) {
+  const codes = await getInstalledCountries(config.outputDir);
+  const validCodePattern = /^[a-z]{2}$/;
+  const safeCodes = codes.filter((code) => {
+    if (!validCodePattern.test(code)) {
+      console.warn(`Skipping invalid country code: ${code}`);
+      return false;
+    }
+    return true;
+  });
+  const ext = config.typescript ? "ts" : "js";
+  const indexPath = path2.join(config.outputDir, `index.${ext}`);
+  if (safeCodes.length === 0) {
+    const emptyContent = config.typescript ? `// Auto-generated by geo-data - no countries installed yet
+// Run: npx geo-data add <country>
+
+export const countries = {} as const;
+export type CountryCode = never;
+` : `// Auto-generated by geo-data - no countries installed yet
+// Run: npx geo-data add <country>
+
+export const countries = {};
+`;
+    await fs3.writeFile(indexPath, emptyContent);
+    return;
+  }
+  safeCodes.sort();
+  const imports = safeCodes.map((code) => `import ${code}Data from './${code}.json' with { type: "json" };`).join("\n");
+  const countriesObj = safeCodes.map((code) => `  ${code.toUpperCase()}: ${code}Data,`).join("\n");
+  const types = config.typescript ? `
+export type CountryCode = keyof typeof countries;
+export type Country = (typeof countries)[CountryCode];
+export type Region = Country['regions'][number];
+export type City = Region['cities'][number];
+export type LocalizedName = { name: { [key: string]: string | undefined; en: string } };
+` : "";
+  const content = `// Auto-generated by geo-data - do not edit manually
+// Regenerate with: npx geo-data update
+${imports}
+
+export const countries = {
+${countriesObj}
+} as const;
+${types}
+export function getCountry${config.typescript ? "(code: CountryCode)" : "(code)"} {
+  return countries[code];
+}
+
+export function getRegions${config.typescript ? "(code: CountryCode)" : "(code)"} {
+  return countries[code].regions;
+}
+
+export function getCities${config.typescript ? "(code: CountryCode, regionCode?: string)" : "(code, regionCode)"} {
+  const regions = getRegions(code);
+  if (regionCode) {
+    const region = regions.find(r => r.code === regionCode);
+    return region?.cities ?? [];
+  }
+  return regions.flatMap(r => r.cities);
+}
+
+export function getAllCities${config.typescript ? "(code: CountryCode)" : "(code)"} {
+  return getRegions(code).flatMap(r => r.cities);
+}
+
+export function getLocalizedName${config.typescript ? '(item: { name: Record<string, string | undefined> & { en: string } }, lang: string = "en"): string' : '(item, lang = "en")'} {
+  return item.name[lang] ?? item.name.en;
+}
+
+export function getCountryCodes()${config.typescript ? ": CountryCode[]" : ""} {
+  return Object.keys(countries)${config.typescript ? " as CountryCode[]" : ""};
+}
+
+export function isValidCountryCode${config.typescript ? "(code: string): code is CountryCode" : "(code)"} {
+  return code in countries;
+}
+`;
+  await fs3.writeFile(indexPath, content.trim() + "\n");
+}
+
+// src/utils/registry.ts
+import * as p3 from "@clack/prompts";
+import fs4 from "fs-extra";
+import os from "os";
+import path3 from "path";
+var REGISTRY_BASE = process.env.GEO_DATA_REGISTRY || "https://cdn.jsdelivr.net/gh/H4ck3r-x0/geo-data@main/registry";
+var CACHE_DIR = path3.join(os.homedir(), ".cache", "geo-data");
+function isRemoteRegistry(url) {
+  return url.startsWith("http://") || url.startsWith("https://");
+}
+async function readCache(cacheKey, maxAgeMs) {
+  const cachePath = path3.join(CACHE_DIR, `${cacheKey}.json`);
+  if (await fs4.pathExists(cachePath)) {
+    const stat = await fs4.stat(cachePath);
+    if (Date.now() - stat.mtimeMs < maxAgeMs) {
+      return fs4.readJson(cachePath);
+    }
+  }
+  return null;
+}
+async function writeCache(cacheKey, data) {
+  await fs4.ensureDir(CACHE_DIR);
+  await fs4.writeJson(path3.join(CACHE_DIR, `${cacheKey}.json`), data);
+}
+async function readStaleCache(cacheKey) {
+  const cachePath = path3.join(CACHE_DIR, `${cacheKey}.json`);
+  if (await fs4.pathExists(cachePath)) {
+    return fs4.readJson(cachePath);
+  }
+  return null;
+}
+async function fetchJson(urlOrPath) {
+  if (path3.isAbsolute(urlOrPath) || urlOrPath.startsWith(".")) {
+    return fs4.readJson(urlOrPath);
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), 3e4);
+  try {
+    const response = await fetch(urlOrPath, { signal: controller.signal });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${urlOrPath}: ${response.status}`);
+    }
+    return response.json();
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchRegistry() {
+  const url = isRemoteRegistry(REGISTRY_BASE) ? `${REGISTRY_BASE}/index.json` : path3.join(REGISTRY_BASE, "index.json");
+  let data;
+  if (isRemoteRegistry(REGISTRY_BASE)) {
+    const cached = await readCache("registry-index", 60 * 60 * 1e3);
+    if (cached) {
+      data = cached;
+    } else {
+      try {
+        data = await fetchJson(url);
+      } catch (error) {
+        const stale = await readStaleCache("registry-index");
+        if (stale) {
+          p3.log.warn("Network unavailable, using cached data");
+          data = stale;
+        } else {
+          throw error;
+        }
+      }
+    }
+  } else {
+    data = await fetchJson(url);
+  }
+  const result = RegistryIndexSchema.safeParse(data);
+  if (!result.success) {
+    p3.log.warn(`Registry index failed validation: ${result.error.issues[0]?.message}`);
+    return null;
+  }
+  if (isRemoteRegistry(REGISTRY_BASE)) {
+    await writeCache("registry-index", result.data);
+  }
+  return result.data;
+}
+async function fetchCountry(code, config) {
+  const url = isRemoteRegistry(REGISTRY_BASE) ? `${REGISTRY_BASE}/countries/${code}.json` : path3.join(REGISTRY_BASE, "countries", `${code}.json`);
+  let raw;
+  if (isRemoteRegistry(REGISTRY_BASE)) {
+    const cached = await readCache(`country-${code}`, 24 * 60 * 60 * 1e3);
+    if (cached) {
+      raw = cached;
+    } else {
+      try {
+        raw = await fetchJson(url);
+      } catch (error) {
+        const stale = await readStaleCache(`country-${code}`);
+        if (stale) {
+          p3.log.warn("Network unavailable, using cached data");
+          raw = stale;
+        } else {
+          throw error;
+        }
+      }
+    }
+  } else {
+    raw = await fetchJson(url);
+  }
+  const result = CountryDataSchema.safeParse(raw);
+  if (!result.success) {
+    p3.log.warn(`Country data for "${code}" failed validation: ${result.error.issues[0]?.message}`);
+    return null;
+  }
+  if (isRemoteRegistry(REGISTRY_BASE)) {
+    await writeCache(`country-${code}`, result.data);
+  }
+  return filterCountryData(result.data, config);
+}
+function filterCountryData(data, config) {
+  const filterName = (name) => {
+    const filtered = {};
+    for (const lang of config.languages) {
+      if (name[lang]) {
+        filtered[lang] = name[lang];
+      }
+    }
+    if (!filtered.en && name.en) {
+      filtered.en = name.en;
+    }
+    return filtered;
+  };
+  return {
+    ...data,
+    name: filterName(data.name),
+    regions: data.regions.map((region) => ({
+      ...region,
+      name: filterName(region.name),
+      cities: region.cities.map((city) => {
+        const filteredCity = {
+          name: filterName(city.name)
+        };
+        if (config.includeCoordinates && city.latitude !== void 0 && city.longitude !== void 0) {
+          filteredCity.latitude = city.latitude;
+          filteredCity.longitude = city.longitude;
+        }
+        return filteredCity;
+      })
+    }))
+  };
+}
+async function clearCache() {
+  await fs4.remove(CACHE_DIR);
+}
+async function getCacheInfo() {
+  if (!await fs4.pathExists(CACHE_DIR)) {
+    return null;
+  }
+  const files = await fs4.readdir(CACHE_DIR);
+  let size = 0;
+  for (const file of files) {
+    const stat = await fs4.stat(path3.join(CACHE_DIR, file));
+    size += stat.size;
+  }
+  return { size, files: files.length };
+}
+
+// src/commands/add.ts
+async function add(countryCodes, options = {}) {
+  const config = await requireConfig("Add Countries");
+  if (!config) {
+    process.exitCode = 1;
+    return;
+  }
+  intro2("Add Countries");
+  const codes = countryCodes.map((c) => c.toLowerCase());
+  const s = p.spinner();
+  s.start("Fetching registry");
+  try {
+    const registry = await fetchRegistry();
+    if (!registry) {
+      s.stop("Failed");
+      p.log.error("Could not load registry \u2014 invalid data from remote");
+      console.log();
+      process.exitCode = 1;
+      return;
+    }
+    const invalid = codes.filter((c) => !registry.countries[c]);
+    if (invalid.length > 0) {
+      s.stop("Registry loaded");
+      const allCodes = Object.keys(registry.countries);
+      for (const code of invalid) {
+        p.log.error(`Unknown country code: ${code.toUpperCase()}`);
+        const match = findBestMatch(code.toLowerCase(), allCodes);
+        if (match.bestMatch.rating > 0.3) {
+          const suggested = match.bestMatch.target;
+          const info = registry.countries[suggested];
+          p.log.info(`Did you mean ${info.flag} ${suggested.toUpperCase()} (${info.name.en})?`);
+        }
+      }
+      p.log.message("Run: npx geo-data list");
+      console.log();
+      process.exitCode = 1;
+      return;
+    }
+    const existing = [];
+    for (const code of codes) {
+      const outputPath = path4.join(config.outputDir, `${code}.json`);
+      if (await fs5.pathExists(outputPath)) {
+        existing.push(code);
+      }
+    }
+    s.stop("Registry loaded");
+    if (existing.length > 0 && !options.force && !options.dryRun) {
+      const existingList = existing.map((code) => formatCountryDisplay(code, registry.countries[code])).join("\n");
+      p.note(existingList, "Already installed");
+      const overwrite = await p.confirm({
+        message: "Overwrite existing countries?",
+        initialValue: false
+      });
+      if (p.isCancel(overwrite) || !overwrite) {
+        const newCodes = codes.filter((c) => !existing.includes(c));
+        if (newCodes.length === 0) {
+          cancel2("Nothing to add");
+          return;
+        }
+        codes.length = 0;
+        codes.push(...newCodes);
+      }
+    }
+    if (options.dryRun) {
+      const list2 = codes.map((code) => formatCountryDisplay(code, registry.countries[code])).join("\n");
+      p.note(list2, "Would add (dry run)");
+      p.log.info(`Target: ${config.outputDir}/`);
+      console.log();
+      return;
+    }
+    const added = [];
+    const failed = [];
+    for (const code of codes) {
+      const info = registry.countries[code];
+      s.start(`${info.flag} ${info.name.en}`);
+      try {
+        const countryData = await fetchCountry(code, config);
+        if (!countryData) {
+          s.stop(`${info.flag} ${info.name.en} - failed: invalid data`);
+          failed.push(code);
+          continue;
+        }
+        const outputPath = path4.join(config.outputDir, `${code}.json`);
+        await fs5.ensureDir(config.outputDir);
+        await fs5.writeJson(outputPath, countryData, { spaces: 2 });
+        const size = (JSON.stringify(countryData).length / 1024).toFixed(1);
+        s.stop(`${info.flag} ${info.name.en} (${size} KB)`);
+        added.push(code);
+      } catch (error) {
+        s.stop(`${info.flag} ${info.name.en} - failed: ${errorMessage(error)}`);
+        failed.push(code);
+      }
+    }
+    if (added.length > 0) {
+      const ext = config.typescript ? "ts" : "js";
+      s.start(`Generating index.${ext}`);
+      await generateIndex(config);
+      s.stop(`Generated index.${ext}`);
+    }
+    if (failed.length > 0) {
+      process.exitCode = 1;
+      p.log.warn(`Failed: ${failed.map((c) => c.toUpperCase()).join(", ")}`);
+    }
+    if (added.length > 0) {
+      p.note(`import { getCities } from '${config.outputDir}';`, "Usage");
+      outro2(`Added ${added.length} ${added.length === 1 ? "country" : "countries"}`);
+    }
+  } catch (error) {
+    s.stop("Failed");
+    process.exitCode = 1;
+    p.log.error(errorMessage(error));
+    console.log();
+  }
+}
+
+// src/commands/cache.ts
+async function cache(action = "info") {
+  if (action !== "info" && action !== "clear") {
+    intro2("Cache");
+    p.log.error(`Unknown action: "${action}". Use "info" or "clear".`);
+    console.log();
+    process.exitCode = 1;
+    return;
+  }
+  intro2("Cache");
+  if (action === "clear") {
+    const s = p.spinner();
+    s.start("Clearing cache");
+    try {
+      await clearCache();
+      s.stop("Cache cleared");
+      outro2("Done");
+    } catch (error) {
+      s.stop("Failed to clear cache");
+      process.exitCode = 1;
+      p.log.error(errorMessage(error));
+      console.log();
+    }
+    return;
+  }
+  const info = await getCacheInfo();
+  if (!info) {
+    p.log.info("No cached data");
+    console.log();
+    return;
+  }
+  const sizeKB = (info.size / 1024).toFixed(1);
+  const sizeMB = (info.size / 1024 / 1024).toFixed(2);
+  const sizeDisplay = info.size > 1024 * 1024 ? `${sizeMB} MB` : `${sizeKB} KB`;
+  p.note(`Files: ${info.files}
+Size: ${sizeDisplay}
+Location: ~/.cache/geo-data/`, "Cache info");
+  p.log.message("Run: npx geo-data cache clear");
+  console.log();
+}
+
+// src/commands/init.ts
+import fs6 from "fs-extra";
+import path5 from "path";
+async function detectDefaults() {
+  const cwd = process.cwd();
+  const hasTsconfig = await fs6.pathExists(path5.resolve(cwd, "tsconfig.json"));
+  const hasSrc = await fs6.pathExists(path5.resolve(cwd, "src"));
+  return {
+    outputDir: hasSrc ? "./src/data/geo" : "./data/geo",
+    typescript: hasTsconfig,
+    languages: ["en"],
+    includeCoordinates: false,
+    hints: {
+      outputDir: hasSrc ? "(src/ detected)" : "",
+      typescript: hasTsconfig ? "(tsconfig.json found)" : ""
+    }
+  };
+}
+async function init() {
+  banner();
+  intro2("Initialize");
+  const existingConfig = await getConfig();
+  if (existingConfig) {
+    const overwrite = await p.confirm({
+      message: `${CONFIG_FILE} already exists. Overwrite?`,
+      initialValue: false
+    });
+    if (p.isCancel(overwrite) || !overwrite) {
+      cancel2();
+      return;
+    }
+  }
+  const defaults = await detectDefaults();
+  p.note(
+    [
+      `Output:      ${defaults.outputDir}  ${defaults.hints.outputDir}`,
+      `TypeScript:  ${defaults.typescript ? "yes" : "no"}  ${defaults.hints.typescript}`,
+      `Languages:   ${defaults.languages.join(", ")}`,
+      `Coordinates: no`
+    ].join("\n"),
+    "Detected settings"
+  );
+  const confirm = await p.confirm({
+    message: "Look good?",
+    initialValue: true
+  });
+  if (p.isCancel(confirm)) {
+    cancel2();
+    return;
+  }
+  let { outputDir, languages, includeCoordinates, typescript } = defaults;
+  if (!confirm) {
+    const customOutputDir = await p.text({
+      message: "Where should geo data be stored?",
+      placeholder: defaults.outputDir,
+      defaultValue: defaults.outputDir
+    });
+    if (p.isCancel(customOutputDir)) {
+      cancel2();
+      return;
+    }
+    outputDir = customOutputDir;
+    const customLanguages = await p.multiselect({
+      message: "Which languages do you need?",
+      options: [
+        { value: "en", label: "English", hint: "recommended" },
+        { value: "ar", label: "Arabic (\u0627\u0644\u0639\u0631\u0628\u064A\u0629)" },
+        { value: "fr", label: "French (Fran\xE7ais)" },
+        { value: "es", label: "Spanish (Espa\xF1ol)" },
+        { value: "de", label: "German (Deutsch)" },
+        { value: "zh", label: "Chinese (\u4E2D\u6587)" },
+        { value: "ja", label: "Japanese (\u65E5\u672C\u8A9E)" },
+        { value: "pt", label: "Portuguese (Portugu\xEAs)" },
+        { value: "ru", label: "Russian (\u0420\u0443\u0441\u0441\u043A\u0438\u0439)" },
+        { value: "hi", label: "Hindi (\u0939\u093F\u0928\u094D\u0926\u0940)" },
+        { value: "it", label: "Italian (Italiano)" },
+        { value: "ko", label: "Korean (\uD55C\uAD6D\uC5B4)" },
+        { value: "nl", label: "Dutch (Nederlands)" },
+        { value: "pl", label: "Polish (Polski)" },
+        { value: "pt-BR", label: "Brazilian Portuguese (Portugu\xEAs do Brasil)" },
+        { value: "tr", label: "Turkish (T\xFCrk\xE7e)" },
+        { value: "uk", label: "Ukrainian (\u0423\u043A\u0440\u0430\u0457\u043D\u0441\u044C\u043A\u0430)" }
+      ],
+      initialValues: ["en"],
+      required: true
+    });
+    if (p.isCancel(customLanguages)) {
+      cancel2();
+      return;
+    }
+    languages = customLanguages;
+    const customCoordinates = await p.confirm({
+      message: "Include coordinates (latitude/longitude)?",
+      initialValue: false
+    });
+    if (p.isCancel(customCoordinates)) {
+      cancel2();
+      return;
+    }
+    includeCoordinates = customCoordinates;
+    const customTypescript = await p.confirm({
+      message: "Generate TypeScript types?",
+      initialValue: defaults.typescript
+    });
+    if (p.isCancel(customTypescript)) {
+      cancel2();
+      return;
+    }
+    typescript = customTypescript;
+  }
+  const config = {
+    $schema: "https://raw.githubusercontent.com/H4ck3r-x0/geo-data/main/schema.json",
+    outputDir,
+    languages,
+    includeCoordinates,
+    typescript
+  };
+  const s = p.spinner();
+  s.start("Creating configuration");
+  try {
+    await fs6.writeJson(CONFIG_FILE, config, { spaces: 2 });
+    await fs6.ensureDir(outputDir);
+  } catch (error) {
+    s.stop("Failed");
+    p.log.error(errorMessage(error));
+    console.log();
+    process.exitCode = 1;
+    return;
+  }
+  s.stop("Configuration created");
+  const firstCountry = await p.text({
+    message: "Add your first country? (code or name, Enter to skip)",
+    placeholder: "e.g. sa, us, fr",
+    defaultValue: ""
+  });
+  if (!p.isCancel(firstCountry) && firstCountry.trim()) {
+    console.log();
+    await add([firstCountry.trim()], {});
+    return;
+  }
+  p.note("npx geo-data add sa ae    Add countries\nnpx geo-data pick         Interactive picker", "Next steps");
+  outro2("Ready to go!");
+}
+
+// src/commands/list.ts
+import chalk2 from "chalk";
+async function list(options = {}) {
+  const config = await getConfig();
+  intro2(options.installed ? "Installed Countries" : "Available Countries");
+  const s = p.spinner();
+  s.start("Fetching countries");
+  try {
+    const registry = await fetchRegistry();
+    if (!registry) {
+      s.stop("Failed");
+      p.log.error("Could not load registry \u2014 invalid data from remote");
+      console.log();
+      process.exitCode = 1;
+      return;
+    }
+    let installedSet = /* @__PURE__ */ new Set();
+    if (config) {
+      const installed = await getInstalledCountries(config.outputDir);
+      installedSet = new Set(installed);
+    }
+    s.stop("Countries loaded");
+    let countries = Object.entries(registry.countries).sort((a, b) => a[1].name.en.localeCompare(b[1].name.en));
+    if (options.installed) {
+      if (installedSet.size === 0) {
+        p.log.warn("No countries installed yet");
+        p.log.message("Run: npx geo-data add sa ae qa");
+        console.log();
+        return;
+      }
+      countries = countries.filter(([code]) => installedSet.has(code));
+    }
+    console.log();
+    let currentLetter = "";
+    for (const [code, info] of countries) {
+      const firstLetter = info.name.en[0].toUpperCase();
+      if (firstLetter !== currentLetter && !options.installed) {
+        if (currentLetter !== "") console.log();
+        currentLetter = firstLetter;
+      }
+      const installed = installedSet.has(code);
+      const marker = installed ? chalk2.green("\u25CF") : chalk2.dim("\u25CB");
+      const codeStyled = installed ? chalk2.green.bold(code.toUpperCase()) : chalk2.white(code.toUpperCase());
+      console.log(`  ${marker} ${info.flag} ${codeStyled.padEnd(installed ? 14 : 6)} ${chalk2.dim(info.name.en)}`);
+    }
+    console.log();
+    if (options.installed) {
+      outro2(`${installedSet.size} countries installed`);
+    } else {
+      if (installedSet.size > 0) {
+        p.log.info(`${installedSet.size} installed ${chalk2.green("\u25CF")}`);
+      }
+      outro2(`${countries.length} countries available`);
+    }
+  } catch (error) {
+    s.stop("Failed to fetch countries");
+    process.exitCode = 1;
+    p.log.error(errorMessage(error));
+    console.log();
+  }
+}
+
+// src/commands/pick.ts
+import prompts from "prompts";
+async function pick() {
+  banner();
+  const config = await requireConfig("Pick Countries");
+  if (!config) {
+    process.exitCode = 1;
+    return;
+  }
+  intro2("Pick Countries");
+  const s = p.spinner();
+  s.start("Loading countries");
+  try {
+    const registry = await fetchRegistry();
+    if (!registry) {
+      s.stop("Failed");
+      p.log.error("Could not load registry \u2014 invalid data from remote");
+      console.log();
+      process.exitCode = 1;
+      return;
+    }
+    const installed = await getInstalledCountries(config.outputDir);
+    const installedSet = new Set(installed);
+    s.stop("Countries loaded");
+    const countries = Object.entries(registry.countries).map(([code, info]) => ({
+      code,
+      ...info,
+      installed: installedSet.has(code)
+    })).sort((a, b) => a.name.en.localeCompare(b.name.en));
+    p.log.message("Type to search, Space to select, Enter to confirm");
+    console.log();
+    const { selected } = await prompts({
+      type: "autocompleteMultiselect",
+      name: "selected",
+      message: "Select countries",
+      choices: countries.map((c) => ({
+        title: `${c.flag} ${c.code.toUpperCase()} - ${c.name.en}`,
+        value: c.code,
+        selected: c.installed,
+        disabled: c.installed ? "(installed)" : false
+      })),
+      instructions: false
+    });
+    if (!selected || selected.length === 0) {
+      console.log();
+      cancel2("No countries selected");
+      return;
+    }
+    const toAdd = selected.filter((code) => !installedSet.has(code));
+    if (toAdd.length === 0) {
+      console.log();
+      cancel2("All selected countries are already installed");
+      return;
+    }
+    console.log();
+    await add(toAdd, {});
+  } catch (error) {
+    s.stop("Failed");
+    process.exitCode = 1;
+    p.log.error(errorMessage(error));
+    console.log();
+  }
+}
+
+// src/commands/remove.ts
+import fs7 from "fs-extra";
+import path6 from "path";
+async function remove(countryCodes, options = {}) {
+  const config = await requireConfig("Remove Countries");
+  if (!config) {
+    process.exitCode = 1;
+    return;
+  }
+  intro2("Remove Countries");
+  const codes = countryCodes.map((c) => c.toLowerCase());
+  try {
+    const toRemove = [];
+    const notFound = [];
+    for (const code of codes) {
+      const filePath = path6.join(config.outputDir, `${code}.json`);
+      if (await fs7.pathExists(filePath)) {
+        toRemove.push(code);
+      } else {
+        notFound.push(code);
+      }
+    }
+    if (notFound.length > 0) {
+      for (const code of notFound) {
+        p.log.warn(`Not installed: ${code.toUpperCase()}`);
+      }
+    }
+    if (toRemove.length === 0) {
+      process.exitCode = 1;
+      cancel2("Nothing to remove");
+      return;
+    }
+    const registry = await fetchRegistry();
+    if (!registry) {
+      p.log.error("Could not load registry \u2014 invalid data from remote");
+      console.log();
+      process.exitCode = 1;
+      return;
+    }
+    const list2 = toRemove.map((code) => formatCountryDisplay(code, registry.countries[code])).join("\n");
+    if (options.dryRun) {
+      p.note(list2, "Would remove (dry run)");
+      console.log();
+      return;
+    }
+    p.note(list2, "Will remove");
+    if (!options.force) {
+      const confirm = await p.confirm({
+        message: `Remove ${toRemove.length} ${toRemove.length === 1 ? "country" : "countries"}?`,
+        initialValue: false
+      });
+      if (p.isCancel(confirm) || !confirm) {
+        cancel2();
+        return;
+      }
+    }
+    const s = p.spinner();
+    for (const code of toRemove) {
+      const info = registry.countries[code];
+      const label = `${info?.flag || "\u{1F3F3}\uFE0F"} ${info?.name.en || code}`;
+      s.start(label);
+      const filePath = path6.join(config.outputDir, `${code}.json`);
+      await fs7.remove(filePath);
+      s.stop(label);
+    }
+    const ext = config.typescript ? "ts" : "js";
+    s.start(`Regenerating index.${ext}`);
+    await generateIndex(config);
+    s.stop(`Regenerated index.${ext}`);
+    outro2(`Removed ${toRemove.length} ${toRemove.length === 1 ? "country" : "countries"}`);
+  } catch (error) {
+    process.exitCode = 1;
+    p.log.error(errorMessage(error));
+    console.log();
+  }
+}
+
+// src/commands/update.ts
+import fs8 from "fs-extra";
+import path7 from "path";
+async function update(options = {}) {
+  const config = await requireConfig("Update Countries");
+  if (!config) {
+    process.exitCode = 1;
+    return;
+  }
+  intro2("Update Countries");
+  const s = p.spinner();
+  s.start("Checking installed countries");
+  try {
+    const installed = await getInstalledCountries(config.outputDir);
+    if (installed.length === 0) {
+      s.stop("No countries found");
+      p.log.warn("No countries installed");
+      p.log.message("Run: npx geo-data add sa ae");
+      console.log();
+      process.exitCode = 1;
+      return;
+    }
+    const registry = await fetchRegistry();
+    if (!registry) {
+      s.stop("Failed");
+      p.log.error("Could not load registry \u2014 invalid data from remote");
+      console.log();
+      process.exitCode = 1;
+      return;
+    }
+    s.stop(`Found ${installed.length} countries`);
+    if (options.dryRun) {
+      const list2 = installed.sort().map((code) => formatCountryDisplay(code, registry.countries[code])).join("\n");
+      p.note(list2, "Would update (dry run)");
+      console.log();
+      return;
+    }
+    let updated = 0;
+    for (const code of installed.sort()) {
+      const info = registry.countries[code];
+      if (!info) continue;
+      s.start(`${info.flag} ${info.name.en}`);
+      try {
+        const countryData = await fetchCountry(code, config);
+        if (!countryData) {
+          s.stop(`${info.flag} ${info.name.en} - failed: invalid data`);
+          continue;
+        }
+        const outputPath = path7.join(config.outputDir, `${code}.json`);
+        await fs8.writeJson(outputPath, countryData, { spaces: 2 });
+        const size = (JSON.stringify(countryData).length / 1024).toFixed(1);
+        s.stop(`${info.flag} ${info.name.en} (${size} KB)`);
+        updated++;
+      } catch (error) {
+        s.stop(`${info.flag} ${info.name.en} - failed: ${errorMessage(error)}`);
+      }
+    }
+    const ext = config.typescript ? "ts" : "js";
+    s.start(`Regenerating index.${ext}`);
+    await generateIndex(config);
+    s.stop(`Regenerated index.${ext}`);
+    outro2(`Updated ${updated} ${updated === 1 ? "country" : "countries"}`);
+  } catch (error) {
+    s.stop("Failed");
+    process.exitCode = 1;
+    p.log.error(errorMessage(error));
+    console.log();
+  }
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var program = new Command();
+program.configureOutput({
+  outputError: (str, write) => write(chalk3.red(str))
+});
+program.name("geo-data").description("Copy only the countries you need. No bloat.").version(version);
+program.command("init").description("Initialize geo-data in your project").action(init);
+program.command("add").description("Add countries to your project").argument("[countries...]", "Country codes (e.g., sa ae fr)").option("-f, --force", "Overwrite existing without asking").option("-n, --dry-run", "Preview changes without writing").action((countries, options) => {
+  if (!countries || countries.length === 0) {
+    pick();
+  } else {
+    add(countries, options);
+  }
+});
+program.command("list").alias("ls").description("List available countries").option("-i, --installed", "Show only installed countries").action((options) => list(options));
+program.command("update").description("Re-download installed countries").option("-f, --force", "Update without confirmation").option("-n, --dry-run", "Preview what would be updated").action((options) => update(options));
+program.command("remove").alias("rm").description("Remove countries from your project").argument("<countries...>", "Country codes to remove").option("-f, --force", "Remove without confirmation").option("-n, --dry-run", "Preview what would be removed").action((countries, options) => remove(countries, options));
+program.command("cache").description("Manage offline cache").argument("[action]", "info (default) or clear", "info").action((action) => cache(action));
+program.command("pick").alias("select").description("Interactive country picker").action(() => pick());
+program.showHelpAfterError(chalk3.dim("(use --help for available commands)"));
+program.showSuggestionAfterError(true);
+program.addHelpText(
+  "after",
+  `
+${chalk3.bold("Examples:")}
+  ${chalk3.dim("$")} geo-data init
+  ${chalk3.dim("$")} geo-data pick
+  ${chalk3.dim("$")} geo-data add sa ae
+  ${chalk3.dim("$")} geo-data list -i
+`
+);
+program.parseAsync().catch((error) => {
+  console.error(chalk3.red(error instanceof Error ? error.message : "An unexpected error occurred"));
+  process.exitCode = 1;
+});

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "geo-data-cli",
+  "version": "0.1.0",
+  "description": "Copy only the countries you need. No bloat.",
+  "type": "module",
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "bin": {
+    "geo-data": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm",
+    "dev": "tsup src/index.ts --format esm --watch",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build",
+    "lint": "biome lint .",
+    "format": "biome format --write .",
+    "check": "biome check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "keywords": [
+    "geo",
+    "countries",
+    "cities",
+    "i18n",
+    "multilingual",
+    "cli",
+    "geography",
+    "typescript",
+    "codegen",
+    "states",
+    "regions",
+    "localization",
+    "l10n"
+  ],
+  "author": "Mohammed Fahad",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/H4ck3r-x0/geo-data.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/H4ck3r-x0/geo-data#readme",
+  "bugs": {
+    "url": "https://github.com/H4ck3r-x0/geo-data/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.8.2",
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "figlet": "^1.8.0",
+    "fs-extra": "^11.2.0",
+    "gradient-string": "^3.0.0",
+    "prompts": "^2.4.2",
+    "string-similarity": "^4.0.4",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.7.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/gradient-string": "^1.1.6",
+    "@types/node": "^20.11.0",
+    "@types/prompts": "^2.4.9",
+    "@types/string-similarity": "^4.0.2",
+    "tsup": "^8.0.1",
+    "typescript": "^5.3.3",
+    "vitest": "^4.0.18"
+  }
+}