5.3.3

.gitea/workflows/default_nottags.yaml

@@ -0,0 +1,66 @@
+name: Default (not tags)
+
+on:
+  push:
+    tags-ignore:
+      - '**'
+
+env:
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Install pnpm and npmci
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+
+      - name: Run npm prepare
+        run: npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -0,0 +1,124 @@
+name: Default (tags)
+
+on:
+  push:
+    tags:
+      - '*'
+
+env:
+  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
+  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
+  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
+  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
+  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
+  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
+
+jobs:
+  security:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Audit production dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --prod
+        continue-on-error: true
+
+      - name: Audit development dependencies
+        run: |
+          npmci command npm config set registry https://registry.npmjs.org
+          npmci command pnpm audit --audit-level=high --dev
+        continue-on-error: true
+
+  test:
+    if: ${{ always() }}
+    needs: security
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Test stable
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm test
+
+      - name: Test build
+        run: |
+          npmci node install stable
+          npmci npm install
+          npmci npm build
+
+  release:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Release
+        run: |
+          npmci node install stable
+          npmci npm publish
+
+  metadata:
+    needs: test
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
+    runs-on: ubuntu-latest
+    container:
+      image: ${{ env.IMAGE }}
+    continue-on-error: true
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Prepare
+        run: |
+          pnpm install -g pnpm
+          pnpm install -g @ship.zone/npmci
+          npmci npm prepare
+
+      - name: Code quality
+        run: |
+          npmci command npm install -g typescript
+          npmci npm install
+
+      - name: Trigger
+        run: npmci trigger
+
+      - name: Build docs and upload artifacts
+        run: |
+          npmci node install stable
+          npmci npm install
+          pnpm install -g @git.zone/tsdoc
+          npmci command tsdoc
+        continue-on-error: true

.gitignore

@@ -1,4 +1,19 @@
-node_modules/
+.nogit/
+
+# artifacts
 coverage/
-pages/
 public/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_*/
+
+#------# custom

.gitlab-ci.yml

@@ -1,48 +0,0 @@
-image: hosttoday/ht-docker-node:npmts
-
-stages:
-- test
-- release
-- page
-
-testLEGACY:
-  stage: test
-  script:
-    - npmci test legacy
-  tags:
-    - docker
-
-testLTS:
-  stage: test
-  script:
-    - npmci test lts
-  tags:
-    - docker
-
-testSTABLE:
-  stage: test
-  script:
-    - npmci test stable
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci publish
-  only:
-    - tags
-  tags:
-    - docker
-
-pages:
-  image: hosttoday/ht-docker-node:npmpage
-  stage: page
-  script:
-    - npmci command npmpage --host gitlab
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-    - public

.serena/memories/coding_standards.md

@@ -0,0 +1,32 @@
+# Coding Standards for npmextra
+
+## Naming Conventions
+- **Interfaces**: Prefix with `I` (e.g., `IAppDataOptions`, `ITestOptions`)
+- **Types**: Prefix with `T` (e.g., `TKeyValueStore`)
+- **Filenames**: Always lowercase (e.g., `npmextra.classes.appdata.ts`)
+- **Module structure**: `npmextra.<type>.<name>.ts` pattern
+
+## Import/Export Patterns
+- Use ES module syntax (`import`/`export`)
+- Import all dependencies through `npmextra.plugins.ts`
+- Reference with full path: `plugins.moduleName.className()`
+- Export all public APIs through `index.ts`
+
+## TypeScript Patterns
+- Use generic types for flexibility (`<T = any>`)
+- Leverage TypeScript utility types from `@tsclass/tsclass`
+- Use async/await for asynchronous operations
+- Use Promises with smartpromise utilities
+
+## Testing Standards
+- Import expect from `@git.zone/tstest/tapbundle`
+- Test files end with `export default tap.start()`
+- Use descriptive test names with `tap.test()`
+- Test file naming: `test.*.ts` pattern
+
+## Code Quality
+- Make focused, goal-oriented changes
+- Preserve necessary complexity
+- Remove redundancy carefully
+- Keep async patterns where they add value
+- No comments unless explicitly requested

.serena/memories/project_overview.md

@@ -0,0 +1,30 @@
+# npmextra Project Overview
+
+## Purpose
+npmextra is a utility library that enhances npm with additional configuration and tool management capabilities. It provides a key-value store for project setups and centralized configuration management through npmextra.json files.
+
+## Tech Stack
+- TypeScript (ES modules)
+- Node.js
+- Dependencies:
+  - @push.rocks/qenv - Environment variable management
+  - @push.rocks/smartfile - File system operations
+  - @push.rocks/smartjson - JSON handling
+  - @push.rocks/smartlog - Logging
+  - @push.rocks/smartpath - Path utilities
+  - @push.rocks/smartpromise - Promise utilities
+  - @push.rocks/smartrx - Reactive programming
+  - @push.rocks/taskbuffer - Task management
+  - @tsclass/tsclass - TypeScript utilities
+
+## Main Components
+1. **Npmextra** - Main class for managing npmextra.json configurations
+2. **KeyValueStore** - Persistent key-value storage system
+3. **AppData** - Advanced data management with environment variable mapping
+
+## Project Structure
+- `ts/` - TypeScript source files
+- `test/` - Test files using @git.zone/tstest
+- `dist_ts/` - Compiled JavaScript output
+- `npmextra.json` - Project configuration
+- `package.json` - Node.js package configuration

.serena/memories/suggested_commands.md

@@ -0,0 +1,31 @@
+# Suggested Commands for npmextra Development
+
+## Build Commands
+- `pnpm run build` - Build the TypeScript project (uses tsbuild)
+- `pnpm test` - Run tests using tstest
+
+## Development Commands
+- `pnpm install` - Install dependencies
+- `pnpm install --save-dev <package>` - Add development dependencies  
+- `tsx <script>` - Run TypeScript files directly (tsx is globally available)
+
+## Git Commands
+- `git status` - Check current changes
+- `git add .` - Stage changes
+- `git commit -m "message"` - Commit changes (only when explicitly requested)
+- `git mv` - Move/rename files to preserve history
+
+## Testing
+- `pnpm test` - Run all tests
+- `tstest test/test.some.ts --verbose` - Run specific test file
+- Tests use @git.zone/tstest framework with tap-based structure
+
+## Type Checking
+- `pnpm run build` - Type check and build the project
+- `tsbuild check test/**/* --skiplibcheck` - Type check test files only
+
+## Directory Structure
+- Source code in `ts/` directory
+- Tests in `test/` directory  
+- Built output in `dist_ts/` directory
+- Temporary/debug files in `.nogit/` directory

.serena/project.yml

@@ -0,0 +1,68 @@
+# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
+#  * For C, use cpp
+#  * For JavaScript, use typescript
+# Special requirements:
+#  * csharp: Requires the presence of a .sln file in the project folder.
+language: typescript
+
+# whether to use the project's gitignore file to ignore files
+# Added on 2025-04-07
+ignore_all_files_in_gitignore: true
+# list of additional paths to ignore
+# same syntax as gitignore, so you can use * and **
+# Was previously called `ignored_dirs`, please update your config if you are using that.
+# Added (renamed) on 2025-04-07
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+
+# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
+# Below is the complete list of tools for convenience.
+# To make sure you have the latest list of tools, and to view their descriptions, 
+# execute `uv run scripts/print_tool_overview.py`.
+#
+#  * `activate_project`: Activates a project by name.
+#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
+#  * `create_text_file`: Creates/overwrites a file in the project directory.
+#  * `delete_lines`: Deletes a range of lines within a file.
+#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
+#  * `execute_shell_command`: Executes a shell command.
+#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
+#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
+#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file.
+#  * `initial_instructions`: Gets the initial instructions for the current project.
+#     Should only be used in settings where the system prompt cannot be set,
+#     e.g. in clients you have no control over, like Claude Desktop.
+#  * `insert_after_symbol`: Inserts content after the end of the definition of a given symbol.
+#  * `insert_at_line`: Inserts content at a given line in a file.
+#  * `insert_before_symbol`: Inserts content before the beginning of the definition of a given symbol.
+#  * `list_dir`: Lists files and directories in the given directory (optionally with recursion).
+#  * `list_memories`: Lists memories in Serena's project-specific memory store.
+#  * `onboarding`: Performs onboarding (identifying the project structure and essential tasks, e.g. for testing or building).
+#  * `prepare_for_new_conversation`: Provides instructions for preparing for a new conversation (in order to continue with the necessary context).
+#  * `read_file`: Reads a file within the project directory.
+#  * `read_memory`: Reads the memory with the given name from Serena's project-specific memory store.
+#  * `remove_project`: Removes a project from the Serena configuration.
+#  * `replace_lines`: Replaces a range of lines within a file with new content.
+#  * `replace_symbol_body`: Replaces the full definition of a symbol.
+#  * `restart_language_server`: Restarts the language server, may be necessary when edits not through Serena happen.
+#  * `search_for_pattern`: Performs a search for a pattern in the project.
+#  * `summarize_changes`: Provides instructions for summarizing the changes made to the codebase.
+#  * `switch_modes`: Activates modes by providing a list of their names
+#  * `think_about_collected_information`: Thinking tool for pondering the completeness of collected information.
+#  * `think_about_task_adherence`: Thinking tool for determining whether the agent is still on track with the current task.
+#  * `think_about_whether_you_are_done`: Thinking tool for determining whether the task is truly completed.
+#  * `write_memory`: Writes a named memory (for future reference) to Serena's project-specific memory store.
+excluded_tools: []
+
+# initial prompt for the project. It will always be given to the LLM upon activating the project
+# (contrary to the memories, which are loaded on demand).
+initial_prompt: ""
+
+project_name: "npmextra"

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "command": "npm test",
+      "name": "Run npm test",
+      "request": "launch",
+      "type": "node-terminal"
+    }
+  ]
+}

.vscode/settings.json

@@ -0,0 +1,26 @@
+{
+  "json.schemas": [
+    {
+      "fileMatch": ["/npmextra.json"],
+      "schema": {
+        "type": "object",
+        "properties": {
+          "npmci": {
+            "type": "object",
+            "description": "settings for npmci"
+          },
+          "gitzone": {
+            "type": "object",
+            "description": "settings for gitzone",
+            "properties": {
+              "projectType": {
+                "type": "string",
+                "enum": ["website", "element", "service", "npm", "wcc"]
+              }
+            }
+          }
+        }
+      }
+    }
+  ]
+}

README.md

