gis.ph-cli 1.0.0

package/.env.example

@@ -0,0 +1,6 @@
+# API Configuration
+API_URL=https://api.gis.ph
+API_KEY=your-api-key-here
+
+# Optional: Set log level
+# LOG_LEVEL=debug

package/README.md

@@ -0,0 +1,279 @@
+# My API CLI
+
+A command-line interface for interacting with your API.
+
+## Features
+
+- 🚀 Simple and intuitive commands
+- 🔐 Secure credential management
+- 📊 Multiple output formats (table, JSON)
+- ⚡ Fast and efficient API interactions
+- 🎨 Colorful and user-friendly output
+- 💾 Persistent configuration storage
+
+## Installation
+
+### Quick Install (Recommended)
+
+Install with a single command:
+
+```bash
+curl -fsSL https://gis.ph/install.sh | bash
+```
+
+Then configure:
+```bash
+gis.ph config set apiUrl https://your-api.com
+gis.ph config set apiKey your-api-key-here
+```
+
+### Manual Installation
+
+#### Prerequisites
+
+- Node.js >= 14.0.0
+- npm or yarn
+
+#### Setup
+
+1. **Clone or navigate to the project directory:**
+   ```bash
+   cd my-api-cli
+   ```
+
+2. **Install dependencies:**
+   ```bash
+   npm install
+   ```
+
+3. **Link the CLI globally (optional):**
+   ```bash
+   npm link
+   ```
+   After linking, you can use `gis.ph` command from anywhere.
+
+4. **Configure your API:**
+   ```bash
+   # Set your API URL
+   gis.ph config set apiUrl https://api.gis.ph
+
+   # Set your API key (if required)
+   gis.ph config set apiKey your-api-key-here
+   ```
+
+   Alternatively, create a `.env` file:
+   ```bash
+   cp .env.example .env
+   # Edit .env with your values
+   ```
+
+### Uninstall
+
+```bash
+# Using the uninstall script
+curl -fsSL https://yourusername.github.io/my-api-cli/uninstall.sh | bash
+
+# Or manually
+rm -rf ~/.gis.ph
+rm ~/.local/bin/gis.ph
+```
+
+## Usage
+
+### Configuration Commands
+
+```bash
+# Set configuration
+gis.ph config set <key> <value>
+
+# Get configuration value
+gis.ph config get <key>
+
+# List all configuration
+gis.ph config list
+
+# Delete configuration
+gis.ph config delete <key>
+
+# Enable/disable automatic update checks
+gis.ph config auto-update enable
+gis.ph config auto-update disable
+```
+
+### Update Commands
+
+```bash
+# Update to latest version
+gis.ph update
+
+# Check for updates without installing
+gis.ph update --check
+
+# Force update even if on latest version
+gis.ph update --force
+```
+
+The CLI automatically checks for updates once per day and notifies you if a new version is available. You can disable this with `gis.ph config auto-update disable`.
+
+### Regions Commands
+
+```bash
+# List all regions (table format)
+gis.ph regions list
+
+# List regions in JSON format
+gis.ph regions list --format json
+
+# List with limit
+gis.ph regions list --limit 10
+
+# Filter regions
+gis.ph regions list --filter status:active
+
+# Get specific region by ID
+gis.ph regions get <region-id>
+
+# Get region in table format
+gis.ph regions get <region-id> --format table
+```
+
+### Examples
+
+```bash
+# Configure the CLI
+gis.ph config set apiUrl https://api.gis.ph
+gis.ph config set apiKey sk_live_abc123
+
+# List all regions
+gis.ph regions list
+
+# Get specific region
+gis.ph regions get us-east-1
+
+# List regions as JSON for scripting
+gis.ph regions list --format json | jq '.regions[0]'
+
+# View help
+gis.ph --help
+gis.ph regions --help
+gis.ph regions list --help
+```
+
+## Development
+
+### Running Locally
+
+Without installing globally:
+```bash
+npm start -- regions list
+# or
+node src/index.js regions list
+```
+
+### Project Structure
+
+```
+my-api-cli/
+├── src/
+│   ├── index.js              # Main CLI entry point
+│   ├── commands/             # Command implementations
+│   │   ├── regions.js        # Regions commands
+│   │   └── config.js         # Config commands
+│   ├── lib/                  # Core libraries
+│   │   └── api-client.js     # API HTTP client
+│   └── utils/                # Utility functions
+│       ├── config.js         # Configuration management
+│       └── formatter.js      # Output formatting
+├── package.json
+├── .env.example
+└── README.md
+```
+
+### Adding New Commands
+
+1. Create a new command file in `src/commands/`:
+   ```javascript
+   const { Command } = require('commander');
+   
+   const myCommand = new Command('mycommand');
+   
+   myCommand
+     .description('My command description')
+     .action(async () => {
+       // Your logic here
+     });
+   
+   module.exports = myCommand;
+   ```
+
+2. Register it in `src/index.js`:
+   ```javascript
+   const myCommand = require('./commands/mycommand');
+   program.addCommand(myCommand);
+   ```
+
+3. Add corresponding API methods in `src/lib/api-client.js`:
+   ```javascript
+   async getMyData() {
+     return this.get('/v1/mydata');
+   }
+   ```
+
+## Configuration Storage
+
+Configuration is stored in your system's config directory:
+- **Linux:** `~/.config/my-api-cli/config.json`
+- **macOS:** `~/Library/Preferences/my-api-cli/config.json`
+- **Windows:** `%APPDATA%\my-api-cli\config.json`
+
+## Environment Variables
+
+The CLI supports the following environment variables:
+
+- `API_URL` - Base URL for the API
+- `API_KEY` - API authentication key
+
+These can be set in a `.env` file or exported in your shell.
+
+## Error Handling
+
+The CLI provides helpful error messages:
+- Network errors (API unreachable)
+- Authentication errors (invalid API key)
+- Validation errors (invalid parameters)
+- API errors (with status codes and messages)
+
+## Troubleshooting
+
+### Command not found
+
+If `gis.ph` command is not found after `npm link`:
+```bash
+# Unlink and relink
+npm unlink -g
+npm link
+```
+
+### API connection errors
+
+Check your configuration:
+```bash
+gis.ph config list
+```
+
+Verify your API URL is correct and accessible.
+
+### Debug mode
+
+For more verbose output, use Node's debug mode:
+```bash
+NODE_DEBUG=* gis.ph regions list
+```
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "gis.ph-cli",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "CLI tool for GIS.ph API",
+  "main": "dist/index.js",
+  "bin": {
+    "gis.ph": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js",
+    "dev": "ts-node src/index.ts",
+    "link": "npm run build && npm link",
+    "unlink": "npm unlink -g",
+    "release": "npm run build && bash scripts/release.sh",
+    "version": "npm version"
+  },
+  "keywords": [
+    "cli",
+    "api",
+    "tool"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.2",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.3",
+    "commander": "^11.1.0",
+    "conf": "^10.2.0",
+    "dotenv": "^16.3.1",
+    "ora": "^5.4.1"
+  },
+  "devDependencies": {
+    "@types/chalk": "^0.4.31",
+    "@types/commander": "^2.12.0",
+    "@types/node": "^25.2.3",
+    "@types/ora": "^3.1.0",
+    "eslint": "^8.55.0",
+    "ts-node": "^10.9.2",
+    "tsc-alias": "^1.8.16",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/scripts/release.sh

@@ -0,0 +1,88 @@
+#!/bin/bash
+
+# Release Script for My API CLI
+# This script helps you create a release package
+
+set -e
+
+# Colors
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Get version from package.json
+VERSION=$(node -p "require('./package.json').version")
+
+echo -e "${BLUE}Creating release package for v${VERSION}...${NC}"
+echo ""
+
+# Clean up old builds
+if [ -d "dist" ]; then
+    echo -e "${YELLOW}Cleaning old builds...${NC}"
+    rm -rf dist
+fi
+
+mkdir -p dist
+
+# Create tarball
+echo -e "${BLUE}Creating tarball...${NC}"
+tar -czf "dist/my-api-cli-v${VERSION}.tar.gz" \
+    --exclude='node_modules' \
+    --exclude='dist' \
+    --exclude='.git' \
+    --exclude='.env' \
+    --exclude='*.log' \
+    src/ \
+    package.json \
+    README.md \
+    .env.example
+
+echo -e "${GREEN}✓ Created: dist/my-api-cli-v${VERSION}.tar.gz${NC}"
+
+# Create checksum
+echo -e "${BLUE}Generating SHA256 checksum...${NC}"
+if command -v sha256sum &> /dev/null; then
+    sha256sum "dist/my-api-cli-v${VERSION}.tar.gz" > "dist/my-api-cli-v${VERSION}.tar.gz.sha256"
+    CHECKSUM=$(cat "dist/my-api-cli-v${VERSION}.tar.gz.sha256" | cut -d' ' -f1)
+elif command -v shasum &> /dev/null; then
+    shasum -a 256 "dist/my-api-cli-v${VERSION}.tar.gz" > "dist/my-api-cli-v${VERSION}.tar.gz.sha256"
+    CHECKSUM=$(cat "dist/my-api-cli-v${VERSION}.tar.gz.sha256" | cut -d' ' -f1)
+else
+    echo -e "${YELLOW}⚠  sha256sum not found, skipping checksum${NC}"
+    CHECKSUM="N/A"
+fi
+
+if [ "$CHECKSUM" != "N/A" ]; then
+    echo -e "${GREEN}✓ SHA256: $CHECKSUM${NC}"
+fi
+
+# Create npm package
+echo -e "${BLUE}Creating npm package...${NC}"
+npm pack --pack-destination=dist
+
+echo -e "${GREEN}✓ Created: dist/my-api-cli-${VERSION}.tgz${NC}"
+
+# List created files
+echo ""
+echo -e "${GREEN}Release files created:${NC}"
+ls -lh dist/
+
+echo ""
+echo -e "${BLUE}Next steps:${NC}"
+echo "1. Test the package:"
+echo -e "   ${YELLOW}cd /tmp && tar -xzf $(pwd)/dist/my-api-cli-v${VERSION}.tar.gz${NC}"
+echo ""
+echo "2. Create a git tag:"
+echo -e "   ${YELLOW}git tag -a v${VERSION} -m 'Release v${VERSION}'${NC}"
+echo -e "   ${YELLOW}git push origin v${VERSION}${NC}"
+echo ""
+echo "3. Create GitHub release and upload:"
+echo -e "   ${YELLOW}dist/my-api-cli-v${VERSION}.tar.gz${NC}"
+echo -e "   ${YELLOW}dist/my-api-cli-v${VERSION}.tar.gz.sha256${NC}"
+echo ""
+echo "4. Update install.sh with new version and checksum"
+if [ "$CHECKSUM" != "N/A" ]; then
+    echo -e "   ${YELLOW}EXPECTED_SHA='$CHECKSUM'${NC}"
+fi
+echo ""

package/src/commands/config.ts

@@ -0,0 +1,113 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { getConfig } from '../utils/config.js';
+import { enableAutoUpdateCheck, disableAutoUpdateCheck, isAutoUpdateDisabled } from '../utils/auto-update.js';
+
+const configCommand = new Command('config');
+
+configCommand
+    .description('Manage CLI configuration')
+    .addCommand(createSetCommand())
+    .addCommand(createGetCommand())
+    .addCommand(createListCommand())
+    .addCommand(createDeleteCommand())
+    .addCommand(createAutoUpdateCommand());
+
+function createSetCommand() {
+    return new Command('set')
+        .description('Set a configuration value')
+        .argument('<key>', 'Configuration key (apiUrl, apiKey)')
+        .argument('<value>', 'Configuration value')
+        .action((key: string, value: string) => {
+            const config = getConfig();
+            config.set(key, value);
+            console.log(chalk.green(`✓ Configuration updated: ${key} = ${maskSensitive(key, value)}`));
+        });
+}
+
+function createGetCommand() {
+    return new Command('get')
+        .description('Get a configuration value')
+        .argument('<key>', 'Configuration key')
+        .action((key: string) => {
+            const config = getConfig();
+            const value = config.get(key);
+
+            if (value === undefined) {
+                console.log(chalk.yellow(`Configuration key "${key}" not found`));
+            } else {
+                console.log(chalk.cyan(`${key}:`), maskSensitive(key, value as string));
+            }
+        });
+}
+
+function createListCommand() {
+    return new Command('list')
+        .description('List all configuration values')
+        .action(() => {
+            const config = getConfig();
+            const store = config.store;
+
+            if (Object.keys(store).length === 0) {
+                console.log(chalk.yellow('No configuration set'));
+                return;
+            }
+
+            console.log(chalk.bold('\nCurrent Configuration:'));
+            Object.entries(store).forEach(([key, value]) => {
+                // Skip internal keys
+                if (key.startsWith('last') || key === 'autoUpdateCheckDisabled') {
+                    return;
+                }
+                console.log(chalk.cyan(`  ${key}:`), maskSensitive(key, value as string));
+            });
+
+            // Show auto-update status
+            const autoUpdateDisabled = isAutoUpdateDisabled();
+            console.log(chalk.cyan(`  Auto-update checks:`), autoUpdateDisabled ? chalk.red('disabled') : chalk.green('enabled'));
+
+            console.log();
+        });
+}
+
+function createDeleteCommand() {
+    return new Command('delete')
+        .description('Delete a configuration value')
+        .argument('<key>', 'Configuration key')
+        .action((key: string) => {
+            const config = getConfig();
+            config.delete(key);
+            console.log(chalk.green(`✓ Configuration deleted: ${key}`));
+        });
+}
+
+function createAutoUpdateCommand() {
+    return new Command('auto-update')
+        .description('Enable or disable automatic update checks')
+        .argument('<action>', 'Action: enable or disable')
+        .action((action: string) => {
+            if (action === 'enable') {
+                enableAutoUpdateCheck();
+                console.log(chalk.green('✓ Automatic update checks enabled'));
+                console.log(chalk.gray('  The CLI will check for updates once per day\n'));
+            } else if (action === 'disable') {
+                disableAutoUpdateCheck();
+                console.log(chalk.yellow('✓ Automatic update checks disabled'));
+                console.log(chalk.gray('  You can still manually check with: gis.ph update --check\n'));
+            } else {
+                console.log(chalk.red(`Invalid action: ${action}`));
+                console.log(chalk.yellow('Usage: gis.ph config auto-update <enable|disable>\n'));
+            }
+        });
+}
+
+function maskSensitive(key: string, value: string): string {
+    if (!value) return '(not set)';
+    const sensitiveKeys = ['apiKey', 'apikey', 'api_key', 'token', 'password', 'secret'];
+    if (sensitiveKeys.some(k => key.toLowerCase().includes(k))) {
+        return value ? '***' + value.slice(-4) : '(not set)';
+    }
+    return value;
+}
+
+export default configCommand;

package/src/commands/regions.ts

@@ -0,0 +1,99 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import apiClient from '../lib/api-client.js';
+import { formatTable, formatJson } from '../utils/formatter.js';
+
+const regionsCommand = new Command('regions');
+
+regionsCommand
+    .description('Manage and view regions')
+    .addCommand(createListCommand())
+    .addCommand(createGetCommand());
+
+function createListCommand() {
+    return new Command('list')
+        .description('List all regions')
+        .option('-f, --format <type>', 'Output format (table|json)', 'table')
+        .option('-l, --limit <number>', 'Limit number of results')
+        .option('--filter <field:value>', 'Filter results (e.g., status:active)')
+        .action(async (options) => {
+            const spinner = ora('Fetching regions...').start();
+
+            try {
+                // Build query parameters
+                const params: any = {};
+                if (options.limit) {
+                    params.limit = parseInt(options.limit);
+                }
+                if (options.filter) {
+                    const [field, value] = options.filter.split(':');
+                    params[field] = value;
+                }
+
+                const data = await apiClient.getRegions(params);
+                spinner.succeed('Regions fetched successfully');
+
+                // Display results
+                if (options.format === 'json') {
+                    console.log(formatJson(data));
+                } else {
+                    // The API now returns { data: [...], error: null }
+                    const regions = Array.isArray(data) ? data : ((data as any).data || (data as any).regions || []);
+
+                    if (regions.length === 0) {
+                        console.log(chalk.yellow('\nNo regions found.\n'));
+                        return;
+                    }
+
+                    const tableData = regions.map((region: any) => ({
+                        ID: region.id || 'N/A',
+                        Name: region.name || 'N/A',
+                        Title: region.title || 'N/A',
+                        Code: region.code || 'N/A',
+                    }));
+
+                    console.log(formatTable(tableData));
+                    console.log(chalk.gray(`\nTotal: ${regions.length} region(s)\n`));
+                }
+            } catch (error: any) {
+                spinner.fail('Failed to fetch regions');
+                console.error(chalk.red(`\nError: ${error.message}\n`));
+                process.exit(1);
+            }
+        });
+}
+
+function createGetCommand() {
+    return new Command('get')
+        .description('Get details of a specific region')
+        .argument('<id>', 'Region ID')
+        .option('-f, --format <type>', 'Output format (table|json)', 'json')
+        .action(async (id: string, options) => {
+            const spinner = ora(`Fetching region ${id}...`).start();
+
+            try {
+                const data = await apiClient.getRegionById(id);
+                spinner.succeed(`Region ${id} fetched successfully`);
+
+                if (options.format === 'json') {
+                    console.log(formatJson(data));
+                } else {
+                    // The API now returns { data: {...}, error: null }
+                    const region = (data as any).data || (data as any).region || data;
+                    const tableData = Object.entries(region).map(([key, value]) => ({
+                        Field: key,
+                        Value: typeof value === 'object' ? JSON.stringify(value) : value,
+                    }));
+
+                    console.log(formatTable(tableData));
+                }
+            } catch (error: any) {
+                spinner.fail(`Failed to fetch region ${id}`);
+                console.error(chalk.red(`\nError: ${error.message}\n`));
+                process.exit(1);
+            }
+        });
+}
+
+export default regionsCommand;

package/src/commands/update.ts

@@ -0,0 +1,321 @@
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import https from 'https';
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+
+// Load package.json manually to avoid issues with JSON modules in some environments
+const pkgPath = new URL('../../package.json', import.meta.url);
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+const updateCommand = new Command('update');
+
+updateCommand
+    .description('Update the CLI to the latest version')
+    .option('--check', 'Check for updates without installing')
+    .option('--force', 'Force update even if already on latest version')
+    .action(async (options: any) => {
+        if (options.check) {
+            await checkForUpdates(true);
+        } else {
+            await performUpdate(options.force);
+        }
+    });
+
+/**
+ * Check for available updates
+ */
+export async function checkForUpdates(verbose = false): Promise<any> {
+    const spinner = verbose ? ora('Checking for updates...').start() : null;
+
+    try {
+        const latestVersion = await getLatestVersion();
+        const currentVersion = pkg.version;
+
+        if (spinner) spinner.succeed('Update check complete');
+
+        const isNewer = compareVersions(latestVersion, currentVersion) > 0;
+
+        if (isNewer) {
+            if (verbose) {
+                console.log(chalk.yellow(`\n🎉 Update available!`));
+                console.log(chalk.gray(`   Current: ${currentVersion}`));
+                console.log(chalk.green(`   Latest:  ${latestVersion}`));
+                console.log(chalk.cyan(`\n   Run ${chalk.bold('gis.ph update')} to upgrade\n`));
+            }
+            return { updateAvailable: true, currentVersion, latestVersion };
+        } else {
+            if (verbose) {
+                console.log(chalk.green(`\n✓ You're on the latest version (${currentVersion})\n`));
+            }
+            return { updateAvailable: false, currentVersion, latestVersion };
+        }
+    } catch (error: any) {
+        if (spinner) spinner.fail('Failed to check for updates');
+        if (verbose) {
+            console.error(chalk.red(`\nError: ${error.message}\n`));
+        }
+        return { updateAvailable: false, error: error.message };
+    }
+}
+
+/**
+ * Get latest version from GitHub
+ */
+export function getLatestVersion(): Promise<string> {
+    return new Promise((resolve, reject) => {
+        // Update this URL to match your GitHub repo
+        const GITHUB_REPO = process.env.GITHUB_REPO || 'yourusername/my-api-cli';
+        const url = `https://api.github.com/repos/${GITHUB_REPO}/releases/latest`;
+
+        https.get(url, {
+            headers: {
+                'User-Agent': 'gis.ph-CLI'
+            }
+        }, (res: any) => {
+            let data = '';
+
+            res.on('data', (chunk: any) => {
+                data += chunk;
+            });
+
+            res.on('end', () => {
+                try {
+                    if (res.statusCode === 404) {
+                        // No releases, try to get from package.json on main branch
+                        getVersionFromMain(GITHUB_REPO)
+                            .then(resolve)
+                            .catch(reject);
+                        return;
+                    }
+
+                    if (res.statusCode !== 200) {
+                        reject(new Error(`GitHub API returned status ${res.statusCode}`));
+                        return;
+                    }
+
+                    const release = JSON.parse(data);
+                    const version = release.tag_name.replace(/^v/, '');
+                    resolve(version);
+                } catch (error) {
+                    reject(new Error('Failed to parse GitHub response'));
+                }
+            });
+        }).on('error', (error: any) => {
+            reject(new Error(`Failed to check version: ${error.message}`));
+        });
+    });
+}
+
+/**
+ * Get version from package.json on main branch (fallback)
+ */
+function getVersionFromMain(repo: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+        const url = `https://raw.githubusercontent.com/${repo}/main/package.json`;
+
+        https.get(url, {
+            headers: {
+                'User-Agent': 'gis.ph-CLI'
+            }
+        }, (res: any) => {
+            let data = '';
+
+            res.on('data', (chunk: any) => {
+                data += chunk;
+            });
+
+            res.on('end', () => {
+                try {
+                    if (res.statusCode !== 200) {
+                        reject(new Error('Could not fetch version from GitHub'));
+                        return;
+                    }
+
+                    const packageJson = JSON.parse(data);
+                    resolve(packageJson.version);
+                } catch (error) {
+                    reject(new Error('Failed to parse package.json from GitHub'));
+                }
+            });
+        }).on('error', (error: any) => {
+            reject(error);
+        });
+    });
+}
+
+/**
+ * Compare semantic versions
+ * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
+ */
+export function compareVersions(v1: string, v2: string): number {
+    const parts1 = v1.split('.').map(Number);
+    const parts2 = v2.split('.').map(Number);
+
+    for (let i = 0; i < 3; i++) {
+        const part1 = parts1[i] || 0;
+        const part2 = parts2[i] || 0;
+
+        if (part1 > part2) return 1;
+        if (part1 < part2) return -1;
+    }
+
+    return 0;
+}
+
+/**
+ * Perform the update
+ */
+async function performUpdate(force = false) {
+    console.log(chalk.blue('\n🔄 Updating CLI...\n'));
+
+    // Check for updates first
+    if (!force) {
+        const updateInfo = await checkForUpdates(false);
+
+        if (!updateInfo.updateAvailable) {
+            console.log(chalk.green(`✓ Already on the latest version (${updateInfo.currentVersion})\n`));
+            console.log(chalk.gray(`Use --force to reinstall anyway\n`));
+            return;
+        }
+    }
+
+    const spinner = ora('Downloading latest version...').start();
+
+    try {
+        // Get installation directory
+        const installDir = getInstallDir();
+
+        if (!installDir) {
+            spinner.fail('Update failed');
+            console.error(chalk.red('\nError: Could not determine installation directory'));
+            console.log(chalk.yellow('\nPlease reinstall using:'));
+            console.log(chalk.cyan('curl -fsSL https://gis.ph/install.sh | bash\n'));
+            process.exit(1);
+        }
+
+        spinner.text = 'Updating...';
+
+        // Run the update script
+        const GITHUB_REPO = process.env.GITHUB_REPO || 'yourusername/my-api-cli';
+        const DOWNLOAD_URL = `https://github.com/${GITHUB_REPO}/archive/refs/heads/main.tar.gz`;
+
+        // Use the same update logic as install script
+        const updateScript = `
+      set -e
+      TEMP_DIR=$(mktemp -d)
+      TEMP_FILE="$TEMP_DIR/cli.tar.gz"
+      INSTALL_DIR="${installDir}"
+      
+      # Download
+      if command -v curl &> /dev/null; then
+        curl -fsSL "${DOWNLOAD_URL}" -o "$TEMP_FILE"
+      else
+        wget -q "${DOWNLOAD_URL}" -O "$TEMP_FILE"
+      fi
+      
+      # Backup current installation
+      if [ -d "$INSTALL_DIR.backup" ]; then
+        rm -rf "$INSTALL_DIR.backup"
+      fi
+      cp -r "$INSTALL_DIR" "$INSTALL_DIR.backup"
+      
+      # Extract to temp location
+      EXTRACT_DIR="$TEMP_DIR/extract"
+      mkdir -p "$EXTRACT_DIR"
+      tar -xzf "$TEMP_FILE" -C "$EXTRACT_DIR"
+      
+      # Find extracted directory
+      EXTRACTED_DIR=$(find "$EXTRACT_DIR" -mindepth 1 -maxdepth 1 -type d | head -n 1)
+      
+      # Move files
+      rm -rf "$INSTALL_DIR"
+      mv "$EXTRACTED_DIR" "$INSTALL_DIR"
+      
+      # Install dependencies
+      cd "$INSTALL_DIR"
+      npm install --production --silent
+      
+      # Clean up
+      rm -rf "$TEMP_DIR"
+      rm -rf "$INSTALL_DIR.backup"
+    `;
+
+        execSync(updateScript, {
+            stdio: 'pipe',
+            shell: '/bin/bash'
+        });
+
+        spinner.succeed('Update complete!');
+
+        // Get new version
+        const newPackageJson = JSON.parse(
+            fs.readFileSync(path.join(installDir, 'package.json'), 'utf8')
+        );
+
+        console.log(chalk.green(`\n✓ Successfully updated to version ${newPackageJson.version}\n`));
+        console.log(chalk.gray('Changes will take effect immediately.\n'));
+
+    } catch (error: any) {
+        spinner.fail('Update failed');
+        console.error(chalk.red(`\nError: ${error.message}`));
+        console.log(chalk.yellow('\nIf the problem persists, try reinstalling:'));
+        console.log(chalk.cyan('curl -fsSL https://gis.ph/install.sh | bash\n'));
+        process.exit(1);
+    }
+}
+
+/**
+ * Get CLI installation directory
+ */
+function getInstallDir(): string | null {
+    // Method 1: Try from config file (set during installation)
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const configPath = path.join(homeDir, '.config', 'gis.ph', 'install_dir');
+    if (fs.existsSync(configPath)) {
+        const installDir = fs.readFileSync(configPath, 'utf8').trim();
+        if (installDir && fs.existsSync(installDir)) {
+            return installDir;
+        }
+    }
+
+    // Method 2: Try environment variable
+    const envInstallDir = process.env['GIS_PH_INSTALL_DIR'] || process.env['GIS.PH_INSTALL_DIR'];
+    if (envInstallDir && fs.existsSync(envInstallDir)) {
+        return envInstallDir;
+    }
+
+    // Method 3: Try common installation paths
+    const possiblePaths = [
+        path.join(homeDir, '.gis.ph'),
+        path.join(homeDir, '.my-api-cli'),
+    ];
+
+    for (const dir of possiblePaths) {
+        if (dir && fs.existsSync(dir) && fs.existsSync(path.join(dir, 'package.json'))) {
+            return dir;
+        }
+    }
+
+    // Method 4: Try to get from the current executable path
+    const binPath = process.argv[1];
+    if (binPath && fs.existsSync(binPath)) {
+        try {
+            if (fs.lstatSync(binPath).isSymbolicLink()) {
+                const realPath = fs.realpathSync(binPath);
+                const installDir = path.dirname(path.dirname(realPath));
+                if (fs.existsSync(path.join(installDir, 'package.json'))) {
+                    return installDir;
+                }
+            }
+        } catch (e) {
+            // Ignore errors
+        }
+    }
+
+    return null;
+}
+
+export default updateCommand;

