@adriangalilea/utils 0.16.1 → 0.16.2

package/dist/platform/kev.js

@@ -33,11 +33,11 @@
  *   KEV.debug = true                                       // Shows lookup chain
  *   KEV.export("backup.env")                              // Includes # from: comments
  */
-import { runtime } from '../runtime.js';
-import { panic } from '../offensive.js';
-import { file } from './file.js';
-import { path } from './path.js';
-import { findProjectRoot, findMonorepoRoot } from './project.js';
+import { panic } from "../offensive.js";
+import { runtime } from "../runtime.js";
+import { file } from "./file.js";
+import { path } from "./path.js";
+import { findMonorepoRoot, findProjectRoot } from "./project.js";
 class SourceOps {
     kev;
     constructor(kev) {
@@ -59,7 +59,7 @@ class SourceOps {
      * Remove specific sources
      */
     remove(...sources) {
-        this.kev.sources = this.kev.sources.filter(s => !sources.includes(s));
+        this.kev.sources = this.kev.sources.filter((s) => !sources.includes(s));
     }
     /**
      * List current sources
@@ -76,7 +76,7 @@ class SourceOps {
 }
 export class KevOps {
     memory = new Map();
-    sources = ['os', '.env'];
+    sources = ["os", ".env"];
     source;
     debug = false;
     constructor() {
@@ -87,64 +87,64 @@ export class KevOps {
         // Check for monorepo root first (turborepo)
         const monorepoRoot = findMonorepoRoot();
         if (monorepoRoot) {
-            const monorepoEnv = path.join(monorepoRoot, '.env');
+            const monorepoEnv = path.join(monorepoRoot, ".env");
             this.sources.push(monorepoEnv);
             if (this.debug) {
-                console.log('KEV: Auto-discovered monorepo root:', monorepoRoot);
-                console.log('KEV: Added monorepo .env to sources:', monorepoEnv);
+                console.log("KEV: Auto-discovered monorepo root:", monorepoRoot);
+                console.log("KEV: Added monorepo .env to sources:", monorepoEnv);
             }
         }
         // Then check for project root
         const projectRoot = findProjectRoot();
         if (projectRoot) {
-            const projectEnv = path.join(projectRoot, '.env');
+            const projectEnv = path.join(projectRoot, ".env");
             // Only add if it's different from monorepo env
-            if (!monorepoRoot || projectEnv !== path.join(monorepoRoot, '.env')) {
+            if (!monorepoRoot || projectEnv !== path.join(monorepoRoot, ".env")) {
                 this.sources.push(projectEnv);
                 if (this.debug) {
-                    console.log('KEV: Auto-discovered project root:', projectRoot);
-                    console.log('KEV: Added project .env to sources:', projectEnv);
+                    console.log("KEV: Auto-discovered project root:", projectRoot);
+                    console.log("KEV: Added project .env to sources:", projectEnv);
                 }
             }
         }
         if (this.debug) {
             if (!monorepoRoot && !projectRoot) {
-                console.log('KEV: No project or monorepo root found, using standard sources:', this.sources);
+                console.log("KEV: No project or monorepo root found, using standard sources:", this.sources);
             }
             else {
-                console.log('KEV: Default sources:', this.sources);
+                console.log("KEV: Default sources:", this.sources);
             }
         }
     }
     parseKey(key) {
-        if (key.startsWith(':')) {
-            panic('invalid key format - starts with colon:', key);
+        if (key.startsWith(":")) {
+            panic("invalid key format - starts with colon:", key);
         }
-        if (key.includes('::')) {
-            panic('invalid key format - double colon:', key);
+        if (key.includes("::")) {
+            panic("invalid key format - double colon:", key);
         }
-        const parts = key.split(':', 2);
+        const parts = key.split(":", 2);
         if (parts.length === 2) {
-            if (parts[0] === '' || parts[1] === '') {
-                panic('invalid key format - empty namespace or key:', key);
+            if (parts[0] === "" || parts[1] === "") {
+                panic("invalid key format - empty namespace or key:", key);
             }
             return [parts[0], parts[1]];
         }
-        return ['', key];
+        return ["", key];
     }
     /**
      * Get environment variable with optional default.
      */
     get(key, defaultValue) {
         const [namespace, realKey] = this.parseKey(key);
-        const debug = this.debug && key !== 'LOG_LEVEL';
+        const debug = this.debug && key !== "LOG_LEVEL";
         if (debug) {
             console.log(`KEV: Looking for ${key}`);
         }
         // Namespaced - direct access
         if (namespace) {
             const val = this.getFromNamespace(namespace, realKey);
-            if (val !== '') {
+            if (val !== "") {
                 if (debug) {
                     console.log(`  ✓ ${namespace}: found ${val}`);
                 }
@@ -159,7 +159,7 @@ export class KevOps {
                 }
                 return defaultValue;
             }
-            return '';
+            return "";
         }
         // Unnamespaced - check memory first
         const entry = this.memory.get(realKey);
@@ -170,17 +170,17 @@ export class KevOps {
             return entry.value;
         }
         if (debug) {
-            console.log('  ✗ memory: not found');
+            console.log("  ✗ memory: not found");
         }
         // Search through sources
         for (const source of this.sources) {
             const val = this.getFromNamespace(source, realKey);
-            if (val !== '') {
+            if (val !== "") {
                 if (debug) {
                     console.log(`  ✓ ${source}: found ${val} (caching)`);
                 }
                 // Cache in memory for next time with source info
-                const absoluteSource = source !== 'os' && source !== 'default' && source !== 'set'
+                const absoluteSource = source !== "os" && source !== "default" && source !== "set"
                     ? path.absolute(source)
                     : source;
                 this.memory.set(realKey, { value: val, source: absoluteSource });
@@ -195,21 +195,21 @@ export class KevOps {
             if (debug) {
                 console.log(`  → using default: ${defaultValue} (caching)`);
             }
-            this.memory.set(realKey, { value: defaultValue, source: 'default' });
+            this.memory.set(realKey, { value: defaultValue, source: "default" });
             return defaultValue;
         }
         if (debug) {
-            console.log('  → not found, returning empty');
+            console.log("  → not found, returning empty");
         }
-        return '';
+        return "";
     }
     /**
      * Get environment variable or panic if not found
      */
     mustGet(key) {
         const val = this.get(key);
-        if (val === '') {
-            panic('required key not found:', key);
+        if (val === "") {
+            panic("required key not found:", key);
         }
         return val;
     }
@@ -218,14 +218,14 @@ export class KevOps {
      */
     sourceOf(key) {
         const entry = this.memory.get(key);
-        return entry ? entry.source : '';
+        return entry ? entry.source : "";
     }
     /**
      * Get both value and its source
      */
     getWithSource(key, defaultValue) {
         const value = this.get(key, defaultValue);
-        if (value !== '') {
+        if (value !== "") {
             let source = this.sourceOf(key);
             // If not in cache but has value, it might be a namespaced get
             if (!source) {
@@ -236,33 +236,33 @@ export class KevOps {
             }
             return [value, source];
         }
-        return ['', ''];
+        return ["", ""];
     }
     getFromNamespace(namespace, key) {
         switch (namespace) {
-            case 'os':
-                return runtime.env(key) || '';
+            case "os":
+                return runtime.env(key) || "";
             default:
                 // File namespace (.env, .env.local, etc)
-                if (namespace.startsWith('.') || namespace.includes('/')) {
+                if (namespace.startsWith(".") || namespace.includes("/")) {
                     return this.getFromFile(namespace, key);
                 }
         }
-        return '';
+        return "";
     }
     getFromFile(filePath, key) {
         if (!file.exists(filePath)) {
-            return '';
+            return "";
         }
         try {
             const content = file.readText(filePath);
-            const lines = content.split('\n');
+            const lines = content.split("\n");
             for (const line of lines) {
                 const trimmed = line.trim();
-                if (trimmed === '' || trimmed.startsWith('#')) {
+                if (trimmed === "" || trimmed.startsWith("#")) {
                     continue;
                 }
-                const parts = trimmed.split('=', 2);
+                const parts = trimmed.split("=", 2);
                 if (parts.length === 2) {
                     const fileKey = parts[0].trim();
                     if (fileKey === key) {
@@ -280,7 +280,7 @@ export class KevOps {
         catch {
             // File read error
         }
-        return '';
+        return "";
     }
     /**
      * Set environment variable
@@ -293,16 +293,16 @@ export class KevOps {
             return;
         }
         // Unnamespaced - memory only
-        this.memory.set(realKey, { value, source: 'set' });
+        this.memory.set(realKey, { value, source: "set" });
     }
     setToNamespace(namespace, key, value) {
         switch (namespace) {
-            case 'os':
+            case "os":
                 runtime.setEnv(key, value);
                 break;
             default:
                 // File namespace - update or append to file
-                if (namespace.startsWith('.') || namespace.includes('/')) {
+                if (namespace.startsWith(".") || namespace.includes("/")) {
                     this.setToFile(namespace, key, value);
                 }
         }
@@ -312,21 +312,23 @@ export class KevOps {
         let found = false;
         if (file.exists(path)) {
             const content = file.readText(path);
-            const existingLines = content.split('\n');
+            const existingLines = content.split("\n");
             for (const line of existingLines) {
                 const trimmed = line.trim();
                 // Keep empty lines and comments
-                if (trimmed === '' || trimmed.startsWith('#')) {
+                if (trimmed === "" || trimmed.startsWith("#")) {
                     lines.push(line);
                     continue;
                 }
                 // Check if this is the key we're updating
-                const parts = trimmed.split('=', 2);
+                const parts = trimmed.split("=", 2);
                 if (parts.length >= 1) {
                     const fileKey = parts[0].trim();
                     if (fileKey === key) {
                         // Update existing key
-                        const quotedValue = value.includes(' ') || value.includes('\t') || value.includes('\n')
+                        const quotedValue = value.includes(" ") ||
+                            value.includes("\t") ||
+                            value.includes("\n")
                             ? `"${value}"`
                             : value;
                         lines.push(`${key}=${quotedValue}`);
@@ -343,13 +345,13 @@ export class KevOps {
         }
         // If key wasn't found, append it
         if (!found) {
-            const quotedValue = value.includes(' ') || value.includes('\t') || value.includes('\n')
+            const quotedValue = value.includes(" ") || value.includes("\t") || value.includes("\n")
                 ? `"${value}"`
                 : value;
             lines.push(`${key}=${quotedValue}`);
         }
         // Write back
-        file.write(path, lines.join('\n'));
+        file.write(path, lines.join("\n"));
     }
     /**
      * Check if key exists
@@ -374,12 +376,12 @@ export class KevOps {
     }
     hasInNamespace(namespace, key) {
         switch (namespace) {
-            case 'os':
+            case "os":
                 return runtime.hasEnv(key);
             default:
                 // File namespace
-                if (namespace.startsWith('.') || namespace.includes('/')) {
-                    return this.getFromFile(namespace, key) !== '';
+                if (namespace.startsWith(".") || namespace.includes("/")) {
+                    return this.getFromFile(namespace, key) !== "";
                 }
         }
         return false;
@@ -387,7 +389,7 @@ export class KevOps {
     /**
      * Get all keys matching pattern
      */
-    keys(pattern = '*') {
+    keys(pattern = "*") {
         const seen = new Set();
         const result = [];
         const patterns = Array.isArray(pattern) ? pattern : [pattern];
@@ -433,16 +435,16 @@ export class KevOps {
     getNamespaceData(namespace, pattern, keysOnly) {
         const result = {};
         switch (namespace) {
-            case 'os':
+            case "os":
                 for (const [key, value] of Object.entries(runtime.allEnv())) {
                     if (this.matchPattern(key, pattern)) {
-                        result[key] = keysOnly ? '' : value || '';
+                        result[key] = keysOnly ? "" : value || "";
                     }
                 }
                 break;
             default:
                 // File namespace
-                if (namespace.startsWith('.') || namespace.includes('/')) {
+                if (namespace.startsWith(".") || namespace.includes("/")) {
                     this.parseEnvFile(namespace, pattern, result, keysOnly);
                 }
         }
@@ -454,18 +456,18 @@ export class KevOps {
         }
         try {
             const content = file.readText(path);
-            const lines = content.split('\n');
+            const lines = content.split("\n");
             for (const line of lines) {
                 const trimmed = line.trim();
-                if (trimmed === '' || trimmed.startsWith('#')) {
+                if (trimmed === "" || trimmed.startsWith("#")) {
                     continue;
                 }
-                const parts = trimmed.split('=', 2);
+                const parts = trimmed.split("=", 2);
                 if (parts.length >= 1) {
                     const key = parts[0].trim();
                     if (this.matchPattern(key, pattern)) {
                         if (keysOnly) {
-                            result[key] = '';
+                            result[key] = "";
                         }
                         else if (parts.length === 2) {
                             let value = parts[1].trim();
@@ -485,18 +487,18 @@ export class KevOps {
         }
     }
     matchPattern(key, pattern) {
-        if (pattern === '*')
+        if (pattern === "*")
             return true;
-        if (pattern.endsWith('*')) {
+        if (pattern.endsWith("*")) {
             const prefix = pattern.slice(0, -1);
             return key.startsWith(prefix);
         }
-        if (pattern.startsWith('*')) {
+        if (pattern.startsWith("*")) {
             const suffix = pattern.slice(1);
             return key.endsWith(suffix);
         }
-        if (pattern.includes('*')) {
-            const parts = pattern.split('*');
+        if (pattern.includes("*")) {
+            const parts = pattern.split("*");
             if (parts.length === 2) {
                 return key.startsWith(parts[0]) && key.endsWith(parts[1]);
             }
@@ -508,7 +510,11 @@ export class KevOps {
      */
     all(pattern) {
         const result = {};
-        const patterns = pattern ? (Array.isArray(pattern) ? pattern : [pattern]) : [];
+        const patterns = pattern
+            ? Array.isArray(pattern)
+                ? pattern
+                : [pattern]
+            : [];
         if (patterns.length === 0) {
             // Default - return memory only with source info
             if (this.memory.size > 0) {
@@ -521,7 +527,7 @@ export class KevOps {
             return result;
         }
         // Check if any pattern has namespace
-        const hasNamespace = patterns.some(p => p.includes(':'));
+        const hasNamespace = patterns.some((p) => p.includes(":"));
         if (!hasNamespace) {
             // No namespaces - get from memory and all sources
             const memMatches = {};
@@ -539,7 +545,7 @@ export class KevOps {
             // Check all sources
             for (const source of this.sources) {
                 const sourceMatches = {};
-                const sourceVars = this.getAllFromNamespace(source, '*');
+                const sourceVars = this.getAllFromNamespace(source, "*");
                 for (const [key, val] of Object.entries(sourceVars)) {
                     for (const pat of patterns) {
                         if (this.matchPattern(key, pat)) {
@@ -555,7 +561,7 @@ export class KevOps {
             return result;
         }
         // Special case for *:*
-        if (patterns.length === 1 && patterns[0] === '*:*') {
+        if (patterns.length === 1 && patterns[0] === "*:*") {
             // Add memory
             if (this.memory.size > 0) {
                 const memCopy = {};
@@ -566,7 +572,7 @@ export class KevOps {
             }
             // Add all sources
             for (const source of this.sources) {
-                const sourceVars = this.getAllFromNamespace(source, '*');
+                const sourceVars = this.getAllFromNamespace(source, "*");
                 if (Object.keys(sourceVars).length > 0) {
                     result[source] = sourceVars;
                 }
@@ -598,8 +604,8 @@ export class KevOps {
     clear(...patterns) {
         // Only allow memory clearing for safety
         for (const pattern of patterns) {
-            if (pattern.includes(':')) {
-                panic('Clear() with namespace is dangerous! Use clearUnsafe() if you really need this.');
+            if (pattern.includes(":")) {
+                panic("Clear() with namespace is dangerous! Use clearUnsafe() if you really need this.");
             }
         }
         if (patterns.length === 0) {
@@ -628,17 +634,18 @@ export class KevOps {
                 continue;
             }
             switch (namespace) {
-                case 'os':
-                    if (keyPattern === '*') {
+                case "os": {
+                    if (keyPattern === "*") {
                         panic('clearUnsafe("os:*") would destroy system! This is never allowed.');
                     }
-                    const keys = this.keysFromNamespace('os', keyPattern);
+                    const keys = this.keysFromNamespace("os", keyPattern);
                     for (const key of keys) {
                         runtime.deleteEnv(key);
                     }
                     break;
+                }
                 default:
-                    panic('Clearing from files not yet implemented');
+                    panic("Clearing from files not yet implemented");
             }
         }
     }
@@ -651,11 +658,11 @@ export class KevOps {
             if (namespace) {
                 // Namespaced unset
                 switch (namespace) {
-                    case 'os':
+                    case "os":
                         runtime.deleteEnv(realKey);
                         break;
                     default:
-                        panic('Unsetting from files not yet implemented');
+                        panic("Unsetting from files not yet implemented");
                 }
             }
             else {
@@ -669,11 +676,11 @@ export class KevOps {
      */
     int(key, defaultValue) {
         const val = this.get(key);
-        if (val === '') {
+        if (val === "") {
             return defaultValue;
         }
         const i = parseInt(val, 10);
-        if (isNaN(i)) {
+        if (Number.isNaN(i)) {
             panic(`invalid int value for ${key}: ${val}`);
         }
         return i;
@@ -683,19 +690,19 @@ export class KevOps {
      */
     bool(key, defaultValue) {
         const val = this.get(key).toLowerCase();
-        if (val === '') {
+        if (val === "") {
             return defaultValue;
         }
         switch (val) {
-            case 'true':
-            case '1':
-            case 'yes':
-            case 'on':
+            case "true":
+            case "1":
+            case "yes":
+            case "on":
                 return true;
-            case 'false':
-            case '0':
-            case 'no':
-            case 'off':
+            case "false":
+            case "0":
+            case "no":
+            case "off":
                 return false;
             default:
                 panic(`invalid bool value for ${key}: ${val}`);
@@ -706,11 +713,11 @@ export class KevOps {
      */
     float(key, defaultValue) {
         const val = this.get(key);
-        if (val === '') {
+        if (val === "") {
             return defaultValue;
         }
         const f = parseFloat(val);
-        if (isNaN(f)) {
+        if (Number.isNaN(f)) {
             panic(`invalid float value for ${key}: ${val}`);
         }
         return f;
@@ -723,13 +730,13 @@ export class KevOps {
         for (const [key, entry] of this.memory) {
             let val = entry.value;
             // Escape values with spaces or special chars
-            if (val.includes(' ') || val.includes('\t') || val.includes('\n')) {
+            if (val.includes(" ") || val.includes("\t") || val.includes("\n")) {
                 val = `"${val}"`;
             }
             // Add comment with source info
             lines.push(`${key}=${val}  # from: ${entry.source}`);
         }
-        file.write(path, lines.join('\n'));
+        file.write(path, lines.join("\n"));
     }
     /**
      * Print all environment variables (masks sensitive keys)
@@ -741,15 +748,15 @@ export class KevOps {
                 let maskedVal = val;
                 // Mask sensitive values
                 const lower = key.toLowerCase();
-                if (lower.includes('key') ||
-                    lower.includes('secret') ||
-                    lower.includes('password') ||
-                    lower.includes('token')) {
+                if (lower.includes("key") ||
+                    lower.includes("secret") ||
+                    lower.includes("password") ||
+                    lower.includes("token")) {
                     if (val.length > 4) {
-                        maskedVal = val.slice(0, 4) + '****';
+                        maskedVal = `${val.slice(0, 4)}****`;
                     }
                     else {
-                        maskedVal = '****';
+                        maskedVal = "****";
                     }
                 }
                 console.log(`${namespace}:${key}=${maskedVal}`);