@@ -1,47 +0,0 @@
-# npmextra
-do more with npm.
-
-npmextra is a hub for a series of js tools that help writing, documenting and maintaining npm modules.
-
-## Availabililty
-[![npm](https://push.rocks/assets/repo-button-npm.svg)](https://www.npmjs.com/package/npmextra)
-[![git](https://push.rocks/assets/repo-button-git.svg)](https://gitlab.com/pushrocks/npmextra)
-[![git](https://push.rocks/assets/repo-button-mirror.svg)](https://github.com/pushrocks/npmextra)
-[![docs](https://push.rocks/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/npmextra/)
-
-## Status for master
-[![build status](https://gitlab.com/pushrocks/npmextra/badges/master/build.svg)](https://gitlab.com/pushrocks/npmextra/commits/master)
-[![coverage report](https://gitlab.com/pushrocks/npmextra/badges/master/coverage.svg)](https://gitlab.com/pushrocks/npmextra/commits/master)
-[![Dependency Status](https://david-dm.org/pushrocks/npmextra.svg)](https://david-dm.org/pushrocks/npmextra)
-[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/npmextra/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/npmextra/master/dependencies/npm)
-[![bitHound Code](https://www.bithound.io/github/pushrocks/npmextra/badges/code.svg)](https://www.bithound.io/github/pushrocks/npmextra)
-[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-standard-brightgreen.svg)](http://standardjs.com/)
-
-## Usage
-The main purpose of npmextra is to configure different tools using one npmextra.json. This way complex setups avoid additional complexity caused by too many configuration files.
-
-npmextra.json
-```json
-{
-    "sometool": {
-        "defaultKey1": "awesomeValueFromConfig"
-    }
-}
-```
-
-```typescript
-import { Npmextra } from 'npmextra'
-
-let myNpmExtra = new Npmextra('my/path/to/cwd') // cwd argument is optional 
-mergedData = myNpmExtra.dataFor(
-    'sometool',
-    { // gets merged with whatever is in the configfile
-        defaultKey1: 'defaultValue1', // so this will get overwritten with "awesomeValueFromConfig"
-        defaultKey2: 'defaultValue2' // this one will pass through unaltered
-    }
-)
-```
-
-[![npm](https://push.rocks/assets/repo-header.svg)](https://push.rocks)

changelog.md

@@ -0,0 +1,147 @@
+# Changelog
+
+## 2025-08-16 - 5.3.3 - fix(appdata)
+Redact sensitive values in AppData logs and add redaction tests
+
+- Add redactSensitiveValue helper in AppData to mask secrets (API keys, tokens, passwords, JWTs, etc.) during logging.
+- Use redaction when logging raw and final mapping values in processMappingValue and nested key logging to avoid leaking sensitive data.
+- Improve log output for long or special values (JWT/base64 detection, length-aware previews) while preserving actual stored values.
+- Add test/test.redaction.ts to verify sensitive environment values are redacted in console output but still stored correctly in the kv store.
+- Add local config .claude/settings.local.json (editor/CI permissions/settings).
+
+## 2025-08-16 - 5.3.2 - fix(dependencies)
+Bump @push.rocks/qenv to ^6.1.3 and add local Claude settings
+
+- Bumped dependency @push.rocks/qenv from ^6.1.2 to ^6.1.3 in package.json
+- Added .claude/settings.local.json to provide local Claude permissions and tooling allowances for development/CI helpers
+
+## 2025-08-15 - 5.3.1 - fix(AppData/Conversion)
+Improve boolean conversion and mapping evaluation in AppData, ensuring falsy values (like false, 0, and empty strings) are correctly handled and logged. Also, reduce test timeout and add local permissions settings for development.
+
+- Enhanced toBoolean and evaluateMappingValue functions to properly preserve and log falsy values.
+- Added detailed logging for mapping spec processing and nested key evaluations.
+- Reduced test timeout in package.json for faster CI feedback.
+- Introduced .claude/settings.local.json with updated permissions for local development.
+
+## 2025-08-15 - 5.3.0 - feat(AppData)
+Refactor AppData class for declarative env mapping and enhanced static helpers
+
+- Introduced a singleton Qenv provider to optimize environment variable resolution.
+- Centralized type conversion logic with utility functions for boolean, JSON, base64, number, and string conversions.
+- Replaced complex switch statements with a composable, declarative mapping pipeline for processing envMapping.
+- Enhanced logging during AppData initialization to clearly report key processing and overwrite operations.
+- Added new static helper methods for environment variable access (valueAsBoolean, valueAsJson, valueAsBase64, valueAsString, valueAsNumber).
+- Fixed boolean conversion issues and ensured backward compatibility with the deprecated 'ephermal' option.
+
+## 2025-08-15 - 5.2.0 - feat(AppData)
+Major refactoring of AppData class for improved elegance and maintainability
+
+- **New Features:**
+  - Added static helper methods for direct environment variable access:
+    - `AppData.valueAsBoolean()` - Convert env vars to boolean
+    - `AppData.valueAsJson()` - Parse env vars as JSON
+    - `AppData.valueAsBase64()` - Decode base64 env vars
+    - `AppData.valueAsString()` - Get env vars as string
+    - `AppData.valueAsNumber()` - Parse env vars as number
+  - Enhanced logging for AppData initialization and key processing:
+    - Shows which storage type is being used (custom, ephemeral, auto-selected)
+    - Logs each key being processed with its spec type
+    - Reports success/failure for each key with type information
+    - Provides summary statistics of processed keys
+
+- **Architecture Improvements:**
+  - Replaced 100+ line switch statement with declarative pipeline architecture
+  - Introduced centralized type converters and transform registry
+  - Implemented composable transform pipeline: `parseMappingSpec()` → `resolveSource()` → `applyTransforms()`
+  - Added singleton Qenv provider to reduce allocations
+  - Reduced code complexity by ~70% while maintaining 100% backward compatibility
+
+- **Bug Fixes:**
+  - Fixed boolean conversion to properly handle both string and boolean inputs
+  - Added `ephemeral` option (correctly spelled) while maintaining backward compatibility with deprecated `ephermal`
+
+- **Performance:**
+  - Optimized environment variable resolution with shared Qenv instance
+  - Reduced object allocations in static helpers
+
+## 2025-08-15 - 5.1.4 - fix(AppData, dev dependencies, settings)
+Improve boolean conversion in AppData, update @types/node dependency, and add local settings file.
+
+- Fixed env var boolean conversion to properly handle non-string values in AppData.
+- Updated @types/node from ^20.14.5 to ^22 in package.json.
+- Added .claude/settings.local.json to configure project permissions locally.
+
+## 2025-08-15 - 5.1.3 - fix(appdata)
+Fix iteration over overwriteObject in AppData and update configuration for dependency and path handling
+
+- Replaced incorrect looping constructs in the AppData class to properly iterate over overwriteObject keys
+- Improved environment variable mapping and file path resolution in multiple TS modules
+- Updated dependency versions and adjusted git workflow configurations
+- Enhanced project configuration including TS config and build script adjustments
+
+## 2024-11-06 - 5.1.2 - fix(appdata)
+
+Fix iteration over overwriteObject in AppData class
+
+- Corrected the for loop from in to of inside the AppData class for iterating over overwriteObject keys.
+
+## 2024-11-05 - 5.1.1 - fix(AppData)
+
+Fix issue with overwrite object handling in AppData class
+
+- Corrected logic to handle cases when overwriteObject is undefined.
+
+## 2024-11-05 - 5.1.0 - feat(appdata)
+
+Add support for overwriting keys using the overwriteObject option in AppData
+
+- Introduced the overwriteObject option in IAppDataOptions to allow overwriting specific keys in the AppData class.
+
+## 2024-06-19 - 5.0.17 - 5.0.23 - Core Updates
+
+Routine maintenance and updates to the core components.
+
+- Multiple core updates and fixes improving stability
+
+## 2024-06-12 - 5.0.13 - 5.0.16 - Core Updates
+
+Maintenance focus on core systems with enhancements and problem resolutions.
+
+- Enhancements and updates in the core functionality
+
+## 2024-05-29 - 5.0.13 - Documentation Update
+
+Descriptive improvements aligned with current features.
+
+- Updated core description for better clarity in documentation
+
+## 2024-04-01 - 5.0.10 - Configuration Update
+
+Improved configuration management for build processes.
+
+- Updated `npmextra.json` to reflect changes in git repository management
+
+## 2024-02-12 - 5.0.0 - 5.0.9 - Major Core Enhancements
+
+A series of critical updates with resolved issues in the core components.
+
+- Introduction of new core features
+- Several core system updates
+
+## 2024-02-12 - 4.0.16 - Major Version Transition
+
+Migration to the new major version with impactful changes.
+
+- BREAKING CHANGE: Significant updates requiring attention for smooth transition
+
+## 2023-08-24 - 3.0.9 - 4.0.16 - Organization Updates
+
+Formatted updates with attention to organizational standards and practice.
+
+- SWITCH to a new organizational scheme
+
+## 2023-07-11 - 3.0.9 - Organizational Enhancement
+
+Shifts aligning with contemporary structuring and logistics.
+
+- Strategic realignment with organizational principles

dist/index.d.ts

@@ -1,2 +0,0 @@
-export * from './npmextra.classes.npmextra';
-export * from './npmextra.classes.keyvaluestore';

dist/index.js

@@ -1,7 +0,0 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-__export(require("./npmextra.classes.npmextra"));
-__export(require("./npmextra.classes.keyvaluestore"));
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O0FBRUEsaURBQTJDO0FBQzNDLHNEQUFnRCJ9

dist/npmextra.classes.keyvaluestore.d.ts

@@ -1,31 +0,0 @@
-export declare type keyValueStoreTypes = 'path' | 'gitProject' | 'customString';
-export declare class KeyValueStore {
-    type: string;
-    identity: string;
-    filePath: string;
-    constructor(typeArg: keyValueStoreTypes, identityStringArg?: string);
-    /**
-     * reads a keyValueFile from disk
-     */
-    read(): void;
-    /**
-     * writes a key value file to disk
-     */
-    write(): void;
-    /**
-     * wipes a key value store from disk
-     */
-    wipe(): void;
-    /**
-     * updates a value
-     */
-    update(): void;
-    /**
-     * computes the identity
-     */
-    private initIdentity(identityStringArg);
-    /**
-     * computes the filePath
-     */
-    private initFilePath();
-}

dist/npmextra.classes.keyvaluestore.js

@@ -1,55 +0,0 @@
-"use strict";
-const plugins = require("./npmextra.plugins");
-const paths = require("./npmextra.paths");
-class KeyValueStore {
-    constructor(typeArg, identityStringArg) {
-        // set kvStoreType
-        this.type = typeArg;
-        this.initIdentity(identityStringArg);
-        this.initFilePath();
-    }
-    /**
-     * reads a keyValueFile from disk
-     */
-    read() {
-    }
-    /**
-     * writes a key value file to disk
-     */
-    write() {
-    }
-    /**
-     * wipes a key value store from disk
-     */
-    wipe() {
-    }
-    /**
-     * updates a value
-     */
-    update() {
-    }
-    /**
-     * computes the identity
-     */
-    initIdentity(identityStringArg) {
-    }
-    /**
-     * computes the filePath
-     */
-    initFilePath() {
-        let baseDir;
-        if (this.type === 'customString') {
-            baseDir = paths.kvCusomDir;
-        }
-        else if (this.type === 'gitProject') {
-            baseDir = paths.kvGitDir;
-        }
-        else if (this.type === 'path') {
-            baseDir = paths.kvPathDir;
-        }
-        this.filePath = plugins.path.join(baseDir, this.identity + '.json');
-        plugins.smartfile.fs.ensureFileSync(this.filePath, '{}');
-    }
-}
-exports.KeyValueStore = KeyValueStore;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnBtZXh0cmEuY2xhc3Nlcy5rZXl2YWx1ZXN0b3JlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvbnBtZXh0cmEuY2xhc3Nlcy5rZXl2YWx1ZXN0b3JlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSw4Q0FBNkM7QUFDN0MsMENBQXlDO0FBS3pDO0lBSUksWUFBWSxPQUEyQixFQUFFLGlCQUEwQjtRQUMvRCxrQkFBa0I7UUFDbEIsSUFBSSxDQUFDLElBQUksR0FBRyxPQUFPLENBQUE7UUFDbkIsSUFBSSxDQUFDLFlBQVksQ0FBQyxpQkFBaUIsQ0FBQyxDQUFBO1FBQ3BDLElBQUksQ0FBQyxZQUFZLEVBQUUsQ0FBQTtJQUN2QixDQUFDO0lBRUQ7O09BRUc7SUFDSCxJQUFJO0lBRUosQ0FBQztJQUVEOztPQUVHO0lBQ0gsS0FBSztJQUVMLENBQUM7SUFFRDs7T0FFRztJQUNILElBQUk7SUFFSixDQUFDO0lBRUQ7O09BRUc7SUFDSCxNQUFNO0lBRU4sQ0FBQztJQUVEOztPQUVHO0lBQ0ssWUFBWSxDQUFDLGlCQUF5QjtJQUU5QyxDQUFDO0lBRUQ7O09BRUc7SUFDSyxZQUFZO1FBQ2hCLElBQUksT0FBZSxDQUFBO1FBQ25CLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssY0FBYyxDQUFDLENBQUMsQ0FBQztZQUMvQixPQUFPLEdBQUcsS0FBSyxDQUFDLFVBQVUsQ0FBQTtRQUM5QixDQUFDO1FBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssWUFBWSxDQUFDLENBQUMsQ0FBQztZQUNwQyxPQUFPLEdBQUcsS0FBSyxDQUFDLFFBQVEsQ0FBQTtRQUM1QixDQUFDO1FBQUMsSUFBSSxDQUFDLEVBQUUsQ0FBQyxDQUFDLElBQUksQ0FBQyxJQUFJLEtBQUssTUFBTSxDQUFDLENBQUMsQ0FBQztZQUM5QixPQUFPLEdBQUcsS0FBSyxDQUFDLFNBQVMsQ0FBQTtRQUM3QixDQUFDO1FBQ0QsSUFBSSxDQUFDLFFBQVEsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsSUFBSSxDQUFDLFFBQVEsR0FBRyxPQUFPLENBQUMsQ0FBQTtRQUNuRSxPQUFPLENBQUMsU0FBUyxDQUFDLEVBQUUsQ0FBQyxjQUFjLENBQUMsSUFBSSxDQUFDLFFBQVEsRUFBQyxJQUFJLENBQUMsQ0FBQTtJQUMzRCxDQUFDO0NBQ0o7QUE3REQsc0NBNkRDIn0=

dist/npmextra.classes.npmextra.d.ts

@@ -1,29 +0,0 @@
-/**
- * Npmextra class allows easy configuration of tools
- */
-export declare class Npmextra {
-    cwd: string;
-    lookupPath: string;
-    npmextraJsonExists: boolean;
-    npmextraJsonData: any;
-    /**
-     * creates instance of Npmextra
-     */
-    constructor(cwdArg?: string);
-    /**
-     * merges the supplied options with the ones from npmextra.json
-     */
-    dataFor<IToolConfig>(toolnameArg: string, defaultOptionsArg: any): IToolConfig;
-    /**
-     * checks if the JSON exists
-     */
-    private checkNpmextraJsonExists();
-    /**
-     * gets lookupPath
-     */
-    private checkLookupPath();
-    /**
-     * get npmextraJsonData
-     */
-    private checkNpmextraJsonData();
-}

dist/npmextra.classes.npmextra.js

@@ -1,67 +0,0 @@
-"use strict";
-const plugins = require("./npmextra.plugins");
-const paths = require("./npmextra.paths");
-/**
- * Npmextra class allows easy configuration of tools
- */
-class Npmextra {
-    /**
-     * creates instance of Npmextra
-     */
-    constructor(cwdArg) {
-        if (cwdArg) {
-            this.cwd = cwdArg;
-        }
-        else {
-            this.cwd = paths.cwd;
-        }
-        this.checkLookupPath();
-        this.checkNpmextraJsonExists();
-        this.checkNpmextraJsonData();
-    }
-    /**
-     * merges the supplied options with the ones from npmextra.json
-     */
-    dataFor(toolnameArg, defaultOptionsArg) {
-        let npmextraToolOptions;
-        if (this.npmextraJsonData[toolnameArg]) {
-            npmextraToolOptions = this.npmextraJsonData[toolnameArg];
-        }
-        else {
-            npmextraToolOptions = {};
-        }
-        let mergedOptions = plugins.lodash.merge({}, defaultOptionsArg, npmextraToolOptions);
-        return mergedOptions;
-    }
-    /**
-     * checks if the JSON exists
-     */
-    checkNpmextraJsonExists() {
-        this.npmextraJsonExists = plugins.smartfile.fs.fileExistsSync(this.lookupPath);
-    }
-    /**
-     * gets lookupPath
-     */
-    checkLookupPath() {
-        if (this.cwd) {
-            this.lookupPath = plugins.path.join(this.cwd, 'npmextra.json');
-        }
-        else {
-            this.lookupPath = paths.configFile;
-        }
-        ;
-    }
-    /**
-     * get npmextraJsonData
-     */
-    checkNpmextraJsonData() {
-        if (this.npmextraJsonExists) {
-            this.npmextraJsonData = plugins.smartfile.fs.toObjectSync(this.lookupPath);
-        }
-        else {
-            this.npmextraJsonData = {};
-        }
-    }
-}
-exports.Npmextra = Npmextra;
-//# sourceMappingURL=data:application/json;base64,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

dist/npmextra.paths.d.ts

@@ -1,7 +0,0 @@
-export declare let cwd: string;
-export declare let packageDir: string;
-export declare let kvBase: string;
-export declare let kvCusomDir: string;
-export declare let kvGitDir: string;
-export declare let kvPathDir: string;
-export declare let configFile: string;

dist/npmextra.paths.js

@@ -1,13 +0,0 @@
-"use strict";
-const plugins = require("./npmextra.plugins");
-// directories
-exports.cwd = process.cwd();
-exports.packageDir = plugins.path.join(__dirname, '../');
-// keyValueStore specific
-exports.kvBase = '~/.npmextra/kv';
-exports.kvCusomDir = plugins.path.join(exports.kvBase, 'custom');
-exports.kvGitDir = plugins.path.join(exports.kvBase, 'git');
-exports.kvPathDir = plugins.path.join(exports.kvBase, 'path');
-// files
-exports.configFile = plugins.path.join(exports.cwd, 'npmextra.json');
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnBtZXh0cmEucGF0aHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9ucG1leHRyYS5wYXRocy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsOENBQTZDO0FBRTdDLGNBQWM7QUFDSCxRQUFBLEdBQUcsR0FBRyxPQUFPLENBQUMsR0FBRyxFQUFFLENBQUE7QUFDbkIsUUFBQSxVQUFVLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFDLEtBQUssQ0FBQyxDQUFBO0FBRTFELHlCQUF5QjtBQUNkLFFBQUEsTUFBTSxHQUFHLGdCQUFnQixDQUFBO0FBQ3pCLFFBQUEsVUFBVSxHQUFHLE9BQU8sQ0FBQyxJQUFJLENBQUMsSUFBSSxDQUFDLGNBQU0sRUFBRSxRQUFRLENBQUMsQ0FBQTtBQUNoRCxRQUFBLFFBQVEsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxjQUFNLEVBQUUsS0FBSyxDQUFDLENBQUE7QUFDM0MsUUFBQSxTQUFTLEdBQUcsT0FBTyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsY0FBTSxFQUFFLE1BQU0sQ0FBQyxDQUFBO0FBRXhELFFBQVE7QUFDRyxRQUFBLFVBQVUsR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxXQUFHLEVBQUMsZUFBZSxDQUFDLENBQUEifQ==

dist/npmextra.plugins.d.ts

@@ -1,6 +0,0 @@
-import 'typings-global';
-export import beautylog = require('beautylog');
-export import lodash = require('lodash');
-export import path = require('path');
-export import smartfile = require('smartfile');
-export import q = require('q');

dist/npmextra.plugins.js

@@ -1,8 +0,0 @@
-"use strict";
-require("typings-global");
-exports.beautylog = require("beautylog");
-exports.lodash = require("lodash");
-exports.path = require("path");
-exports.smartfile = require("smartfile");
-exports.q = require("q");
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibnBtZXh0cmEucGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL25wbWV4dHJhLnBsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLDBCQUF1QjtBQUN2Qix5Q0FBOEM7QUFDOUMsbUNBQXdDO0FBQ3hDLCtCQUFvQztBQUNwQyx5Q0FBOEM7QUFDOUMseUJBQThCIn0=

npmextra.json

@@ -1 +1,42 @@
-{}
+{
+  "npmci": {
+    "globalNpmTools": [],
+    "npmAccessLevel": "public"
+  },
+  "npmts": {
+    "testConfig": {
+      "parallel": false
+    }
+  },
+  "gitzone": {
+    "projectType": "npm",
+    "module": {
+      "githost": "code.foss.global",
+      "gitscope": "push.rocks",
+      "gitrepo": "npmextra",
+      "description": "A utility to enhance npm with additional configuration, tool management capabilities, and a key-value store for project setups.",
+      "npmPackagename": "@push.rocks/npmextra",
+      "license": "MIT",
+      "keywords": [
+        "npm",
+        "configuration management",
+        "tool management",
+        "key-value store",
+        "project setup",
+        "typescript",
+        "environment setup",
+        "dependencies management",
+        "npm package enhancement",
+        "automation",
+        "async operations",
+        "app configuration",
+        "smart file handling",
+        "workflow improvement",
+        "persistent storage"
+      ]
+    }
+  },
+  "tsdoc": {
+    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  }
+}

package.json

@@ -1,33 +1,77 @@
 {
-  "name": "npmextra",
+  "name": "@push.rocks/npmextra",
-  "version": "2.0.3",
+  "version": "5.3.3",
-  "description": "do more with npm",
+  "private": false,
-  "main": "dist/index.js",
+  "description": "A utility to enhance npm with additional configuration, tool management capabilities, and a key-value store for project setups.",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
   "scripts": {
-    "test": "(npmts)"
+    "test": "(tstest test/ --verbose --logfile --timeout 20)",
+    "build": "(tsbuild --web --allowimplicitany)",
+    "buildDocs": "tsdoc"
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@gitlab.com/pushrocks/npmextra.git"
+    "url": "https://code.foss.global/push.rocks/npmextra.git"
   },
   "author": "Lossless GmbH",
   "license": "MIT",
   "bugs": {
-    "url": "https://gitlab.com/pushrocks/npmextra/issues"
+    "url": "https://code.foss.global/push.rocks/npmextra/issues"
   },
-  "homepage": "https://gitlab.com/pushrocks/npmextra#README",
+  "homepage": "https://code.foss.global/push.rocks/npmextra#readme",
   "dependencies": {
-    "@types/q": "^0.x.x",
+    "@push.rocks/qenv": "^6.1.3",
-    "beautylog": "^5.0.23",
+    "@push.rocks/smartfile": "^11.2.5",
-    "lodash": "^4.16.1",
+    "@push.rocks/smartjson": "^5.0.20",
-    "q": "^1.4.1",
+    "@push.rocks/smartlog": "^3.1.8",
-    "smartfile": "^4.0.21",
+    "@push.rocks/smartpath": "^6.0.0",
-    "typings-global": "^1.0.14"
+    "@push.rocks/smartpromise": "^4.2.3",
+    "@push.rocks/smartrx": "^3.0.10",
+    "@push.rocks/taskbuffer": "^3.1.7",
+    "@tsclass/tsclass": "^9.2.0"
   },
   "devDependencies": {
-    "@types/should": "^8.1.30",
+    "@git.zone/tsbuild": "^2.6.4",
-    "should": "^11.1.0",
+    "@git.zone/tsrun": "^1.3.3",
-    "typings-test": "^1.0.3"
+    "@git.zone/tstest": "^2.3.2",
+    "@types/node": "^22"
+  },
+  "files": [
+    "ts/**/*",
+    "ts_web/**/*",
+    "dist/**/*",
+    "dist_*/**/*",
+    "dist_ts/**/*",
+    "dist_ts_web/**/*",
+    "assets/**/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ],
+  "browserslist": [
+    "last 1 chrome versions"
+  ],
+  "type": "module",
+  "keywords": [
+    "npm",
+    "configuration management",
+    "tool management",
+    "key-value store",
+    "project setup",
+    "typescript",
+    "environment setup",
+    "dependencies management",
+    "npm package enhancement",
+    "automation",
+    "async operations",
+    "app configuration",
+    "smart file handling",
+    "workflow improvement",
+    "persistent storage"
+  ],
+  "packageManager": "pnpm@10.11.0+sha512.6540583f41cc5f628eb3d9773ecee802f4f9ef9923cc45b69890fb47991d4b092964694ec3a4f738a420c918a333062c8b925d312f42e4f0c263eb603551f977",
+  "pnpm": {
+    "overrides": {}
   }
 }

pnpm-workspace.yaml

@@ -0,0 +1,4 @@
+onlyBuiltDependencies:
+  - esbuild
+  - mongodb-memory-server
+  - puppeteer

readme.md

@@ -0,0 +1,517 @@
+# @push.rocks/npmextra 🚀
+
+**Supercharge your npm projects with powerful configuration management, tool orchestration, and persistent key-value storage.**
+
+## Install 📦
+
+```bash
+# Using npm
+npm install @push.rocks/npmextra --save
+
+# Using pnpm (recommended)
+pnpm add @push.rocks/npmextra
+```
+
+## Overview 🎯
+
+`@push.rocks/npmextra` is your Swiss Army knife for npm project configuration. It eliminates configuration sprawl by centralizing tool settings, providing intelligent key-value storage, and offering powerful environment variable mapping with automatic type conversions.
+
+### Why npmextra? 
+
+- **🎛️ Centralized Configuration**: Manage all your tool configs in one `npmextra.json` file
+- **💾 Persistent Storage**: Smart key-value store with multiple storage strategies
+- **🔐 Environment Mapping**: Sophisticated env var handling with automatic type conversion
+- **🏗️ TypeScript First**: Full type safety and IntelliSense support
+- **⚡ Zero Config**: Works out of the box with sensible defaults
+- **🔄 Reactive**: Built-in change detection and observables
+
+## Core Concepts 🏗️
+
+### 1. Npmextra Configuration Management
+
+Stop scattering configuration across dozens of files. Centralize everything in `npmextra.json`:
+
+```typescript
+import { Npmextra } from '@push.rocks/npmextra';
+
+// Initialize with current directory
+const npmextra = new Npmextra();
+
+// Or specify a custom path
+const npmextra = new Npmextra('/path/to/project');
+
+// Get merged configuration for any tool
+const eslintConfig = npmextra.dataFor<EslintConfig>('eslint', {
+  // Default values if not in npmextra.json
+  extends: 'standard',
+  rules: {}
+});
+```
+
+**npmextra.json example:**
+```json
+{
+  "eslint": {
+    "extends": "@company/eslint-config",
+    "rules": {
+      "no-console": "warn"
+    }
+  },
+  "prettier": {
+    "semi": false,
+    "singleQuote": true
+  }
+}
+```
+
+### 2. KeyValueStore - Persistent Data Storage
+
+A flexible key-value store that persists data between script executions:
+
+```typescript
+import { KeyValueStore } from '@push.rocks/npmextra';
+
+interface UserSettings {
+  username: string;
+  apiKey: string;
+  preferences: {
+    theme: 'light' | 'dark';
+    notifications: boolean;
+  };
+}
+
+// Different storage strategies
+const kvStore = new KeyValueStore<UserSettings>({
+  typeArg: 'userHomeDir',  // Store in user's home directory
+  identityArg: 'myApp',
+  mandatoryKeys: ['username', 'apiKey']
+});
+
+// Write operations
+await kvStore.writeKey('username', 'john_doe');
+await kvStore.writeKey('preferences', {
+  theme: 'dark',
+  notifications: true
+});
+
+// Read operations
+const username = await kvStore.readKey('username');
+const allData = await kvStore.readAll();
+
+// Check for missing mandatory keys
+const missingKeys = await kvStore.getMissingMandatoryKeys();
+if (missingKeys.length > 0) {
+  console.log('Missing required configuration:', missingKeys);
+}
+
+// Wait for keys to be present
+await kvStore.waitForKeysPresent(['apiKey']);
+```
+
+**Storage Types:**
+- `userHomeDir`: Store in user's home directory
+- `custom`: Specify your own path
+- `ephemeral`: In-memory only (perfect for testing)
+
+### 3. AppData - Advanced Environment Management 🌟
+
+The crown jewel of npmextra - sophisticated environment variable mapping with automatic type conversion:
+
+```typescript
+import { AppData } from '@push.rocks/npmextra';
+
+interface AppConfig {
+  apiUrl: string;
+  apiKey: string;
+  port: number;
+  features: {
+    analytics: boolean;
+    payment: boolean;
+  };
+  cache: {
+    ttl: number;
+    redis: {
+      host: string;
+      password: string;
+    };
+  };
+}
+
+const appData = await AppData.createAndInit<AppConfig>({
+  dirPath: '/app/config',  // Optional: defaults to smart path selection
+  requiredKeys: ['apiKey', 'apiUrl'],
+  envMapping: {
+    apiUrl: 'API_URL',                    // Simple mapping
+    apiKey: 'hard:development-key-123',   // Hardcoded value
+    port: 'hard:3000',                     // Hardcoded number
+    features: {
+      analytics: 'boolean:ENABLE_ANALYTICS',  // Force boolean conversion
+      payment: 'hard_boolean:true'            // Hardcoded boolean
+    },
+    cache: {
+      ttl: 'json:CACHE_CONFIG',  // Parse JSON from env var
+      redis: {
+        host: 'REDIS_HOST',
+        password: 'base64:REDIS_PASSWORD_B64'  // Decode base64
+      }
+    }
+  },
+  overwriteObject: {
+    // Force these values regardless of env vars
+    port: 8080
+  }
+});
+
+const store = await appData.getKvStore();
+const apiUrl = await store.readKey('apiUrl');
+```
+
+## AppData Special Cases & Conversions 🎯
+
+### Environment Variable Prefixes
+
+AppData supports sophisticated type conversion through prefixes:
+
+| Prefix | Description | Example | Result |
+|--------|-------------|---------|--------|
+| `hard:` | Hardcoded value | `hard:myvalue` | `"myvalue"` |
+| `hard_boolean:` | Hardcoded boolean | `hard_boolean:true` | `true` |
+| `hard_json:` | Hardcoded JSON | `hard_json:{"key":"value"}` | `{key: "value"}` |
+| `hard_base64:` | Hardcoded base64 | `hard_base64:SGVsbG8=` | `"Hello"` |
+| `boolean:` | Env var as boolean | `boolean:FEATURE_FLAG` | `true/false` |
+| `json:` | Parse env var as JSON | `json:CONFIG_JSON` | Parsed object |
+| `base64:` | Decode env var from base64 | `base64:SECRET_B64` | Decoded string |
+
+### Automatic Suffix Detection
+
+Variables ending with certain suffixes get automatic conversion:
+
+```typescript
+{
+  envMapping: {
+    // Automatically parsed as JSON if MY_CONFIG_JSON="{"enabled":true}"
+    config: 'MY_CONFIG_JSON',
+    
+    // Automatically decoded from base64 if SECRET_KEY_BASE64="SGVsbG8="
+    secret: 'SECRET_KEY_BASE64'
+  }
+}
+```
+
+### Complex Examples
+
+```typescript
+const appData = await AppData.createAndInit({
+  envMapping: {
+    // Simple environment variable
+    apiUrl: 'API_URL',
+    
+    // Hardcoded values with type conversion
+    debugMode: 'hard_boolean:false',
+    maxRetries: 'hard:5',
+    defaultConfig: 'hard_json:{"timeout":30,"retries":3}',
+    
+    // Environment variables with conversion
+    features: 'json:FEATURE_FLAGS',  // Expects: {"feature1":true,"feature2":false}
+    isProduction: 'boolean:IS_PROD', // Expects: "true" or "false"
+    apiSecret: 'base64:API_SECRET',  // Expects: base64 encoded string
+    
+    // Nested structures
+    database: {
+      host: 'DB_HOST',
+      port: 'hard:5432',
+      credentials: {
+        user: 'DB_USER',
+        password: 'base64:DB_PASSWORD_ENCODED',
+        ssl: 'boolean:DB_USE_SSL'
+      }
+    }
+  },
+  
+  // Override any env mappings
+  overwriteObject: {
+    debugMode: true,  // Force debug mode regardless of env
+    database: {
+      host: 'localhost'  // Force localhost for development
+    }
+  }
+});
+```
+
+### Boolean Conversion Rules
+
+AppData intelligently handles boolean conversions:
+
+1. **String "true"/"false"**: Converted to boolean
+2. **With `boolean:` prefix**: Any env var value is converted (`"true"` → `true`, anything else → `false`)
+3. **With `hard_boolean:` prefix**: Hardcoded boolean value
+4. **Regular env vars**: Strings remain strings unless prefixed
+
+```typescript
+// Environment: FEATURE_A="true", FEATURE_B="yes", FEATURE_C="1"
+{
+  envMapping: {
+    featureA: 'FEATURE_A',           // Result: "true" (string)
+    featureB: 'boolean:FEATURE_B',   // Result: false (only "true" → true)
+    featureC: 'boolean:FEATURE_C',   // Result: false (only "true" → true)
+    featureD: 'hard_boolean:true'    // Result: true (hardcoded)
+  }
+}
+```
+
+### Static Helper Functions
+
+AppData provides convenient static methods for directly accessing and converting environment variables without creating an instance:
+
+```typescript
+import { AppData } from '@push.rocks/npmextra';
+
+// Get environment variable as boolean
+const isEnabled = await AppData.valueAsBoolean('FEATURE_ENABLED');
+// Returns: true if "true", false otherwise
+
+// Get environment variable as parsed JSON
+interface Config {
+  timeout: number;
+  retries: number;
+}
+const config = await AppData.valueAsJson<Config>('SERVICE_CONFIG');
+// Returns: Parsed object or undefined
+
+// Get environment variable as base64 decoded string
+const secret = await AppData.valueAsBase64('ENCODED_SECRET');
+// Returns: Decoded string or undefined
+
+// Get environment variable as string
+const apiUrl = await AppData.valueAsString('API_URL');
+// Returns: String value or undefined
+
+// Get environment variable as number
+const port = await AppData.valueAsNumber('PORT');
+// Returns: Number value or undefined
+```
+
+These static methods are perfect for:
+- Quick environment variable access without setup
+- Simple type conversions in utility functions
+- One-off configuration checks
+- Scenarios where you don't need the full AppData instance
+
+## Advanced Patterns 🎨
+
+### Reactive Configuration
+
+Subscribe to configuration changes:
+
+```typescript
+const kvStore = new KeyValueStore<Config>({
+  typeArg: 'custom',
+  identityArg: 'myApp'
+});
+
+// Subscribe to changes
+kvStore.changeSubject.subscribe((newData) => {
+  console.log('Configuration changed:', newData);
+});
+
+// Changes trigger notifications
+await kvStore.writeKey('theme', 'dark');
+```
+
+### Testing with Ephemeral Storage
+
+Perfect for unit tests - no file system pollution:
+
+```typescript
+const testStore = new KeyValueStore<TestData>({
+  typeArg: 'ephemeral',
+  identityArg: 'test'
+});
+
+// All operations work normally, but nothing persists to disk
+await testStore.writeKey('testKey', 'testValue');
+```
+
+### Smart Path Resolution
+
+AppData automatically selects the best storage location:
+
+1. Checks for `/app/data` (containerized environments)
+2. Falls back to `/data` (alternate container path)
+3. Uses `.nogit/appdata` (local development)
+
+```typescript
+// Automatic path selection
+const appData = await AppData.createAndInit({
+  // No dirPath specified - smart detection
+  requiredKeys: ['apiKey']
+});
+
+// Or force ephemeral for testing
+const testData = await AppData.createAndInit({
+  ephemeral: true,  // No disk persistence
+  requiredKeys: ['testKey']
+});
+```
+
+### Waiting for Configuration
+
+Block until required configuration is available:
+
+```typescript
+const appData = await AppData.createAndInit<Config>({
+  requiredKeys: ['apiKey', 'apiUrl']
+});
+
+// Wait for specific key
+const apiKey = await appData.waitForAndGetKey('apiKey');
+
+// Check missing keys
+const missingKeys = await appData.logMissingKeys();
+// Logs: "The following mandatory keys are missing in the appdata:
+//        -> apiKey,
+//        -> apiUrl"
+```
+
+## Real-World Example 🌍
+
+Here's a complete example of a CLI tool using npmextra:
+
+```typescript
+import { Npmextra, AppData, KeyValueStore } from '@push.rocks/npmextra';
+
+interface CliConfig {
+  githubToken: string;
+  openaiKey: string;
+  model: 'gpt-3' | 'gpt-4';
+  cache: {
+    enabled: boolean;
+    ttl: number;
+  };
+}
+
+class MyCLI {
+  private npmextra: Npmextra;
+  private appData: AppData<CliConfig>;
+  private cache: KeyValueStore<{[key: string]: any}>;
+
+  async initialize() {
+    // Load tool configuration
+    this.npmextra = new Npmextra();
+    const config = this.npmextra.dataFor<any>('mycli', {
+      defaultModel: 'gpt-3'
+    });
+
+    // Setup app data with env mapping
+    this.appData = await AppData.createAndInit<CliConfig>({
+      requiredKeys: ['githubToken', 'openaiKey'],
+      envMapping: {
+        githubToken: 'GITHUB_TOKEN',
+        openaiKey: 'base64:OPENAI_KEY_ENCODED',
+        model: 'hard:gpt-4',
+        cache: {
+          enabled: 'boolean:ENABLE_CACHE',
+          ttl: 'hard:3600'
+        }
+      }
+    });
+
+    // Initialize cache
+    this.cache = new KeyValueStore({
+      typeArg: 'userHomeDir',
+      identityArg: 'mycli-cache'
+    });
+
+    // Check for missing configuration
+    const missingKeys = await this.appData.logMissingKeys();
+    if (missingKeys.length > 0) {
+      console.error('Please configure the missing keys');
+      process.exit(1);
+    }
+  }
+
+  async run() {
+    await this.initialize();
+    
+    const config = await this.appData.getKvStore();
+    const settings = await config.readAll();
+    
+    console.log(`Using model: ${settings.model}`);
+    console.log(`Cache enabled: ${settings.cache.enabled}`);
+    
+    // Use the configuration...
+  }
+}
+
+// Run the CLI
+const cli = new MyCLI();
+cli.run();
+```
+
+## API Reference 📚
+
+### Npmextra Class
+
+```typescript
+new Npmextra(cwdArg?: string)
+```
+- `cwdArg`: Optional working directory path
+
+**Methods:**
+- `dataFor<T>(toolName: string, defaultOptions: T): T` - Get merged configuration
+
+### KeyValueStore Class
+
+```typescript
+new KeyValueStore<T>(options: {
+  typeArg: 'custom' | 'userHomeDir' | 'ephemeral';
+  identityArg: string;
+  customPath?: string;
+  mandatoryKeys?: Array<keyof T>;
+})
+```
+
+**Methods:**
+- `readKey(key: string): Promise<T>` - Read single value
+- `writeKey(key: string, value: T): Promise<void>` - Write single value
+- `readAll(): Promise<T>` - Read all values
+- `writeAll(data: T): Promise<void>` - Write all values
+- `deleteKey(key: string): Promise<void>` - Delete a key
+- `getMissingMandatoryKeys(): Promise<string[]>` - Check missing required keys
+- `waitForKeysPresent(keys: string[]): Promise<void>` - Wait for keys
+
+### AppData Class
+
+```typescript
+await AppData.createAndInit<T>(options: {
+  dirPath?: string;
+  requiredKeys?: Array<keyof T>;
+  ephemeral?: boolean;
+  envMapping?: PartialDeep<T>;
+  overwriteObject?: PartialDeep<T>;
+})
+```
+
+**Methods:**
+- `getKvStore(): Promise<KeyValueStore<T>>` - Get underlying store
+- `logMissingKeys(): Promise<Array<keyof T>>` - Log and return missing keys
+- `waitForAndGetKey<K>(key: K): Promise<T[K]>` - Wait for and retrieve key
+
+## License and Legal Information
+
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+
+**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

readme.plan.md

@@ -0,0 +1,225 @@
+# AppData Refactoring Plan
+
+## Overview
+Refactor the AppData class to improve elegance, maintainability, and extensibility while maintaining 100% backward compatibility.
+
+## Current Issues
+- 100+ lines of nested switch statements in processEnvMapping
+- Static helpers recreate Qenv instances on every call
+- Complex boolean conversion logic scattered across multiple places
+- Typo: "ephermal" should be "ephemeral"
+- Difficult to test and extend with new transformations
+
+## Architecture Improvements
+
+### 1. Singleton Qenv Provider
+Create a shared Qenv instance to avoid repeated instantiation:
+
+```typescript
+let sharedQenv: plugins.qenv.Qenv | undefined;
+
+function getQenv(): plugins.qenv.Qenv {
+  if (!sharedQenv) {
+    sharedQenv = new plugins.qenv.Qenv(
+      process.cwd(),
+      plugins.path.join(process.cwd(), '.nogit')
+    );
+  }
+  return sharedQenv;
+}
+```
+
+### 2. Centralized Type Converters
+Extract all conversion logic into pure utility functions:
+
+```typescript
+function toBoolean(value: unknown): boolean {
+  if (typeof value === 'boolean') return value;
+  if (value == null) return false;
+  const s = String(value).toLowerCase();
+  return s === 'true';
+}
+
+function toJson<T>(value: unknown): T | undefined {
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return undefined;
+    }
+  }
+  return value as T;
+}
+
+function fromBase64(value: unknown): string {
+  if (value == null) return '';
+  return Buffer.from(String(value), 'base64').toString('utf8');
+}
+
+function toNumber(value: unknown): number | undefined {
+  if (value == null) return undefined;
+  const num = Number(value);
+  return Number.isNaN(num) ? undefined : num;
+}
+
+function toString(value: unknown): string | undefined {
+  if (value == null) return undefined;
+  return String(value);
+}
+```
+
+### 3. Declarative Pipeline Architecture
+
+Replace the giant switch statement with a composable pipeline:
+
+#### Data Structures
+```typescript
+type MappingSpec = {
+  source: 
+    | { type: 'env', key: string }
+    | { type: 'hard', value: string };
+  transforms: Transform[];
+}
+
+type Transform = 'boolean' | 'json' | 'base64' | 'number';
+```
+
+#### Pipeline Functions
+```typescript
+// Parse mapping string into spec
+function parseMappingSpec(input: string): MappingSpec
+
+// Resolve the source value
+async function resolveSource(source: MappingSpec['source']): Promise<unknown>
+
+// Apply transformations
+function applyTransforms(value: unknown, transforms: Transform[]): unknown
+
+// Complete pipeline
+async function processMappingValue(mappingString: string): Promise<unknown>
+```
+
+### 4. Transform Registry
+Enable easy extension with new transforms:
+
+```typescript
+const transformRegistry: Record<string, (v: unknown) => unknown> = {
+  boolean: toBoolean,
+  json: toJson,
+  base64: fromBase64,
+  number: toNumber,
+};
+```
+
+### 5. Simplified processEnvMapping
+Build pure object tree first, then write to kvStore:
+
+```typescript
+async function evaluateMappingValue(mappingValue: any): Promise<any> {
+  if (typeof mappingValue === 'string') {
+    return processMappingValue(mappingValue);
+  }
+  if (mappingValue && typeof mappingValue === 'object') {
+    const out: any = {};
+    for (const [k, v] of Object.entries(mappingValue)) {
+      out[k] = await evaluateMappingValue(v);
+    }
+    return out;
+  }
+  return undefined;
+}
+
+// Main loop becomes:
+for (const key in this.options.envMapping) {
+  const evaluated = await evaluateMappingValue(this.options.envMapping[key]);
+  if (evaluated !== undefined) {
+    await this.kvStore.writeKey(key as keyof T, evaluated);
+  }
+}
+```
+
+## Backward Compatibility
+
+### Supported Prefixes (Maintained)
+- `hard:` - Hardcoded value
+- `hard_boolean:` - Hardcoded boolean
+- `hard_json:` - Hardcoded JSON
+- `hard_base64:` - Hardcoded base64
+- `boolean:` - Environment variable as boolean
+- `json:` - Environment variable as JSON
+- `base64:` - Environment variable as base64
+
+### Supported Suffixes (Maintained)
+- `_JSON` - Auto-parse as JSON
+- `_BASE64` - Auto-decode from base64
+
+### Typo Fix Strategy
+- Add `ephemeral` option to interface
+- Keep reading `ephermal` for backward compatibility
+- Log deprecation warning when old spelling is used
+
+## Implementation Steps
+
+1. **Add utility functions** at the top of the file
+2. **Implement pipeline functions** (parseMappingSpec, resolveSource, applyTransforms)
+3. **Refactor processEnvMapping** to use the pipeline
+4. **Update static helpers** to use shared utilities
+5. **Fix typo** with compatibility shim
+6. **Add error boundaries** for better error reporting
+7. **Test** to ensure backward compatibility
+
+## Benefits
+
+### Code Quality
+- **70% reduction** in processEnvMapping complexity
+- **Better separation** of concerns
+- **Easier testing** - each function is pure and testable
+- **Cleaner error handling** with boundaries
+
+### Performance
+- **Shared Qenv instance** reduces allocations
+- **Optional parallelization** with Promise.all
+- **Fewer repeated operations**
+
+### Maintainability
+- **Extensible** - Easy to add new transforms
+- **Readable** - Clear pipeline flow
+- **Debuggable** - Each step can be logged
+- **Type-safe** - Better TypeScript support
+
+## Testing Strategy
+
+1. **Unit tests** for each utility function
+2. **Integration tests** for the full pipeline
+3. **Backward compatibility tests** for all existing prefixes/suffixes
+4. **Edge case tests** for error conditions
+
+## Future Extensions
+
+With the transform registry, adding new features becomes trivial:
+
+```typescript
+// Add YAML support
+transformRegistry['yaml'] = (v) => YAML.parse(String(v));
+
+// Add integer parsing
+transformRegistry['int'] = (v) => parseInt(String(v), 10);
+
+// Add custom transformers
+transformRegistry['uppercase'] = (v) => String(v).toUpperCase();
+```
+
+## Migration Path
+
+1. Implement new architecture alongside existing code
+2. Gradually migrate internal usage
+3. Mark old patterns as deprecated (with warnings)
+4. Remove deprecated code in next major version
+
+## Success Metrics
+
+- All existing tests pass
+- No breaking changes for users
+- Reduced code complexity (measurable via cyclomatic complexity)
+- Improved test coverage
+- Better performance (fewer allocations, optional parallelization)

test/npmextra.json

@@ -1,5 +1,5 @@
 {
-    "testTool":{
+  "testTool": {
-        "testValue":2
+    "testValue": 2
-    }
+  }
 }

test/somekv.json

@@ -0,0 +1,3 @@
+{
+  "myKey": "myValue"
+}

test/test.appdata.ts

@@ -0,0 +1,26 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+
+// module to test
+import * as npmextra from '../ts/index.js';
+
+interface ITestOptions {
+  hi: string;
+  deep: {
+    deep1: string;
+    deep2: string;
+  };
+}
+
+let testAppdata: npmextra.AppData<ITestOptions>;
+
+tap.test('should create a valid AppData', async () => {
+  testAppdata = new npmextra.AppData<ITestOptions>({
+    envMapping: {
+      deep: {
+        deep1: '',
+      },
+    },
+  });
+});
+
+export default tap.start();

test/test.boolean-false.ts

@@ -0,0 +1,139 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as npmextra from '../ts/index.js';
+
+// Test environment variable with boolean false value
+tap.test('should handle boolean false values in nested objects correctly', async () => {
+  // Set up test environment variable
+  process.env['S3_USESSL'] = 'false';
+  process.env['S3_ENDPOINT'] = 'https://s3.example.com';
+  process.env['S3_REGION'] = 'us-east-1';
+  process.env['S3_ACCESSKEY'] = 'test-key';
+  process.env['S3_ACCESSSECRET'] = 'test-secret';
+
+  // Create AppData with nested object structure similar to CloudlyConfig
+  const appData = await npmextra.AppData.createAndInit({
+    ephemeral: true, // Use in-memory storage for testing
+    envMapping: {
+      s3Descriptor: {
+        endpoint: 'S3_ENDPOINT',
+        region: 'S3_REGION',
+        accessKey: 'S3_ACCESSKEY',
+        accessSecret: 'S3_ACCESSSECRET',
+        useSsl: 'boolean:S3_USESSL'
+      }
+    }
+  });
+
+  // Get the kvStore and read the configuration
+  const kvStore = await appData.getKvStore();
+  const s3Descriptor = await kvStore.readKey('s3Descriptor');
+
+  console.log('\n=== Test Results ===');
+  console.log('S3 Descriptor:', JSON.stringify(s3Descriptor, null, 2));
+  console.log('useSsl value:', s3Descriptor?.useSsl);
+  console.log('useSsl type:', typeof s3Descriptor?.useSsl);
+  console.log('useSsl === false:', (s3Descriptor?.useSsl as any) === false);
+
+  // Verify the values
+  expect(s3Descriptor).toBeTruthy();
+  expect(s3Descriptor.endpoint).toEqual('https://s3.example.com');
+  expect(s3Descriptor.region).toEqual('us-east-1');
+  expect(s3Descriptor.accessKey).toEqual('test-key');
+  expect(s3Descriptor.accessSecret).toEqual('test-secret');
+  
+  // Critical test: useSsl should be false, not undefined
+  expect(s3Descriptor.useSsl).toEqual(false);
+  expect(typeof s3Descriptor.useSsl).toEqual('boolean');
+  expect(s3Descriptor.useSsl).not.toBeUndefined();
+});
+
+tap.test('should handle various boolean representations correctly', async () => {
+  // Test different boolean representations
+  const testCases = [
+    { env: 'false', expected: false },
+    { env: 'FALSE', expected: false },
+    { env: '0', expected: false },
+    { env: 'no', expected: false },
+    { env: 'NO', expected: false },
+    { env: 'n', expected: false },
+    { env: 'off', expected: false },
+    { env: 'true', expected: true },
+    { env: 'TRUE', expected: true },
+    { env: '1', expected: true },
+    { env: 'yes', expected: true },
+    { env: 'YES', expected: true },
+    { env: 'y', expected: true },
+    { env: 'on', expected: true },
+  ];
+
+  for (const testCase of testCases) {
+    process.env['TEST_BOOL'] = testCase.env;
+    
+    const appData = await npmextra.AppData.createAndInit({
+      ephemeral: true,
+      envMapping: {
+        testBool: 'boolean:TEST_BOOL'
+      }
+    });
+
+    const kvStore = await appData.getKvStore();
+    const testBool = await kvStore.readKey('testBool');
+
+    console.log(`Input "${testCase.env}" => ${testBool} (expected: ${testCase.expected})`);
+    expect(testBool).toEqual(testCase.expected);
+  }
+});
+
+tap.test('should handle hardcoded boolean false values', async () => {
+  // Test with hardcoded boolean false value
+  const appData = await npmextra.AppData.createAndInit({
+    ephemeral: true,
+    envMapping: {
+      boolValue: 'hard_boolean:false'
+    }
+  });
+
+  const kvStore = await appData.getKvStore();
+  const boolValue = await kvStore.readKey('boolValue');
+
+  console.log('\n=== Hardcoded Boolean Test ===');
+  console.log('boolValue:', boolValue);
+  console.log('type:', typeof boolValue);
+  console.log('is false:', (boolValue as any) === false);
+
+  expect(boolValue).toEqual(false);
+  expect(typeof boolValue).toEqual('boolean');
+});
+
+tap.test('should not filter out other falsy values', async () => {
+  process.env['ZERO_VALUE'] = '0';
+  process.env['EMPTY_STRING'] = '';  // This should be preserved as empty string
+  
+  const appData = await npmextra.AppData.createAndInit({
+    ephemeral: true,
+    envMapping: {
+      nested: {
+        zeroAsNumber: 'ZERO_VALUE',  // Should preserve "0" as string
+        zeroAsBoolean: 'boolean:ZERO_VALUE',  // Should convert to false
+        emptyString: 'EMPTY_STRING',  // Should preserve empty string
+        hardcodedFalse: 'hard_boolean:false',  // Should be false
+        hardcodedZero: 'hard:0',  // Should be "0" string
+      }
+    }
+  });
+
+  const kvStore = await appData.getKvStore();
+  const nested = await kvStore.readKey('nested');
+
+  console.log('\n=== Falsy Values Test ===');
+  console.log('nested:', JSON.stringify(nested, null, 2));
+
+  expect(nested).toBeTruthy();
+  expect(nested.zeroAsNumber).toEqual('0');
+  expect(nested.zeroAsBoolean).toEqual(false);
+  expect(nested.emptyString).toEqual('');
+  expect(nested.hardcodedFalse).toEqual(false);
+  expect(nested.hardcodedZero).toEqual('0');
+});
+
+export default tap.start();

test/test.d.ts

@@ -1 +0,0 @@
-import 'typings-test';

test/test.js

@@ -1,27 +0,0 @@
-"use strict";
-require("typings-test");
-const should = require("should");
-const npmExtra = require("../dist/index");
-let testNpmextra;
-describe('npmextra', function () {
-    it('should create a new Npmtextra instance', function () {
-        testNpmextra = new npmExtra.Npmextra('./test/');
-        should(testNpmextra).be.instanceof(npmExtra.Npmextra);
-    });
-    it('should state wether a npmextra.json exists', function () {
-        should(testNpmextra.npmextraJsonExists).be.true();
-    });
-    it('should pass through default value, if not overriden by config from file', function () {
-        let testData = testNpmextra.dataFor('testTool', { someKey2: 'someValue2' });
-        console.log(testData);
-        should(testData).have.ownProperty('someKey2');
-    });
-    it('should read a config file', function () {
-        let testData = testNpmextra.dataFor('testTool', {
-            someKey2: 'someValue2'
-        });
-        should(testData).have.ownProperty('someKey2');
-        should(testData.testValue).equal(2);
-    });
-});
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGVzdC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbInRlc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLHdCQUFxQjtBQUVyQixpQ0FBZ0M7QUFFaEMsMENBQTBDO0FBRTFDLElBQUksWUFBK0IsQ0FBQTtBQUVuQyxRQUFRLENBQUMsVUFBVSxFQUFDO0lBQ2hCLEVBQUUsQ0FBQyx3Q0FBd0MsRUFBRTtRQUN6QyxZQUFZLEdBQUcsSUFBSSxRQUFRLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxDQUFBO1FBQy9DLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQyxFQUFFLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxRQUFRLENBQUMsQ0FBQTtJQUN6RCxDQUFDLENBQUMsQ0FBQTtJQUNGLEVBQUUsQ0FBQyw0Q0FBNEMsRUFBRTtRQUM3QyxNQUFNLENBQUMsWUFBWSxDQUFDLGtCQUFrQixDQUFDLENBQUMsRUFBRSxDQUFDLElBQUksRUFBRSxDQUFBO0lBQ3JELENBQUMsQ0FBQyxDQUFBO0lBQ0YsRUFBRSxDQUFDLHlFQUF5RSxFQUFDO1FBQ3pFLElBQUksUUFBUSxHQUFHLFlBQVksQ0FBQyxPQUFPLENBQUMsVUFBVSxFQUFFLEVBQUMsUUFBUSxFQUFFLFlBQVksRUFBQyxDQUFDLENBQUE7UUFDekUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxRQUFRLENBQUMsQ0FBQTtRQUNyQixNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxVQUFVLENBQUMsQ0FBQTtJQUNqRCxDQUFDLENBQUMsQ0FBQTtJQUNGLEVBQUUsQ0FBQywyQkFBMkIsRUFBQztRQUMzQixJQUFJLFFBQVEsR0FBRyxZQUFZLENBQUMsT0FBTyxDQUMvQixVQUFVLEVBQ1Y7WUFDSSxRQUFRLEVBQUUsWUFBWTtTQUN6QixDQUNKLENBQUE7UUFDRCxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxVQUFVLENBQUMsQ0FBQTtRQUM3QyxNQUFNLENBQUMsUUFBUSxDQUFDLFNBQVMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQTtJQUN2QyxDQUFDLENBQUMsQ0FBQTtBQUNOLENBQUMsQ0FBQyxDQUFBIn0=

test/test.kvstore.ts

@@ -0,0 +1,32 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+
+import * as npmextra from '../ts/index.js';
+
+let myKeyValueStore: npmextra.KeyValueStore<any>;
+
+tap.test('should create a keyValueStore', async () => {
+  myKeyValueStore = new npmextra.KeyValueStore<any>({
+    typeArg: 'custom',
+    identityArg: 'test',
+    customPath: 'test/somekv.json',
+  });
+  expect(myKeyValueStore).toBeInstanceOf(npmextra.KeyValueStore);
+});
+
+tap.test('should reset the keyValueStore', async () => {
+  await myKeyValueStore.reset();
+});
+
+tap.test('expect result to be empty', async () => {
+  let result = await myKeyValueStore.readAll();
+  expect(JSON.stringify(result)).toEqual('{}');
+});
+
+tap.test('expect to add an object to the kv Store', async () => {
+  await myKeyValueStore.writeAll({
+    myKey: 'myValue',
+  });
+  await expect(await myKeyValueStore.readKey('myKey')).toEqual('myValue');
+});
+
+export default tap.start();

test/test.redaction.ts

@@ -0,0 +1,85 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as npmextra from '../ts/index.js';
+
+// Test that sensitive values are properly redacted in logs
+tap.test('should redact sensitive values in console output', async () => {
+  // Capture console.log output
+  const originalLog = console.log;
+  const logOutput: string[] = [];
+  console.log = (...args: any[]) => {
+    logOutput.push(args.join(' '));
+  };
+
+  try {
+    // Set up environment variables with sensitive data
+    process.env['API_KEY'] = 'super-secret-api-key-12345';
+    process.env['DATABASE_PASSWORD'] = 'myP@ssw0rd123';
+    process.env['AUTH_TOKEN'] = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ';
+    process.env['PUBLIC_URL'] = 'https://example.com';
+    process.env['DEBUG_MODE'] = 'true';
+
+    // Create AppData with sensitive environment mappings
+    const appData = await npmextra.AppData.createAndInit({
+      ephemeral: true,
+      envMapping: {
+        apiKey: 'API_KEY',
+        dbPassword: 'DATABASE_PASSWORD',
+        authToken: 'AUTH_TOKEN',
+        publicUrl: 'PUBLIC_URL',
+        debugMode: 'boolean:DEBUG_MODE',
+        nestedConfig: {
+          secretKey: 'API_KEY',
+          nonSecret: 'PUBLIC_URL'
+        }
+      }
+    });
+
+    // Restore console.log
+    console.log = originalLog;
+
+    // Check that sensitive values were redacted in logs
+    const combinedOutput = logOutput.join('\n');
+    
+    // API_KEY should be redacted
+    expect(combinedOutput).toContain('sup...[26 chars]');
+    expect(combinedOutput).not.toContain('super-secret-api-key-12345');
+    
+    // DATABASE_PASSWORD should be redacted
+    expect(combinedOutput).toContain('myP...[13 chars]');
+    expect(combinedOutput).not.toContain('myP@ssw0rd123');
+    
+    // AUTH_TOKEN should be redacted (JWT tokens starting with eyJ)
+    expect(combinedOutput).toContain('eyJ...[');
+    expect(combinedOutput).not.toContain('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9');
+    
+    // PUBLIC_URL should not be redacted (not sensitive)
+    expect(combinedOutput).toContain('https://example.com');
+    
+    // DEBUG_MODE should not be redacted (not sensitive)
+    expect(combinedOutput).toContain('true');
+
+    // Verify data is still stored correctly (not redacted in actual storage)
+    const kvStore = await appData.getKvStore();
+    const apiKey = await kvStore.readKey('apiKey');
+    const dbPassword = await kvStore.readKey('dbPassword');
+    const publicUrl = await kvStore.readKey('publicUrl');
+    
+    // Actual values should be stored correctly
+    expect(apiKey).toEqual('super-secret-api-key-12345');
+    expect(dbPassword).toEqual('myP@ssw0rd123');
+    expect(publicUrl).toEqual('https://example.com');
+    
+  } finally {
+    // Restore console.log in case of test failure
+    console.log = originalLog;
+    
+    // Clean up environment variables
+    delete process.env['API_KEY'];
+    delete process.env['DATABASE_PASSWORD'];
+    delete process.env['AUTH_TOKEN'];
+    delete process.env['PUBLIC_URL'];
+    delete process.env['DEBUG_MODE'];
+  }
+});
+
+export default tap.start();

test/test.ts

@@ -1,32 +1,35 @@
-import 'typings-test'
+import { expect, tap } from '@git.zone/tstest/tapbundle';
-import path = require('path')
-import * as should from 'should'
 
-import npmExtra = require('../dist/index')
+// module to test
+import * as npmextra from '../ts/index.js';
 
-let testNpmextra: npmExtra.Npmextra
+let testNpmextra: npmextra.Npmextra;
 
-describe('npmextra',function(){
+tap.test('should create a new Npmtextra instance', async () => {
-    it('should create a new Npmtextra instance', function(){
+  testNpmextra = new npmextra.Npmextra('./test/');
-        testNpmextra = new npmExtra.Npmextra('./test/')
+  expect(testNpmextra).toBeInstanceOf(npmextra.Npmextra);
-        should(testNpmextra).be.instanceof(npmExtra.Npmextra)
+});
-    })
+
-    it('should state wether a npmextra.json exists', function() {
+tap.test('should state wether a npmextra.json exists', async () => {
-        should(testNpmextra.npmextraJsonExists).be.true()
+  // tslint:disable-next-line:no-unused-expression
-    })
+  expect(testNpmextra.npmextraJsonExists).toBeTrue();
-    it('should pass through default value, if not overriden by config from file',function(){
+});
-        let testData = testNpmextra.dataFor('testTool', {someKey2: 'someValue2'})
+
-        console.log(testData)
+tap.test(
-        should(testData).have.ownProperty('someKey2')
+  'should pass through default value, if not overriden by config from file',
-    })
+  async () => {
-    it('should read a config file',function(){
+    let testData = testNpmextra.dataFor('testTool', { someKey2: 'someValue2' });
-        let testData = testNpmextra.dataFor(
+    console.log(testData);
-            'testTool',
+    expect(testData).toHaveProperty('someKey2');
-            {
+  },
-                someKey2: 'someValue2'
+);
-            }
+
-        )
+tap.test('should read a config file', async () => {
-        should(testData).have.ownProperty('someKey2')
+  let testData = testNpmextra.dataFor<any>('testTool', {
-        should(testData.testValue).equal(2)
+    someKey2: 'someValue2',
-    })
+  });
-})
+  expect(testData).toHaveProperty('someKey2');
+  expect(testData.testValue).toEqual(2);
+});
+
+tap.start();

ts/00_commitinfo_data.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+  name: '@push.rocks/npmextra',
+  version: '5.3.3',
+  description: 'A utility to enhance npm with additional configuration, tool management capabilities, and a key-value store for project setups.'
+}

ts/index.ts

@@ -1,4 +1,3 @@
-import * as plugins from './npmextra.plugins'
+export * from './npmextra.classes.appdata.js';
-
+export * from './npmextra.classes.keyvaluestore.js';
-export * from './npmextra.classes.npmextra'
+export * from './npmextra.classes.npmextra.js';
-export * from './npmextra.classes.keyvaluestore'

ts/npmextra.classes.appdata.ts

@@ -0,0 +1,548 @@
+import * as plugins from './npmextra.plugins.js';
+import { KeyValueStore } from './npmextra.classes.keyvaluestore.js';
+
+// ============================================================================
+// Singleton Qenv Provider
+// ============================================================================
+let sharedQenv: plugins.qenv.Qenv | undefined;
+
+function getQenv(): plugins.qenv.Qenv {
+  if (!sharedQenv) {
+    sharedQenv = new plugins.qenv.Qenv(
+      process.cwd(),
+      plugins.path.join(process.cwd(), '.nogit')
+    );
+  }
+  return sharedQenv;
+}
+
+// ============================================================================
+// Security - Redaction for sensitive data
+// ============================================================================
+/**
+ * Redacts sensitive values in logs to prevent exposure of secrets
+ */
+function redactSensitiveValue(key: string, value: unknown): string {
+  // List of patterns that indicate sensitive data
+  const sensitivePatterns = [
+    /secret/i, /token/i, /key/i, /password/i, /pass/i, 
+    /api/i, /credential/i, /auth/i, /private/i, /jwt/i,
+    /cert/i, /signature/i, /bearer/i
+  ];
+  
+  // Check if key contains sensitive pattern
+  const isSensitive = sensitivePatterns.some(pattern => pattern.test(key));
+  
+  if (isSensitive) {
+    if (typeof value === 'string') {
+      // Show first 3 chars and length for debugging
+      return value.length > 3 
+        ? `${value.substring(0, 3)}...[${value.length} chars]`
+        : '[redacted]';
+    }
+    return '[redacted]';
+  }
+  
+  // Check if value looks like a JWT token or base64 secret
+  if (typeof value === 'string') {
+    // JWT tokens start with eyJ
+    if (value.startsWith('eyJ')) {
+      return `eyJ...[${value.length} chars]`;
+    }
+    // Very long strings might be encoded secrets
+    if (value.length > 100) {
+      return `${value.substring(0, 50)}...[${value.length} chars total]`;
+    }
+  }
+  
+  return JSON.stringify(value);
+}
+
+// ============================================================================
+// Type Converters - Centralized conversion logic
+// ============================================================================
+function toBoolean(value: unknown): boolean {
+  // If already boolean, return as-is
+  if (typeof value === 'boolean') {
+    console.log(`    🔹 toBoolean: value is already boolean: ${value}`);
+    return value;
+  }
+  
+  // Handle null/undefined
+  if (value == null) {
+    console.log(`    🔹 toBoolean: value is null/undefined, returning false`);
+    return false;
+  }
+  
+  // Handle string representations
+  const s = String(value).toLowerCase().trim();
+  
+  // True values: "true", "1", "yes", "y", "on"
+  if (['true', '1', 'yes', 'y', 'on'].includes(s)) {
+    console.log(`    🔹 toBoolean: converting "${value}" to true`);
+    return true;
+  }
+  
+  // False values: "false", "0", "no", "n", "off"
+  if (['false', '0', 'no', 'n', 'off'].includes(s)) {
+    console.log(`    🔹 toBoolean: converting "${value}" to false`);
+    return false;
+  }
+  
+  // Default: non-empty string = true, empty = false
+  const result = s.length > 0;
+  console.log(`    🔹 toBoolean: defaulting "${value}" to ${result}`);
+  return result;
+}
+
+function toJson<T = any>(value: unknown): T | undefined {
+  if (value == null) return undefined;
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return undefined;
+    }
+  }
+  return value as T;
+}
+
+function fromBase64(value: unknown): string | undefined {
+  if (value == null) return undefined;
+  try {
+    return Buffer.from(String(value), 'base64').toString('utf8');
+  } catch {
+    return String(value);
+  }
+}
+
+function toNumber(value: unknown): number | undefined {
+  if (value == null) return undefined;
+  const num = Number(value);
+  return Number.isNaN(num) ? undefined : num;
+}
+
+function toString(value: unknown): string | undefined {
+  if (value == null) return undefined;
+  return String(value);
+}
+
+// ============================================================================
+// Declarative Pipeline Architecture
+// ============================================================================
+type Transform = 'boolean' | 'json' | 'base64' | 'number';
+
+type MappingSpec = {
+  source: 
+    | { type: 'env'; key: string }
+    | { type: 'hard'; value: string };
+  transforms: Transform[];
+};
+
+// Transform registry for extensibility
+const transformRegistry: Record<string, (v: unknown) => unknown> = {
+  boolean: toBoolean,
+  json: toJson,
+  base64: fromBase64,
+  number: toNumber,
+};
+
+/**
+ * Parse a mapping string into a declarative spec
+ */
+function parseMappingSpec(input: string): MappingSpec {
+  const transforms: Transform[] = [];
+  let remaining = input;
+  
+  // Check for hardcoded prefixes with type conversion
+  if (remaining.startsWith('hard_boolean:')) {
+    return {
+      source: { type: 'hard', value: remaining.slice(13) },
+      transforms: ['boolean']
+    };
+  }
+  
+  if (remaining.startsWith('hard_json:')) {
+    return {
+      source: { type: 'hard', value: remaining.slice(10) },
+      transforms: ['json']
+    };
+  }
+  
+  if (remaining.startsWith('hard_base64:')) {
+    return {
+      source: { type: 'hard', value: remaining.slice(12) },
+      transforms: ['base64']
+    };
+  }
+  
+  // Check for generic hard: prefix
+  if (remaining.startsWith('hard:')) {
+    remaining = remaining.slice(5);
+    // Check for legacy suffixes on hardcoded values
+    if (remaining.endsWith('_JSON')) {
+      transforms.push('json');
+      remaining = remaining.slice(0, -5);
+    } else if (remaining.endsWith('_BASE64')) {
+      transforms.push('base64');
+      remaining = remaining.slice(0, -7);
+    }
+    return {
+      source: { type: 'hard', value: remaining },
+      transforms
+    };
+  }
+  
+  // Check for env var prefixes
+  if (remaining.startsWith('boolean:')) {
+    transforms.push('boolean');
+    remaining = remaining.slice(8);
+  } else if (remaining.startsWith('json:')) {
+    transforms.push('json');
+    remaining = remaining.slice(5);
+  } else if (remaining.startsWith('base64:')) {
+    transforms.push('base64');
+    remaining = remaining.slice(7);
+  }
+  
+  // Check for legacy suffixes on env vars
+  if (remaining.endsWith('_JSON')) {
+    transforms.push('json');
+    remaining = remaining.slice(0, -5);
+  } else if (remaining.endsWith('_BASE64')) {
+    transforms.push('base64');
+    remaining = remaining.slice(0, -7);
+  }
+  
+  return {
+    source: { type: 'env', key: remaining },
+    transforms
+  };
+}
+
+/**
+ * Resolve the source value (env var or hardcoded)
+ */
+async function resolveSource(source: MappingSpec['source']): Promise<unknown> {
+  if (source.type === 'hard') {
+    return source.value;
+  }
+  // source.type === 'env'
+  // Workaround for Qenv bug where empty strings are treated as undefined
+  // Check process.env directly first to preserve empty strings
+  if (Object.prototype.hasOwnProperty.call(process.env, source.key)) {
+    return process.env[source.key];
+  }
+  // Fall back to Qenv for other sources (env.json, docker secrets, etc.)
+  return await getQenv().getEnvVarOnDemand(source.key);
+}
+
+/**
+ * Apply transformations in sequence
+ */
+function applyTransforms(value: unknown, transforms: Transform[]): unknown {
+  return transforms.reduce((acc, transform) => {
+    const fn = transformRegistry[transform];
+    return fn ? fn(acc) : acc;
+  }, value);
+}
+
+/**
+ * Process a mapping value through the complete pipeline
+ */
+async function processMappingValue(mappingString: string): Promise<unknown> {
+  const spec = parseMappingSpec(mappingString);
+  const keyName = spec.source.type === 'env' ? spec.source.key : 'hardcoded';
+  
+  console.log(`    🔍 Processing mapping: "${mappingString}"`);
+  console.log(`       Source: ${spec.source.type === 'env' ? `env:${spec.source.key}` : `hard:${spec.source.value}`}`);
+  console.log(`       Transforms: ${spec.transforms.length > 0 ? spec.transforms.join(', ') : 'none'}`);
+  
+  const rawValue = await resolveSource(spec.source);
+  console.log(`       Raw value: ${redactSensitiveValue(keyName, rawValue)} (type: ${typeof rawValue})`);
+  
+  if (rawValue === undefined || rawValue === null) {
+    console.log(`       ⚠️ Raw value is undefined/null, returning undefined`);
+    return undefined;
+  }
+  
+  const result = applyTransforms(rawValue, spec.transforms);
+  console.log(`       Final value: ${redactSensitiveValue(keyName, result)} (type: ${typeof result})`);
+  return result;
+}
+
+/**
+ * Recursively evaluate mapping values (strings or nested objects)
+ */
+async function evaluateMappingValue(mappingValue: any): Promise<any> {
+  // Handle null explicitly - it should return null, not be treated as object
+  if (mappingValue === null) {
+    console.log(`    📌 Value is null, returning null`);
+    return null;
+  }
+  
+  // Handle strings (mapping specs)
+  if (typeof mappingValue === 'string') {
+    return processMappingValue(mappingValue);
+  }
+  
+  // Handle objects (but not arrays or null)
+  if (mappingValue && typeof mappingValue === 'object' && !Array.isArray(mappingValue)) {
+    console.log(`    📂 Processing nested object with ${Object.keys(mappingValue).length} keys`);
+    const result: any = {};
+    for (const [key, value] of Object.entries(mappingValue)) {
+      console.log(`      → Processing nested key "${key}"`);
+      const evaluated = await evaluateMappingValue(value);
+      // Important: Don't filter out false or other falsy values!
+      // Only skip if explicitly undefined
+      if (evaluated !== undefined) {
+        result[key] = evaluated;
+        console.log(`      ✓ Nested key "${key}" = ${redactSensitiveValue(key, evaluated)} (type: ${typeof evaluated})`);
+      } else {
+        console.log(`      ⚠️ Nested key "${key}" evaluated to undefined, skipping`);
+      }
+    }
+    return result;
+  }
+  
+  // For any other type (numbers, booleans, etc.), return as-is
+  // Note: We don't have key context here, so we'll just indicate the type
+  console.log(`    📎 Returning value as-is: [value] (type: ${typeof mappingValue})`);
+  return mappingValue;
+}
+
+// ============================================================================
+// AppData Interface and Class
+// ============================================================================
+export interface IAppDataOptions<T = any> {
+  dirPath?: string;
+  requiredKeys?: Array<keyof T>;
+
+  /**
+   * Whether keys should be persisted on disk or not
+   */
+  ephemeral?: boolean;
+  
+  /**
+   * @deprecated Use 'ephemeral' instead
+   */
+  ephermal?: boolean;
+
+  /**
+   * kvStoreKey: 'MY_ENV_VAR'
+   */
+  envMapping?: plugins.tsclass.typeFest.PartialDeep<T>;
+  overwriteObject?: plugins.tsclass.typeFest.PartialDeep<T>;
+}
+
+export class AppData<T = any> {
+  /**
+   * creates appdata. If no pathArg is given, data will be stored here:
+   * ${PWD}/.nogit/appdata
+   * @param pathArg
+   * @returns
+   */
+  public static async createAndInit<T = any>(
+    optionsArg: IAppDataOptions<T> = {},
+  ): Promise<AppData<T>> {
+    const appData = new AppData<T>(optionsArg);
+    await appData.readyDeferred.promise;
+    return appData;
+  }
+
+  /**
+   * Static helper to get an environment variable as a boolean
+   * @param envVarName The name of the environment variable
+   * @returns boolean value (true if env var is "true", false otherwise)
+   */
+  public static async valueAsBoolean(envVarName: string): Promise<boolean> {
+    const value = await getQenv().getEnvVarOnDemand(envVarName);
+    return toBoolean(value);
+  }
+
+  /**
+   * Static helper to get an environment variable as parsed JSON
+   * @param envVarName The name of the environment variable
+   * @returns Parsed JSON object/array
+   */
+  public static async valueAsJson<R = any>(envVarName: string): Promise<R | undefined> {
+    const value = await getQenv().getEnvVarOnDemand(envVarName);
+    return toJson<R>(value);
+  }
+
+  /**
+   * Static helper to get an environment variable as base64 decoded string
+   * @param envVarName The name of the environment variable
+   * @returns Decoded string
+   */
+  public static async valueAsBase64(envVarName: string): Promise<string | undefined> {
+    const value = await getQenv().getEnvVarOnDemand(envVarName);
+    return fromBase64(value);
+  }
+
+  /**
+   * Static helper to get an environment variable as a string
+   * @param envVarName The name of the environment variable
+   * @returns String value
+   */
+  public static async valueAsString(envVarName: string): Promise<string | undefined> {
+    const value = await getQenv().getEnvVarOnDemand(envVarName);
+    return toString(value);
+  }
+
+  /**
+   * Static helper to get an environment variable as a number
+   * @param envVarName The name of the environment variable
+   * @returns Number value
+   */
+  public static async valueAsNumber(envVarName: string): Promise<number | undefined> {
+    const value = await getQenv().getEnvVarOnDemand(envVarName);
+    return toNumber(value);
+  }
+
+  // instance
+  public readyDeferred = plugins.smartpromise.defer<void>();
+  public options: IAppDataOptions<T>;
+  private kvStore: KeyValueStore<T>;
+
+  constructor(optionsArg: IAppDataOptions<T> = {}) {
+    this.options = optionsArg;
+    this.init();
+  }
+
+  /**
+   * inits app data
+   */
+  private async init() {
+    console.log('🚀 Initializing AppData...');
+    
+    // Handle backward compatibility for typo
+    const isEphemeral = this.options.ephemeral ?? this.options.ephermal ?? false;
+    if (this.options.ephermal && !this.options.ephemeral) {
+      console.warn('⚠️ Option "ephermal" is deprecated, use "ephemeral" instead.');
+    }
+    
+    if (this.options.dirPath) {
+      console.log(`  📁 Using custom directory: ${this.options.dirPath}`);
+    } else if (isEphemeral) {
+      console.log(`  💨 Using ephemeral storage (in-memory only)`);
+    } else {
+      const appDataDir = '/app/data';
+      const dataDir = '/data';
+      const nogitAppData = '.nogit/appdata';
+      const appDataExists = plugins.smartfile.fs.isDirectory(appDataDir);
+      const dataExists = plugins.smartfile.fs.isDirectory(dataDir);
+      if (appDataExists) {
+        this.options.dirPath = appDataDir;
+        console.log(`  📁 Auto-selected container directory: ${appDataDir}`);
+      } else if (dataExists) {
+        this.options.dirPath = dataDir;
+        console.log(`  📁 Auto-selected data directory: ${dataDir}`);
+      } else {
+        await plugins.smartfile.fs.ensureDir(nogitAppData);
+        this.options.dirPath = nogitAppData;
+        console.log(`  📁 Auto-selected local directory: ${nogitAppData}`);
+      }
+    }
+
+    this.kvStore = new KeyValueStore<T>({
+      typeArg: isEphemeral ? 'ephemeral' : 'custom',
+      identityArg: 'appkv',
+      customPath: this.options.dirPath,
+      mandatoryKeys: this.options.requiredKeys as Array<keyof T>,
+    });
+
+    if (this.options.envMapping) {
+      console.log(`📦 Processing envMapping for AppData...`);
+      const totalKeys = Object.keys(this.options.envMapping).length;
+      let processedCount = 0;
+      
+      // Process each top-level key in envMapping
+      for (const key in this.options.envMapping) {
+        try {
+          const mappingSpec = this.options.envMapping[key];
+          const specType = mappingSpec === null ? 'null' : 
+                          typeof mappingSpec === 'string' ? mappingSpec : 
+                          typeof mappingSpec === 'object' ? 'nested object' : 
+                          typeof mappingSpec;
+          console.log(`  → Processing key "${key}" with spec: ${specType}`);
+          
+          const evaluated = await evaluateMappingValue(mappingSpec);
+          // Important: Don't skip false, 0, empty string, or null values!
+          // Only skip if explicitly undefined
+          if (evaluated !== undefined) {
+            await this.kvStore.writeKey(key as keyof T, evaluated);
+            processedCount++;
+            const valueType = evaluated === null ? 'null' :
+                            Array.isArray(evaluated) ? 'array' : 
+                            typeof evaluated;
+            const valuePreview = evaluated === null ? 'null' :
+                               typeof evaluated === 'object' ? 
+                                 (Array.isArray(evaluated) ? `[${evaluated.length} items]` : `{${Object.keys(evaluated).length} keys}`) :
+                                 redactSensitiveValue(key, evaluated);
+            console.log(`  ✅ Successfully processed key "${key}" = ${valuePreview} (type: ${valueType})`);
+          } else {
+            console.log(`  ⚠️ Key "${key}" evaluated to undefined, skipping`);
+          }
+        } catch (err) {
+          console.error(`  ❌ Failed to evaluate envMapping for key "${key}":`, err);
+        }
+      }
+      
+      console.log(`📊 EnvMapping complete: ${processedCount}/${totalKeys} keys successfully processed`);
+    }
+
+    // Apply overwrite object after env mapping
+    if (this.options.overwriteObject) {
+      const overwriteKeys = Object.keys(this.options.overwriteObject);
+      console.log(`🔄 Applying overwriteObject with ${overwriteKeys.length} key(s)...`);
+      
+      for (const key of overwriteKeys) {
+        const value = this.options.overwriteObject[key];
+        const valueType = Array.isArray(value) ? 'array' : typeof value;
+        console.log(`  🔧 Overwriting key "${key}" with ${valueType} value`);
+        
+        await this.kvStore.writeKey(
+          key as keyof T,
+          value,
+        );
+      }
+      
+      console.log(`✅ OverwriteObject complete: ${overwriteKeys.length} key(s) overwritten`);
+    }
+
+    this.readyDeferred.resolve();
+    console.log('✨ AppData initialization complete!');
+  }
+
+  /**
+   * returns a kvstore that resides in appdata
+   */
+  public async getKvStore(): Promise<KeyValueStore<T>> {
+    await this.readyDeferred.promise;
+    return this.kvStore;
+  }
+
+  public async logMissingKeys(): Promise<Array<keyof T>> {
+    const kvStore = await this.getKvStore();
+    const missingMandatoryKeys = await kvStore.getMissingMandatoryKeys();
+    if (missingMandatoryKeys.length > 0) {
+      console.log(
+        `The following mandatory keys are missing in the appdata:\n   -> ${missingMandatoryKeys.join(
+          ',\n   -> ',
+        )}`,
+      );
+    } else {
+      console.log('All mandatory keys are present in the appdata');
+    }
+    return missingMandatoryKeys;
+  }
+
+  public async waitForAndGetKey<K extends keyof T>(
+    keyArg: K,
+  ): Promise<T[K] | undefined> {
+    await this.readyDeferred.promise;
+    await this.kvStore.waitForKeysPresent([keyArg]);
+    return this.kvStore.readKey(keyArg);
+  }
+}

ts/npmextra.classes.keyvaluestore.ts

@@ -1,68 +1,222 @@
-import * as plugins from './npmextra.plugins'
+import * as plugins from './npmextra.plugins.js';
-import * as paths from './npmextra.paths'
+import * as paths from './npmextra.paths.js';
 
-export type keyValueStoreTypes = 'path' | 'gitProject' | 'customString'
+import { Task } from '@push.rocks/taskbuffer';
 
+export type TKeyValueStore = 'custom' | 'userHomeDir' | 'ephemeral';
 
-export class KeyValueStore {
+export interface IKvStoreConstructorOptions<T> {
-    type: string // the type of the kvStore
+  typeArg: TKeyValueStore;
-    identity: string // the identity of the kvStore
+  identityArg: string;
-    filePath: string // the filePath of the kvStore
+  customPath?: string;
-    constructor(typeArg: keyValueStoreTypes, identityStringArg?: string) {
+  mandatoryKeys?: Array<keyof T>;
-        // set kvStoreType
+}
-        this.type = typeArg
+
-        this.initIdentity(identityStringArg)
+/**
-        this.initFilePath()
+ * kvStore is a simple key value store to store data about projects between runs
-    }
+ */
-
+export class KeyValueStore<T = any> {
-    /**
+  private dataObject: Partial<T> = {};
-     * reads a keyValueFile from disk
+  private deletedObject: Partial<T> = {};
-     */
+  private mandatoryKeys: Set<keyof T> = new Set();
-    read() {
+  public changeSubject = new plugins.smartrx.rxjs.Subject<Partial<T>>();
-
+
-    }
+  private storedStateString: string = '';
-
+  public syncTask = new Task({
-    /**
+    name: 'syncTask',
-     * writes a key value file to disk
+    buffered: true,
-     */
+    bufferMax: 1,
-    write() {
+    execDelay: 0,
-
+    taskFunction: async () => {
-    }
+      if (this.type !== 'ephemeral') {
-
+        this.dataObject = {
-    /**
+          ...plugins.smartfile.fs.toObjectSync(this.filePath),
-     * wipes a key value store from disk
+          ...this.dataObject,
-     */
+        };
-    wipe() {
+        for (const key of Object.keys(this.deletedObject) as Array<keyof T>) {
-
+          delete this.dataObject[key];
-    }
+        }
-
+        this.deletedObject = {};
-    /**
+        await plugins.smartfile.memory.toFs(
-     * updates a value
+          plugins.smartjson.stringifyPretty(this.dataObject),
-     */
+          this.filePath,
-    update() {
+        );
-
+      }
-    }
+      const newStateString = plugins.smartjson.stringify(this.dataObject);
-
+
-    /**
+      // change detection
-     * computes the identity
+      if (newStateString !== this.storedStateString) {
-     */
+        this.storedStateString = newStateString;
-    private initIdentity(identityStringArg: string) {
+        this.changeSubject.next(this.dataObject);
-        
+      }
-    }
+    },
-
+  });
-    /**
+
-     * computes the filePath 
+  /**
-     */
+   * computes the identity and filePath
-    private initFilePath() {
+   */
-        let baseDir: string
+  private initFilePath = () => {
-        if (this.type === 'customString') {
+    if (this.type === 'ephemeral') {
-            baseDir = paths.kvCusomDir
+      // No file path is needed for ephemeral type
-        } else if (this.type === 'gitProject') {
+      return;
-            baseDir = paths.kvGitDir
+    }
-        } else if (this.type === 'path') {
+    if (this.customPath) {
-            baseDir = paths.kvPathDir
+      // Use custom path if provided
-        }
+      const absolutePath = plugins.smartpath.transform.makeAbsolute(
-        this.filePath = plugins.path.join(baseDir, this.identity + '.json')
+        this.customPath,
-        plugins.smartfile.fs.ensureFileSync(this.filePath,'{}')
+        paths.cwd,
-    }
+      );
+      this.filePath = absolutePath;
+      if (plugins.smartfile.fs.isDirectorySync(this.filePath)) {
+        this.filePath = plugins.path.join(
+          this.filePath,
+          this.identity + '.json',
+        );
+      }
+      plugins.smartfile.fs.ensureFileSync(this.filePath, '{}');
+      return;
+    }
+
+    let baseDir: string;
+    if (this.type === 'userHomeDir') {
+      baseDir = paths.kvUserHomeDirBase;
+    } else {
+      throw new Error('kv type not supported');
+    }
+    this.filePath = plugins.path.join(baseDir, this.identity + '.json');
+    plugins.smartfile.fs.ensureDirSync(baseDir);
+    plugins.smartfile.fs.ensureFileSync(this.filePath, '{}');
+  };
+
+  // if no custom path is provided, try to store at home directory
+  public type: TKeyValueStore;
+  public identity: string;
+  public filePath?: string;
+  private customPath?: string; // Optionally allow custom path
+
+  /**
+   * the constructor of keyvalue store
+   * @param typeArg
+   * @param identityArg
+   * @param customPath Optional custom path for the keyValue store
+   */
+  constructor(optionsArg: IKvStoreConstructorOptions<T>) {
+    if (optionsArg.customPath && optionsArg.typeArg !== 'custom') {
+      throw new Error('customPath can only be provided if typeArg is custom');
+    }
+    if (optionsArg.typeArg === 'custom' && !optionsArg.customPath) {
+      throw new Error('customPath must be provided if typeArg is custom');
+    }
+    this.type = optionsArg.typeArg;
+    this.identity = optionsArg.identityArg;
+    this.customPath = optionsArg.customPath; // Store custom path if provided
+    this.initFilePath();
+    if (optionsArg.mandatoryKeys) {
+      this.setMandatoryKeys(optionsArg.mandatoryKeys);
+    }
+  }
+
+  /**
+   * reads all keyValue pairs at once and returns them
+   */
+  public async readAll(): Promise<Partial<T>> {
+    await this.syncTask.trigger();
+    return this.dataObject;
+  }
+
+  /**
+   * reads a keyValueFile from disk
+   */
+  public async readKey<K extends keyof T>(keyArg: K): Promise<T[K]> {
+    await this.syncTask.trigger();
+    return this.dataObject[keyArg] as T[K];
+  }
+
+  /**
+   * writes a specific key to the keyValueStore
+   */
+  public async writeKey<K extends keyof T>(
+    keyArg: K,
+    valueArg: T[K],
+  ): Promise<void> {
+    await this.writeAll({
+      [keyArg]: valueArg,
+    } as unknown as Partial<T>);
+  }
+
+  public async deleteKey<K extends keyof T>(keyArg: K): Promise<void> {
+    this.deletedObject[keyArg] = this.dataObject[keyArg];
+    await this.syncTask.trigger();
+  }
+
+  /**
+   * writes all keyValue pairs in the object argument
+   */
+  public async writeAll(keyValueObject: Partial<T>): Promise<void> {
+    this.dataObject = { ...this.dataObject, ...keyValueObject };
+    await this.syncTask.trigger();
+  }
+
+  /**
+   * wipes a key value store from disk
+   */
+  public async wipe(): Promise<void> {
+    this.dataObject = {};
+    if (this.type !== 'ephemeral') {
+      await plugins.smartfile.fs.remove(this.filePath);
+    }
+  }
+
+  /**
+   * resets the KeyValueStore to the initial state by syncing first, deleting all keys, and then triggering a sync again
+   */
+  public async reset(): Promise<void> {
+    await this.syncTask.trigger(); // Sync to get the latest state
+
+    // Delete all keys from the dataObject and add them to deletedObject
+    for (const key of Object.keys(this.dataObject) as Array<keyof T>) {
+      this.deletedObject[key] = this.dataObject[key];
+      delete this.dataObject[key];
+    }
+
+    await this.syncTask.trigger(); // Sync again to reflect the deletion
+  }
+
+  private setMandatoryKeys(keys: Array<keyof T>) {
+    keys.forEach((key) => this.mandatoryKeys.add(key));
+  }
+
+  public async getMissingMandatoryKeys(): Promise<Array<keyof T>> {
+    await this.readAll();
+    return Array.from(this.mandatoryKeys).filter(
+      (key) => !(key in this.dataObject),
+    );
+  }
+
+  public async waitForKeysPresent<K extends keyof T>(
+    keysArg: K[],
+  ): Promise<void> {
+    const missingKeys = keysArg.filter((keyArg) => !this.dataObject[keyArg]);
+    if (missingKeys.length === 0) {
+      return;
+    }
+    return new Promise<void>((resolve, reject) => {
+      const subscription = this.changeSubject.subscribe(() => {
+        const missingKeys = keysArg.filter(
+          (keyArg) => !this.dataObject[keyArg],
+        );
+        if (missingKeys.length === 0) {
+          subscription.unsubscribe();
+          resolve();
+        }
+      });
+    });
+  }
+
+  public async waitForAndGetKey<K extends keyof T>(
+    keyArg: K,
+  ): Promise<T[K] | undefined> {
+    await this.waitForKeysPresent([keyArg]);
+    return this.readKey(keyArg);
+  }
 }

ts/npmextra.classes.npmextra.ts

@@ -1,70 +1,79 @@
-import * as plugins from './npmextra.plugins'
+import * as plugins from './npmextra.plugins.js';
-import * as paths from './npmextra.paths'
+import * as paths from './npmextra.paths.js';
 
 /**
  * Npmextra class allows easy configuration of tools
  */
 export class Npmextra {
-    cwd: string
+  cwd: string;
-    lookupPath: string
+  lookupPath: string;
-    npmextraJsonExists: boolean
+  npmextraJsonExists: boolean;
-    npmextraJsonData: any
+  npmextraJsonData: any;
 
-    /**
+  /**
-     * creates instance of Npmextra
+   * creates instance of Npmextra
-     */
+   */
-    constructor(cwdArg?: string) {
+  constructor(cwdArg?: string) {
-        if (cwdArg) {
+    if (cwdArg) {
-            this.cwd = cwdArg
+      this.cwd = cwdArg;
-        } else {
+    } else {
-            this.cwd = paths.cwd
+      this.cwd = paths.cwd;
-        }
-        this.checkLookupPath()
-        this.checkNpmextraJsonExists()
-        this.checkNpmextraJsonData()
     }
+    this.checkLookupPath();
+    this.checkNpmextraJsonExists();
+    this.checkNpmextraJsonData();
+  }
 
-    /**
+  /**
-     * merges the supplied options with the ones from npmextra.json
+   * merges the supplied options with the ones from npmextra.json
-     */
+   */
-    dataFor<IToolConfig>(toolnameArg: string, defaultOptionsArg: any): IToolConfig {
+  dataFor<IToolConfig>(
-        let npmextraToolOptions
+    toolnameArg: string,
-        if (this.npmextraJsonData[toolnameArg]) {
+    defaultOptionsArg: any,
-            npmextraToolOptions = this.npmextraJsonData[toolnameArg]
+  ): IToolConfig {
-        } else {
+    let npmextraToolOptions;
-            npmextraToolOptions = {}
+    if (this.npmextraJsonData[toolnameArg]) {
-        }
+      npmextraToolOptions = this.npmextraJsonData[toolnameArg];
-        let mergedOptions = plugins.lodash.merge({}, defaultOptionsArg, npmextraToolOptions)
+    } else {
-        return mergedOptions
+      npmextraToolOptions = {};
     }
+    let mergedOptions = {
+      ...defaultOptionsArg,
+      ...npmextraToolOptions,
+    };
+    return mergedOptions;
+  }
 
-    /**
+  /**
-     * checks if the JSON exists
+   * checks if the JSON exists
-     */
+   */
-    private checkNpmextraJsonExists() {
+  private checkNpmextraJsonExists() {
-        this.npmextraJsonExists = plugins.smartfile.fs.fileExistsSync(this.lookupPath)
+    this.npmextraJsonExists = plugins.smartfile.fs.fileExistsSync(
+      this.lookupPath,
+    );
+  }
+
+  /**
+   * gets lookupPath
+   */
+  private checkLookupPath() {
+    if (this.cwd) {
+      this.lookupPath = plugins.path.join(this.cwd, 'npmextra.json');
+    } else {
+      this.lookupPath = paths.configFile;
     }
+  }
 
-    /**
+  /**
-     * gets lookupPath
+   * get npmextraJsonData
-     */
+   */
-    private checkLookupPath() {
+  private checkNpmextraJsonData() {
-        if (this.cwd) {
+    if (this.npmextraJsonExists) {
-            this.lookupPath = plugins.path.join(this.cwd, 'npmextra.json')
+      this.npmextraJsonData = plugins.smartfile.fs.toObjectSync(
-        } else {
+        this.lookupPath,
-            this.lookupPath = paths.configFile
+      );
-        };
+    } else {
+      this.npmextraJsonData = {};
     }
-
+  }
-    /**
-     * get npmextraJsonData
-     */
-    private checkNpmextraJsonData() {
-        if (this.npmextraJsonExists) {
-            this.npmextraJsonData = plugins.smartfile.fs.toObjectSync(this.lookupPath)
-        } else {
-            this.npmextraJsonData = {}
-        }
-    }
-
 }

ts/npmextra.paths.ts

@@ -1,14 +1,22 @@
-import * as plugins from './npmextra.plugins'
+import * as plugins from './npmextra.plugins.js';
 
 // directories
-export let cwd = process.cwd()
+export let cwd = process.cwd();
-export let packageDir = plugins.path.join(__dirname,'../')
+export let packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '../',
+);
 
+// ----------------------
 // keyValueStore specific
-export let kvBase = '~/.npmextra/kv'
+// ----------------------
-export let kvCusomDir = plugins.path.join(kvBase, 'custom')
+
-export let kvGitDir = plugins.path.join(kvBase, 'git')
+export let home = plugins.smartpath.get.home();
-export let kvPathDir = plugins.path.join(kvBase, 'path')
+
+/**
+ * keyValue base path
+ */
+export let kvUserHomeDirBase = plugins.path.join(home, '.npmextra/kv');
 
 // files
-export let configFile = plugins.path.join(cwd,'npmextra.json')
+export let configFile = plugins.path.join(cwd, 'npmextra.json');

ts/npmextra.plugins.ts

@@ -1,6 +1,25 @@
-import 'typings-global'
+import * as tsclass from '@tsclass/tsclass';
-export import beautylog = require('beautylog')
+
-export import lodash = require('lodash')
+export { tsclass };
-export import path = require('path')
+
-export import smartfile = require('smartfile')
+import * as qenv from '@push.rocks/qenv';
-export import q = require('q')
+import * as smartlog from '@push.rocks/smartlog';
+import * as path from 'path';
+import * as smartfile from '@push.rocks/smartfile';
+import * as smartjson from '@push.rocks/smartjson';
+import * as smartpath from '@push.rocks/smartpath';
+import * as smartpromise from '@push.rocks/smartpromise';
+import * as smartrx from '@push.rocks/smartrx';
+import * as taskbuffer from '@push.rocks/taskbuffer';
+
+export {
+  qenv,
+  smartlog,
+  path,
+  smartfile,
+  smartjson,
+  smartpath,
+  smartpromise,
+  smartrx,
+  taskbuffer,
+};

tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "useDefineForClassFields": false,
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "verbatimModuleSyntax": true,
+    "baseUrl": ".",
+    "paths": {}
+  },
+  "exclude": ["dist_*/**/*.d.ts"]
+}

tslint.json

@@ -1,3 +0,0 @@
-{
-    "extends": "tslint-config-standard"
-}