package/src/index.ts

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import fs from 'fs';
+import path from 'path';
+import { autoCheckForUpdates, isAutoUpdateDisabled } from './utils/auto-update.js';
+
+// Import commands
+import regionsCommand from './commands/regions.js';
+import configCommand from './commands/config.js';
+import updateCommand from './commands/update.js';
+
+// Load package.json manually
+const pkgPath = new URL('../package.json', import.meta.url);
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+
+const program = new Command();
+
+program
+    .name('gis.ph')
+    .description('CLI tool for GIS.ph API')
+    .version(pkg.version);
+
+// Add commands
+program.addCommand(regionsCommand);
+program.addCommand(configCommand);
+program.addCommand(updateCommand);
+
+// Handle unknown commands
+program.on('command:*', () => {
+    console.error(chalk.red(`\nInvalid command: ${program.args.join(' ')}`));
+    console.log(chalk.yellow(`See --help for a list of available commands.\n`));
+    process.exit(1);
+});
+
+// Check for updates in background (non-blocking)
+if (!isAutoUpdateDisabled()) {
+    autoCheckForUpdates().catch(() => {
+        // Silently fail - don't interrupt user
+    });
+}
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no arguments provided
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/src/lib/api-client.ts

@@ -0,0 +1,85 @@
+import axios, { AxiosInstance } from 'axios';
+import { getConfig } from '../utils/config.js';
+
+class ApiClient {
+    private client: AxiosInstance;
+    private baseURL: string;
+    private apiKey?: string;
+
+    constructor() {
+        const config = getConfig();
+
+        this.baseURL = (config.get('apiUrl') as string) || process.env.API_URL || 'http://localhost:3000';
+        this.apiKey = (config.get('apiKey') as string) || process.env.API_KEY;
+
+        this.client = axios.create({
+            baseURL: this.baseURL,
+            timeout: 30000,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+
+        // Add request interceptor for authentication
+        this.client.interceptors.request.use(
+            (conf) => {
+                if (this.apiKey) {
+                    conf.headers['Authorization'] = `Bearer ${this.apiKey}`;
+                }
+                return conf;
+            },
+            (error) => {
+                return Promise.reject(error);
+            }
+        );
+
+        // Add response interceptor for error handling
+        this.client.interceptors.response.use(
+            (response) => response,
+            (error) => {
+                if (error.response) {
+                    // Server responded with error status
+                    const message = error.response.data?.message || error.response.statusText;
+                    throw new Error(`API Error (${error.response.status}): ${message}`);
+                } else if (error.request) {
+                    // Request made but no response
+                    throw new Error(`Network Error: Unable to reach API at ${this.baseURL}`);
+                } else {
+                    // Something else happened
+                    throw new Error(`Request Error: ${error.message}`);
+                }
+            }
+        );
+    }
+
+    async get<T = any>(endpoint: string, params: any = {}): Promise<T> {
+        const response = await this.client.get(endpoint, { params });
+        return response.data;
+    }
+
+    async post<T = any>(endpoint: string, data: any = {}): Promise<T> {
+        const response = await this.client.post(endpoint, data);
+        return response.data;
+    }
+
+    async put<T = any>(endpoint: string, data: any = {}): Promise<T> {
+        const response = await this.client.put(endpoint, data);
+        return response.data;
+    }
+
+    async delete<T = any>(endpoint: string): Promise<T> {
+        const response = await this.client.delete(endpoint);
+        return response.data;
+    }
+
+    // Specific API methods
+    async getRegions(params: any = {}) {
+        return this.get('/v1/regions', params);
+    }
+
+    async getRegionById(id: string | number) {
+        return this.get(`/v1/regions/${id}`);
+    }
+}
+
+export default new ApiClient();

package/src/utils/auto-update.ts

@@ -0,0 +1,59 @@
+import chalk from 'chalk';
+import { getConfig } from './config.js';
+// We'll import type if needed, but for now we'll use any or dynamic import if there's a circular dependency
+// Actually, it's better to move common types to a separate file.
+
+export async function autoCheckForUpdates() {
+    try {
+        const config = getConfig();
+        const lastCheck = config.get('lastUpdateCheck') as number;
+        const now = Date.now();
+
+        // Check once per day (24 hours)
+        const ONE_DAY = 24 * 60 * 60 * 1000;
+
+        if (lastCheck && (now - lastCheck) < ONE_DAY) {
+            return; // Too soon, skip check
+        }
+
+        // Update last check time
+        config.set('lastUpdateCheck', now);
+
+        // Lazy import to avoid circular dependency if update.ts imports this
+        const { checkForUpdates } = await import('../commands/update.js');
+
+        // Check for updates (non-verbose, don't show spinner)
+        const updateInfo = await checkForUpdates(false);
+
+        if (updateInfo.updateAvailable) {
+            // Show notification at the end of command output
+            setTimeout(() => {
+                console.log(chalk.yellow('\n┌─────────────────────────────────────────┐'));
+                console.log(chalk.yellow('│  🎉 Update Available!                   │'));
+                console.log(chalk.yellow('│                                         │'));
+                console.log(chalk.gray(`│  Current: ${updateInfo.currentVersion.padEnd(28)} │`));
+                console.log(chalk.green(`│  Latest:  ${updateInfo.latestVersion.padEnd(28)} │`));
+                console.log(chalk.yellow('│                                         │'));
+                console.log(chalk.cyan(`│  Run ${chalk.bold('gis.ph update')} to upgrade        │`));
+                console.log(chalk.yellow('└─────────────────────────────────────────┘\n'));
+            }, 100);
+        }
+    } catch (error) {
+        // Silently fail - don't interrupt user's workflow
+    }
+}
+
+export function disableAutoUpdateCheck() {
+    const config = getConfig();
+    config.set('autoUpdateCheckDisabled', true);
+}
+
+export function enableAutoUpdateCheck() {
+    const config = getConfig();
+    config.set('autoUpdateCheckDisabled', false);
+}
+
+export function isAutoUpdateDisabled() {
+    const config = getConfig();
+    return config.get('autoUpdateCheckDisabled') === true;
+}

package/src/utils/config.ts

@@ -0,0 +1,23 @@
+import Conf from 'conf';
+
+interface ConfigSchema {
+    apiUrl: string;
+    apiKey?: string;
+    lastUpdateCheck?: number;
+    [key: string]: any;
+}
+
+let config: any;
+
+export function getConfig() {
+    if (!config) {
+        // @ts-ignore
+        config = new Conf<ConfigSchema>({
+            projectName: 'gis.ph',
+            defaults: {
+                apiUrl: 'https://api.gis.ph',
+            },
+        });
+    }
+    return config;
+}

package/src/utils/formatter.ts

@@ -0,0 +1,61 @@
+import Table from 'cli-table3';
+import chalk from 'chalk';
+
+/**
+ * Format data as a table
+ * @param {Array<any>} data - Array of objects to display
+ * @returns {string} Formatted table
+ */
+export function formatTable(data: any[]): string {
+    if (!Array.isArray(data) || data.length === 0) {
+        return chalk.yellow('No data to display');
+    }
+
+    const headers = Object.keys(data[0]);
+
+    const table = new Table({
+        head: headers.map(h => chalk.cyan(h)),
+        style: {
+            head: [],
+            border: ['gray'],
+        },
+        // @ts-ignore - cli-table3 types might be strict about colWidths
+        colWidths: headers.map(() => null), // Auto-width
+    });
+
+    data.forEach(row => {
+        table.push(headers.map(h => row[h] ?? ''));
+    });
+
+    return '\n' + table.toString() + '\n';
+}
+
+/**
+ * Format data as pretty JSON
+ * @param {*} data - Data to format
+ * @returns {string} Formatted JSON
+ */
+export function formatJson(data: any): string {
+    return '\n' + JSON.stringify(data, null, 2) + '\n';
+}
+
+/**
+ * Format data as simple key-value pairs
+ * @param {Object} data - Object to display
+ * @returns {string} Formatted output
+ */
+export function formatKeyValue(data: any): string {
+    if (typeof data !== 'object' || data === null) {
+        return String(data);
+    }
+
+    let output = '\n';
+    Object.entries(data).forEach(([key, value]) => {
+        const formattedValue = typeof value === 'object'
+            ? JSON.stringify(value, null, 2)
+            : value;
+        output += `${chalk.cyan(key + ':')} ${formattedValue}\n`;
+    });
+
+    return output;
+}

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "target": "ESNext",
+        "module": "NodeNext",
+        "moduleResolution": "NodeNext",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true,
+        "declaration": true,
+        "sourceMap": true,
+        "resolveJsonModule": true
+    },
+    "include": [
+        "src/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
+}