@splashcodex/api-key-manager 5.0.2 → 5.2.0

package/README.md

@@ -1,206 +1,206 @@
-# @splashcodex/ApiKeyManager v5.0 — Ecosystem Edition
-
-> Universal API Key Management Gateway with Provider Presets, Built-in Persistence, and Multi-Provider Vault.
-
-[![npm version](https://img.shields.io/npm/v/@splashcodex/ApiKeyManager)](https://www.npmjs.com/package/@splashcodex/ApiKeyManager)
-
-## New in v5.0 (Ecosystem Edition)
-
-- **Provider Presets** — One-line setup for `GeminiManager`, `OpenAIManager`, and `MultiManager`.
-- **Automatic Env Parsing** — Reads `GOOGLE_GEMINI_API_KEY`, `OPENAI_API_KEY`, etc. (supports JSON arrays and comma-separated strings).
-- **Built-in Persistence** — `FileStorage` (survives restarts) and `MemoryStorage` included.
-- **Singleton Pattern** — Thread-safe singletons with `getInstance()` and `Result<T>` pattern.
-- **Multi-Provider Vault** — Manage multiple providers (`gemini`, `openai`, `anthropic`) from a single entry point.
-- **Centralized API Gateway** — Built-in Fastify proxy server to centralize AI requests for multiple apps securely.
-
-## Features
-
-- **Circuit Breaker** — Keys transition through `CLOSED → OPEN → HALF_OPEN → DEAD`
-- **Error Classification** — Automatic detection of 429 (Quota), 403 (Auth), 5xx (Transient), Timeout, Safety blocks
-- **Pluggable Strategies** — `StandardStrategy`, `WeightedStrategy`, `LatencyStrategy`
-- **`execute()` Wrapper** — Single method: get key → call → latency → retry → fallback
-- **Event Emitter** — Typed lifecycle hooks for monitoring & alerting
-- **Auto-Retry with Backoff** — Built-in retry loop with exponential backoff + jitter
-- **Semantic Cache** — Cosine-similarity cache with pluggable embeddings
-- **Streaming Support** — `executeStream()` with initial retry + cache replay
-- **100% Backward Compatible** — v1.x through v4.x code works without changes
-
-## Installation
-
-```bash
-npm install @splashcodex/api-key-manager
-```
-
-### 🚀 Auto-Scaffold (New!)
-The fastest way to get started is to run the `init` command in your project directory:
-```bash
-npx @splashcodex/api-key-manager init
-```
-This will automatically create a `.env` template and a `demo.ts` file showing the Gemini Preset in action.
-
-## Quick Start (v5 Presets)
-
-The fastest way to get started in any CodeDex repository.
-
-### Gemini Preset
-Reads `GOOGLE_GEMINI_API_KEY` or `GEMINI_API_KEY` from environment.
-
-```typescript
-import { GeminiManager } from '@splashcodex/api-key-manager/presets/gemini';
-
-const result = GeminiManager.getInstance();
-if (!result.success) throw result.error;
-
-const gemini = result.data;
-const response = await gemini.execute(async (key) => {
-    // result.data is the underlying ApiKeyManager
-    return await callGemini(key, "Hello!");
-});
-```
-
-### Centralized API Gateway (New!)
-
-Run a standalone proxy server that acts as a single point of entry for all your microservices or repositories. It centralizes key management, circuit breaking, and rate limiting across applications.
-
-1. Install global/local and export your keys:
-```bash
-export GOOGLE_GEMINI_API_KEY="AIzaSy...1,AIzaSy...2"
-```
-
-2. Start the gateway:
-```bash
-npm run gateway
-# Server runs on http://localhost:9000
-```
-
-3. Call the proxy from ANY language without managing keys in the client app:
-```bash
-curl -X POST http://localhost:9000/v1/generate \
-  -H "Content-Type: application/json" \
-  -d '{"provider": "gemini", "prompt": "Hello!"}'
-```
-Route supports both `/v1/generate` (Standard JSON) and `/v1/stream` (Server-Sent Events). Monitoring available at `/v1/health` and `/v1/providers`.
-
----
-
-### Multi-Provider Vault
-
-Manage ALL your provider keys across your system from one pool.Perfect for gateways or complex bots handling multiple models.
-
-```typescript
-import { MultiManager } from '@splashcodex/api-key-manager/presets/multi';
-
-const vault = MultiManager.getInstance({
-    providers: {
-        gemini: { envKeys: ['GOOGLE_GEMINI_API_KEY'] },
-        openai: { envKeys: ['OPENAI_API_KEY'] }
-    }
-}).data!;
-
-// Route by provider
-const res = await vault.execute(fn, { provider: 'gemini' });
-```
-
----
-
-## v5.0 — Architecture & Persistence
-
-### Built-in Persistence
-State (cooling down keys, dead keys) now survives application restarts by default.
-
-```typescript
-import { FileStorage } from '@splashcodex/api-key-manager/persistence/file';
-
-const manager = new ApiKeyManager(keys, {
-    storage: new FileStorage({
-        filePath: './api_state.json'
-    })
-});
-```
-
-### Subpath Imports
-To keep your bundles small, you can import only what you need:
-
-```typescript
-import { GeminiManager } from '@splashcodex/api-key-manager/presets/gemini';
-import { FileStorage } from '@splashcodex/api-key-manager/persistence/file';
-```
-
----
-
-## v4.0 — Semantic Cache
-
-Automatically cache API responses by semantic similarity.
-
-```typescript
-const manager = new ApiKeyManager(['key1', 'key2'], {
-  semanticCache: {
-    threshold: 0.92,
-    getEmbedding: async (text) => await myModel.embed(text)
-  }
-});
-
-// Cache HIT if prompt is semantically similar
-const r1 = await manager.execute(apiFn, { prompt: 'What is the weather?' });
-const r2 = await manager.execute(apiFn, { prompt: 'How is the weather today?' });
-```
-
-### v4.1 — Streaming Support
-Real-time response handling with the same resilience as `execute()`.
-
-```typescript
-const stream = await manager.executeStream(async (key) => {
-    return await gemini.generateContentStream({ prompt: "..." });
-}, { prompt: "..." });
-
-for await (const chunk of stream) {
-    console.log(chunk.text());
-}
-```
-
----
-
-## execute() Wrapper
-
-Wraps the entire lifecycle into one method:
-
-```typescript
-const result = await manager.execute(
-  async (key, signal) => {
-    const res = await fetch(url, { headers: { 'x-api-key': key }, signal });
-    return res.json();
-  },
-  { maxRetries: 3, timeoutMs: 10000 }
-);
-```
-
-## API Reference
-
-### Presets
-
-| Class | Env Vars | Description |
-|-------|----------|-------------|
-| `GeminiManager` | `GOOGLE_GEMINI_API_KEY`, `GEMINI_API_KEY` | Gemini-optimized singleton |
-| `OpenAIManager` | `OPENAI_API_KEY` | OpenAI-optimized singleton |
-| `MultiManager` | Custom | Vault for multiple provider pools |
-
-### Persistence
-
-| Class | Description |
-|-------|-------------|
-| `FileStorage` | Persists to a JSON file (recommended for servers) |
-| `MemoryStorage` | In-memory only (best for serverless/short-lived) |
-
-### Core Methods
-
-| Method | Description |
-|--------|-------------|
-| `execute(fn, opts)` | Standard wrapper |
-| `executeStream(fn, opts)` | Streaming wrapper |
-| `getStats()` | Get pool health |
-| `getKey()` | Manual key rotation |
-| `markFailed(key, err)` | Manual failure reporting |
-
-## License
-
-ISC
+# @splashcodex/ApiKeyManager v5.0 — Ecosystem Edition
+
+> Universal API Key Management Gateway with Provider Presets, Built-in Persistence, and Multi-Provider Vault.
+
+[![npm version](https://img.shields.io/npm/v/@splashcodex/ApiKeyManager)](https://www.npmjs.com/package/@splashcodex/ApiKeyManager)
+
+## New in v5.0 (Ecosystem Edition)
+
+- **Provider Presets** — One-line setup for `GeminiManager`, `OpenAIManager`, and `MultiManager`.
+- **Automatic Env Parsing** — Reads `GOOGLE_GEMINI_API_KEY`, `OPENAI_API_KEY`, etc. (supports JSON arrays and comma-separated strings).
+- **Built-in Persistence** — `FileStorage` (survives restarts) and `MemoryStorage` included.
+- **Singleton Pattern** — Thread-safe singletons with `getInstance()` and `Result<T>` pattern.
+- **Multi-Provider Vault** — Manage multiple providers (`gemini`, `openai`, `anthropic`) from a single entry point.
+- **Centralized API Gateway** — Built-in Fastify proxy server to centralize AI requests for multiple apps securely.
+
+## Features
+
+- **Circuit Breaker** — Keys transition through `CLOSED → OPEN → HALF_OPEN → DEAD`
+- **Error Classification** — Automatic detection of 429 (Quota), 403 (Auth), 5xx (Transient), Timeout, Safety blocks
+- **Pluggable Strategies** — `StandardStrategy`, `WeightedStrategy`, `LatencyStrategy`
+- **`execute()` Wrapper** — Single method: get key → call → latency → retry → fallback
+- **Event Emitter** — Typed lifecycle hooks for monitoring & alerting
+- **Auto-Retry with Backoff** — Built-in retry loop with exponential backoff + jitter
+- **Semantic Cache** — Cosine-similarity cache with pluggable embeddings
+- **Streaming Support** — `executeStream()` with initial retry + cache replay
+- **100% Backward Compatible** — v1.x through v4.x code works without changes
+
+## Installation
+
+```bash
+npm install @splashcodex/api-key-manager
+```
+
+### 🚀 Auto-Scaffold (New!)
+The fastest way to get started is to run the `init` command in your project directory:
+```bash
+npx @splashcodex/api-key-manager init
+```
+This will automatically create a `.env` template and a `demo.ts` file showing the Gemini Preset in action.
+
+## Quick Start (v5 Presets)
+
+The fastest way to get started in any CodeDex repository.
+
+### Gemini Preset
+Reads `GOOGLE_GEMINI_API_KEY` or `GEMINI_API_KEY` from environment.
+
+```typescript
+import { GeminiManager } from '@splashcodex/api-key-manager/presets/gemini';
+
+const result = GeminiManager.getInstance();
+if (!result.success) throw result.error;
+
+const gemini = result.data;
+const response = await gemini.execute(async (key) => {
+    // result.data is the underlying ApiKeyManager
+    return await callGemini(key, "Hello!");
+});
+```
+
+### Centralized API Gateway (New!)
+
+Run a standalone proxy server that acts as a single point of entry for all your microservices or repositories. It centralizes key management, circuit breaking, and rate limiting across applications.
+
+1. Install global/local and export your keys:
+```bash
+export GOOGLE_GEMINI_API_KEY="AIzaSy...1,AIzaSy...2"
+```
+
+2. Start the gateway:
+```bash
+npm run gateway
+# Server runs on http://localhost:9000
+```
+
+3. Call the proxy from ANY language without managing keys in the client app:
+```bash
+curl -X POST http://localhost:9000/v1/generate \
+  -H "Content-Type: application/json" \
+  -d '{"provider": "gemini", "prompt": "Hello!"}'
+```
+Route supports both `/v1/generate` (Standard JSON) and `/v1/stream` (Server-Sent Events). Monitoring available at `/v1/health` and `/v1/providers`.
+
+---
+
+### Multi-Provider Vault
+
+Manage ALL your provider keys across your system from one pool.Perfect for gateways or complex bots handling multiple models.
+
+```typescript
+import { MultiManager } from '@splashcodex/api-key-manager/presets/multi';
+
+const vault = MultiManager.getInstance({
+    providers: {
+        gemini: { envKeys: ['GOOGLE_GEMINI_API_KEY'] },
+        openai: { envKeys: ['OPENAI_API_KEY'] }
+    }
+}).data!;
+
+// Route by provider
+const res = await vault.execute(fn, { provider: 'gemini' });
+```
+
+---
+
+## v5.0 — Architecture & Persistence
+
+### Built-in Persistence
+State (cooling down keys, dead keys) now survives application restarts by default.
+
+```typescript
+import { FileStorage } from '@splashcodex/api-key-manager/persistence/file';
+
+const manager = new ApiKeyManager(keys, {
+    storage: new FileStorage({
+        filePath: './api_state.json'
+    })
+});
+```
+
+### Subpath Imports
+To keep your bundles small, you can import only what you need:
+
+```typescript
+import { GeminiManager } from '@splashcodex/api-key-manager/presets/gemini';
+import { FileStorage } from '@splashcodex/api-key-manager/persistence/file';
+```
+
+---
+
+## v4.0 — Semantic Cache
+
+Automatically cache API responses by semantic similarity.
+
+```typescript
+const manager = new ApiKeyManager(['key1', 'key2'], {
+  semanticCache: {
+    threshold: 0.92,
+    getEmbedding: async (text) => await myModel.embed(text)
+  }
+});
+
+// Cache HIT if prompt is semantically similar
+const r1 = await manager.execute(apiFn, { prompt: 'What is the weather?' });
+const r2 = await manager.execute(apiFn, { prompt: 'How is the weather today?' });
+```
+
+### v4.1 — Streaming Support
+Real-time response handling with the same resilience as `execute()`.
+
+```typescript
+const stream = await manager.executeStream(async (key) => {
+    return await gemini.generateContentStream({ prompt: "..." });
+}, { prompt: "..." });
+
+for await (const chunk of stream) {
+    console.log(chunk.text());
+}
+```
+
+---
+
+## execute() Wrapper
+
+Wraps the entire lifecycle into one method:
+
+```typescript
+const result = await manager.execute(
+  async (key, signal) => {
+    const res = await fetch(url, { headers: { 'x-api-key': key }, signal });
+    return res.json();
+  },
+  { maxRetries: 3, timeoutMs: 10000 }
+);
+```
+
+## API Reference
+
+### Presets
+
+| Class | Env Vars | Description |
+|-------|----------|-------------|
+| `GeminiManager` | `GOOGLE_GEMINI_API_KEY`, `GEMINI_API_KEY` | Gemini-optimized singleton |
+| `OpenAIManager` | `OPENAI_API_KEY` | OpenAI-optimized singleton |
+| `MultiManager` | Custom | Vault for multiple provider pools |
+
+### Persistence
+
+| Class | Description |
+|-------|-------------|
+| `FileStorage` | Persists to a JSON file (recommended for servers) |
+| `MemoryStorage` | In-memory only (best for serverless/short-lived) |
+
+### Core Methods
+
+| Method | Description |
+|--------|-------------|
+| `execute(fn, opts)` | Standard wrapper |
+| `executeStream(fn, opts)` | Streaming wrapper |
+| `getStats()` | Get pool health |
+| `getKey()` | Manual key rotation |
+| `markFailed(key, err)` | Manual failure reporting |
+
+## License
+
+ISC

package/bin/cli.js

@@ -1,50 +1,180 @@
-#!/usr/bin/env node
-const fs = require('fs');
-const path = require('path');
-
-const args = process.argv.slice(2);
-const command = args[0];
-
-function printDocs() {
-    console.log(`\x1b[92m🌟 @splashcodex/api-key-manager v5.0\x1b[0m`);
-    console.log(`\x1b[96m📚 Documentation: https://www.npmjs.com/package/@splashcodex/ApiKeyManager\x1b[0m\n`);
-    console.log(`\x1b[93m🚀 Commands:\x1b[0m`);
-    console.log(`   npx @splashcodex/api-key-manager init   \x1b[90m# Scaffold a demo project in the current directory\x1b[0m`);
-    console.log(`\n\x1b[95m💡 Tip: Need help? Run init to see it in action!\x1b[0m\n`);
-}
-
-function initProject() {
-    const cwd = process.cwd();
-    const envPath = path.join(cwd, '.env');
-    const demoPath = path.join(cwd, 'demo.ts');
-
-    console.log(`\n\x1b[96m🚀 Initializing @splashcodex/api-key-manager environment...\x1b[0m\n`);
-
-    // Create .env
-    if (!fs.existsSync(envPath)) {
-        fs.writeFileSync(envPath, `GOOGLE_GEMINI_API_KEY="your_api_key_1,your_api_key_2"\nOPENAI_API_KEY="sk-..."\n`);
-        console.log(`\x1b[92m[✔] Created .env file\x1b[0m`);
-    } else {
-        console.log(`\x1b[90m[-] .env already exists. Remember to add GOOGLE_GEMINI_API_KEY!\x1b[0m`);
-    }
-
-    // Create demo.ts
-    if (!fs.existsSync(demoPath)) {
-        const tsCode = `import 'dotenv/config';\nimport { GeminiManager } from '@splashcodex/api-key-manager/presets/gemini';\n\nasync function main() {\n    console.log("Initialize GeminiManager...");\n    // Automatically parse GOOGLE_GEMINI_API_KEY from env\n    const result = GeminiManager.getInstance();\n    if (!result.success) {\n        console.error("Failed to initialize:", result.error);\n        return;\n    }\n    \n    const gemini = result.data;\n    \n    console.log("Executing resilient request...");\n    // Automatically handles key rotation and 429 quota limits\n    try {\n        const response = await gemini.execute(async (key) => {\n            console.log(\`[Network] Sending request with key: \${key.substring(0, 8)}...\`);\n            // Replace with actual fetch: await fetch(..., { headers: { 'x-goog-api-key': key } })\n            return "Success: Simulated API Response!";\n        });\n        console.log("Result:", response);\n    } catch (e) {\n        console.error("All keys exhausted or network failed.", e.message);\n    }\n}\n\nmain();\n`;
-        fs.writeFileSync(demoPath, tsCode);
-        console.log(`\x1b[92m[✔] Created demo.ts\x1b[0m`);
-    } else {
-        console.log(`\x1b[90m[-] demo.ts already exists.\x1b[0m`);
-    }
-
-    console.log(`\n\x1b[93m🎉 Setup Complete!\x1b[0m`);
-    console.log(`To run the demo:`);
-    console.log(`\x1b[36m   npm install dotenv\x1b[0m`);
-    console.log(`\x1b[36m   npx ts-node demo.ts\x1b[0m\n`);
-}
-
-if (command === 'init') {
-    initProject();
-} else {
-    printDocs();
-}
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const ENV_DIR = path.join(os.homedir(), 'codedex', 'env');
+
+function printDocs() {
+    console.log(`\x1b[92m@splashcodex/api-key-manager v5.1\x1b[0m`);
+    console.log(`\x1b[96mDocs: https://www.npmjs.com/package/@splashcodex/ApiKeyManager\x1b[0m\n`);
+    console.log(`\x1b[93mCommands:\x1b[0m`);
+    console.log(`   npx @splashcodex/api-key-manager init    \x1b[90m# Scaffold demo + central env directory\x1b[0m`);
+    console.log(`   npx @splashcodex/api-key-manager setup   \x1b[90m# Create ~/codedex/env/ with template files\x1b[0m`);
+    console.log(`   npx @splashcodex/api-key-manager status  \x1b[90m# Show which env files are loaded\x1b[0m`);
+    console.log('');
+}
+
+function setupEnvDir() {
+    console.log(`\n\x1b[96mSetting up centralized env directory...\x1b[0m\n`);
+
+    if (!fs.existsSync(ENV_DIR)) {
+        fs.mkdirSync(ENV_DIR, { recursive: true });
+        console.log(`\x1b[92m[+] Created ${ENV_DIR}\x1b[0m`);
+    } else {
+        console.log(`\x1b[90m[-] ${ENV_DIR} already exists\x1b[0m`);
+    }
+
+    const templates = {
+        'common.env': [
+            '# Common environment variables shared across all projects',
+            '# DATABASE_URL="postgresql://user:pass@localhost:5432/mydb"',
+            '# REDIS_URL="redis://localhost:6379"',
+            '# SUPABASE_URL="https://your-project.supabase.co"',
+            '# SUPABASE_ANON_KEY="your-anon-key"',
+            '',
+        ].join('\n'),
+        'llm.env': [
+            '# LLM API keys — supports comma-separated or JSON arrays',
+            '# GOOGLE_GEMINI_API_KEY="key1,key2,key3"',
+            '# OPENAI_API_KEY="sk-..."',
+            '# ANTHROPIC_API_KEY="sk-ant-..."',
+            '',
+        ].join('\n'),
+        'stripe.env': [
+            '# Stripe payment keys',
+            '# STRIPE_SECRET_KEY="sk_test_..."',
+            '# STRIPE_WEBHOOK_SECRET="whsec_..."',
+            '',
+        ].join('\n'),
+    };
+
+    for (const [name, content] of Object.entries(templates)) {
+        const filePath = path.join(ENV_DIR, name);
+        if (!fs.existsSync(filePath)) {
+            fs.writeFileSync(filePath, content);
+            console.log(`\x1b[92m[+] Created ${name}\x1b[0m`);
+        } else {
+            console.log(`\x1b[90m[-] ${name} already exists\x1b[0m`);
+        }
+    }
+
+    console.log(`\n\x1b[93mNext steps:\x1b[0m`);
+    console.log(`  1. Add your real keys to the files in ${ENV_DIR}`);
+    console.log(`  2. Back up the folder to Google Drive for portability`);
+    console.log(`  3. In your projects, add at the entry point:`);
+    console.log(`\x1b[36m     import { loadCentralEnv } from '@splashcodex/api-key-manager/env';\x1b[0m`);
+    console.log(`\x1b[36m     loadCentralEnv();\x1b[0m\n`);
+}
+
+function showStatus() {
+    console.log(`\n\x1b[96mCentralized env status\x1b[0m\n`);
+    console.log(`  Directory: ${ENV_DIR}`);
+
+    if (!fs.existsSync(ENV_DIR)) {
+        console.log(`  \x1b[31mNot found.\x1b[0m Run: npx @splashcodex/api-key-manager setup\n`);
+        return;
+    }
+
+    const files = fs.readdirSync(ENV_DIR).filter(f => f.endsWith('.env')).sort();
+    if (files.length === 0) {
+        console.log(`  \x1b[33mNo .env files found.\x1b[0m\n`);
+        return;
+    }
+
+    let totalVars = 0;
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(ENV_DIR, file), 'utf-8');
+        const vars = content.split('\n')
+            .filter(l => l.trim() && !l.trim().startsWith('#'))
+            .filter(l => l.includes('='));
+        totalVars += vars.length;
+
+        const icon = vars.length > 0 ? '\x1b[92m' : '\x1b[90m';
+        console.log(`  ${icon}${file}\x1b[0m — ${vars.length} variable(s)`);
+        for (const v of vars) {
+            const key = v.split('=')[0].trim();
+            console.log(`    \x1b[90m${key}\x1b[0m`);
+        }
+    }
+
+    console.log(`\n  Total: ${files.length} file(s), ${totalVars} variable(s)\n`);
+}
+
+function initProject() {
+    const cwd = process.cwd();
+    const demoPath = path.join(cwd, 'demo.ts');
+
+    console.log(`\n\x1b[96mInitializing @splashcodex/api-key-manager...\x1b[0m\n`);
+
+    // Ensure central env directory exists
+    setupEnvDir();
+
+    // Create demo.ts
+    if (!fs.existsSync(demoPath)) {
+        const tsCode = `/**
+ * Demo: @splashcodex/api-key-manager v5.1
+ *
+ * Shows the two-layer pattern:
+ *   Layer 1: loadCentralEnv() loads keys from ~/codedex/env/
+ *   Layer 2: GeminiManager handles rotation, retries, circuit breaking
+ */
+import { loadCentralEnv } from '@splashcodex/api-key-manager/env';
+import { GeminiManager } from '@splashcodex/api-key-manager/presets/gemini';
+
+// Layer 1: Load centralized environment
+const envResult = loadCentralEnv();
+console.log(\`Loaded \${envResult.varsSet} env vars from \${envResult.filesLoaded.length} files\`);
+
+async function main() {
+    // Layer 2: Initialize key manager (reads from process.env)
+    const result = GeminiManager.getInstance();
+    if (!result.success) {
+        console.error("Failed:", result.error.message);
+        console.error("Add your Gemini key to ~/codedex/env/llm.env");
+        return;
+    }
+
+    const gemini = result.data;
+    console.log(\`GeminiManager ready: \${gemini.getKeyCount()} key(s)\`);
+
+    try {
+        const response = await gemini.execute(async (key) => {
+            console.log(\`Using key: \${key.substring(0, 8)}...\`);
+            // Replace with actual API call
+            return "Simulated API Response";
+        }, { maxRetries: 3, timeoutMs: 30000 });
+        console.log("Result:", response);
+    } catch (e: any) {
+        console.error("Failed:", e.message);
+    }
+}
+
+main();
+`;
+        fs.writeFileSync(demoPath, tsCode);
+        console.log(`\x1b[92m[+] Created demo.ts\x1b[0m`);
+    } else {
+        console.log(`\x1b[90m[-] demo.ts already exists\x1b[0m`);
+    }
+
+    console.log(`\n\x1b[93mTo run the demo:\x1b[0m`);
+    console.log(`\x1b[36m   npx ts-node demo.ts\x1b[0m\n`);
+}
+
+switch (command) {
+    case 'init':
+        initProject();
+        break;
+    case 'setup':
+        setupEnvDir();
+        break;
+    case 'status':
+        showStatus();
+        break;
+    default:
+        printDocs();
+}

package/dist/env/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Centralized Environment Loader
+ * @module env
+ */
+export { loadCentralEnv, getCentralEnvVar, getDefaultEnvDir, } from './loader';
+export type { LoadCentralEnvOptions, LoadResult, } from './loader';

package/dist/env/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultEnvDir = exports.getCentralEnvVar = exports.loadCentralEnv = void 0;
+/**
+ * Centralized Environment Loader
+ * @module env
+ */
+var loader_1 = require("./loader");
+Object.defineProperty(exports, "loadCentralEnv", { enumerable: true, get: function () { return loader_1.loadCentralEnv; } });
+Object.defineProperty(exports, "getCentralEnvVar", { enumerable: true, get: function () { return loader_1.getCentralEnvVar; } });
+Object.defineProperty(exports, "getDefaultEnvDir", { enumerable: true, get: function () { return loader_1.getDefaultEnvDir; } });
+//# sourceMappingURL=index.js.map

package/dist/env/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/env/index.ts"],"names":[],"mappings":";;;AAAA;;;GAGG;AACH,mCAIkB;AAHd,wGAAA,cAAc,OAAA;AACd,0GAAA,gBAAgB,OAAA;AAChB,0GAAA,gBAAgB,OAAA"}