v1.11.4

.smartconfig.json

@@ -1,5 +1,5 @@
 {
-  "gitzone": {
+  "@git.zone/cli": {
     "projectType": "npm",
     "module": {
       "githost": "code.foss.global",
@@ -21,10 +21,16 @@
         "module-management",
         "developer-tools"
       ]
+    },
+    "release": {
+      "registries": [
+        "https://verdaccio.lossless.digital",
+        "https://registry.npmjs.org"
+      ],
+      "accessLevel": "public"
     }
   },
-  "npmci": {
-    "npmGlobalTools": [],
-    "npmAccessLevel": "public"
+  "@ship.zone/szci": {
+    "npmGlobalTools": []
   }
 }

.vscode/settings.json

@@ -1,7 +1,7 @@
 {
   "json.schemas": [
     {
-      "fileMatch": ["/npmextra.json"],
+      "fileMatch": ["/.smartconfig.json"],
       "schema": {
         "type": "object",
         "properties": {

changelog.md

@@ -1,5 +1,129 @@
 # Changelog
 
+## 2026-03-24 - 1.11.4 - fix(config)
+rename npmextra configuration to .smartconfig.json and align publish packaging with updated config handling
+
+- replaces packaged config file references from npmextra.json to .smartconfig.json
+- updates publish module typings and null checks for tsPublishJson, package info, and file paths
+- bumps build and runtime dependencies to newer compatible versions
+- simplifies tsconfig.json by removing unused baseUrl and paths settings
+- refreshes README content to document current CLI, registry, and package publishing behavior
+
+## 2026-03-24 - 1.11.3 - fix(config)
+replace npmextra with smartconfig for base registry resolution
+
+- Switch the base registry source from npmextra.json to smartconfig.json for publish configuration.
+- Update plugin imports and runtime config loading to use @push.rocks/smartconfig.
+- Adjust packaged files and error messages to reference smartconfig.json consistently.
+
+## 2026-03-05 - 1.11.2 - fix(deps)
+bump @push.rocks/smartshell dependency to ^3.3.7 and update package version to 1.11.1
+
+- package.json: version 1.11.0 -> 1.11.1
+- package.json: @push.rocks/smartshell ^3.3.0 -> ^3.3.7
+- ts/00_commitinfo_data.ts: version updated to 1.11.1
+- changelog.md: added entry documenting the dependency bump and patch release
+
+## 2026-03-05 - 1.11.1 - fix(deps)
+bump @push.rocks/smartshell dependency to ^3.3.7
+
+- package.json: @push.rocks/smartshell ^3.3.0 -> ^3.3.7
+- Only dependency version updated (patch-level)
+
+## 2025-12-16 - 1.11.0 - feat(publish)
+add registry resolution (useBase/extendBase) and migrate filesystem operations to async SmartFs; improve publish flow and docs
+
+- Add resolveRegistries supporting 'useBase' and 'extendBase' and explicit registries; reads base registries from npmextra.json at @git.zone/cli.release
+- Migrate sync smartfile APIs to async @push.rocks/smartfs and expose smartfs and npmextra via plugins
+- Ensure publish directory is recreated cleanly and use async file copy/read/write for package, tsconfig, readme and license
+- Handle empty registries by skipping publish with a warning and throw a clear error if useBase/extendBase is used but no base registries configured
+- Publish now normalizes registry URLs and supports accessLevel per-registry when running pnpm publish
+- Update README: registry configuration docs, issue reporting/security section and various wording/formatting improvements; bump several dependencies/devDependencies
+
+## 2025-12-15 - 1.10.4 - fix(.serena)
+cleanup: remove .serena assistant memories, cache and project config
+
+- Removed multiple .serena/memories markdown files (code_style_conventions.md, logging_improvements_2025.md, project_overview.md, smartrequest_api_update_2025.md, suggested_commands.md, task_completion_checklist.md) — these were assistant metadata/notes
+- Removed .serena/project.yml (project configuration for the assistant)
+- Removed .serena/cache/typescript/document_symbols_cache_v23-06-25.pkl (generated symbol cache)
+
+## 2025-08-18 - 1.10.3 - fix(devDependencies)
+Bump development dependencies and add local Claude settings
+
+- Bumped @git.zone/tsbuild from ^2.6.4 to ^2.6.6 in package.json
+- Bumped @push.rocks/smartnpm from ^2.0.4 to ^2.0.6 in package.json
+- Added .claude/settings.local.json for local Claude permissions/configuration
+
+## 2025-08-18 - 1.10.2 - fix(dependencies)
+Update dependency versions and add local Claude settings
+
+- Bump devDependency @git.zone/tstest from ^2.3.2 to ^2.3.4
+- Bump dependency @push.rocks/smartfile from ^11.2.5 to ^11.2.7
+- Bump dependency @push.rocks/smartrequest from ^4.2.1 to ^4.2.2
+- Bump dependency @push.rocks/smartshell from ^3.2.3 to ^3.3.0
+- Add .claude/settings.local.json (local Claude permissions/config)
+
+## 2025-08-08 - 1.10.1 - fix(core)
+Refactor smartrequest usage, update dependency versions, and improve documentation and tests
+
+- Refactored getFiles method in classes.giteaassets to use SmartRequest builder and handle branch query parameters.
+- Updated package.json dependency versions for smartfile, smartlog, tsbuild, tsbundle, and tstest.
+- Added pnpm-workspace.yaml configuration for onlyBuiltDependencies.
+- Enhanced readme with detailed usage instructions, CI/CD integration examples, and advanced feature descriptions.
+- Updated test files to import tapbundle from @git.zone/tstest instead of @push.rocks/tapbundle.
+- Added .claude/settings.local.json for managing local permissions.
+
+## 2025-08-08 - 1.10.0 - feat(logging)
+Enhance logging and module publishing with color-coded output, progress tracking, and improved CLI startup
+
+- Refactored logging to introduce color-coded symbols and helper functions (logInfo, logWarn, logSuccess, logBuild, logPublish, etc.)
+- Added visual components such as headers, separators, and progress indicators for better operational visibility
+- Integrated enhanced logging into module publishing and CLI startup, replacing generic console logs
+- Updated various configuration and documentation files to reflect new code style conventions and dependency updates
+
+## 2025-01-02 - 1.9.1 - fix(publishmodule)
+Fix incorrect CLI script path during publish module creation
+
+- Updated the `createBinCliSetup` method to correctly adjust the CLI script path.
+- Replaced path in base64-decoded CLI file content from './dist_ts/index.js' to './dist_<packageSubFolder>/index.js'.
+
+## 2025-01-02 - 1.9.0 - feat(core)
+Refactor gitea asset handling and module initialization
+
+- Introduced GiteaAssets class to handle gitea asset fetching.
+- Updated TsPublish and PublishModule classes to use GiteaAssets.
+- Fixed queryParams in getFiles method of GiteaAssets.
+
+## 2025-01-01 - 1.8.0 - feat(core)
+Added GiteaAssets class for managing files in Gitea repositories
+
+- Introduced GiteaAssets class to handle file retrieval from Gitea repositories.
+- Added tests for GiteaAssets implementation.
+- Updated plugins module to include smartrequest for HTTP requests.
+
+## 2024-11-05 - 1.7.7 - fix(core)
+Fix dependency resolution in package initialization
+
+- Corrected the resolution of dependencies from tspublish.json against monorepo's package.json.
+- Ensures unlisted dependencies in monorepo's package.json default to its version.
+
+## 2024-11-05 - 1.7.6 - fix(tspublish)
+Fix the logging of the number of found publish modules
+
+- Corrected the way the number of publish modules is logged by using Object.keys(publishModules).length instead of publishModules.length.
+
+## 2024-11-05 - 1.7.5 - fix(core)
+Fix issue with tspublish.json name validation in TsPublish class
+
+- Resolved incorrect JSON parsing and validation for 'name' property in tspublish.json in the TsPublish.publish method.
+- Removed redundant JSON parse from plugin.smartfile.fs.toStringSync in publish method.
+
+## 2024-11-05 - 1.7.4 - fix(classes.tspublish)
+Refactor getModuleSubDirs method to streamline name validation for publish modules
+
+- Moved the check for the presence of the 'name' field in tspublish.json from getModuleSubDirs to the publish method.
+- Added log warning and continue flow if 'name' is not found during the publish process.
+
 ## 2024-11-05 - 1.7.3 - fix(TsPublish)
 Add validation for tspublish.json name field
 

license

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tspublish",
-  "version": "1.7.3",
+  "version": "1.11.4",
   "private": false,
   "description": "A tool to publish multiple, concise, and small packages from monorepos, specifically for TypeScript projects within a git environment.",
   "main": "dist_ts/index.js",
@@ -9,20 +9,19 @@
   "author": "Task Venture Capital GmbH",
   "license": "MIT",
   "scripts": {
-    "test": "(tstest test/ --web)",
+    "test": "(tstest test/ --verbose --testlog --timeout 30)",
     "build": "(tsbuild --web --allowimplicitany)",
     "buildDocs": "(tsdoc)"
   },
   "bin": {
-    "tspublish": "cli.js"
+    "tspublish": "./cli.js"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.1.85",
-    "@git.zone/tsbundle": "^2.1.0",
-    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.44",
-    "@push.rocks/tapbundle": "^5.0.15",
-    "@types/node": "^22.8.7"
+    "@git.zone/tsbuild": "^4.4.0",
+    "@git.zone/tsbundle": "^2.10.0",
+    "@git.zone/tsrun": "^2.0.1",
+    "@git.zone/tstest": "^3.5.1",
+    "@types/node": "^25.5.0"
   },
   "repository": {
     "type": "git",
@@ -44,17 +43,21 @@
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
-    "npmextra.json",
+    ".smartconfig.json",
     "readme.md"
   ],
   "dependencies": {
-    "@push.rocks/smartcli": "^4.0.11",
+    "@push.rocks/consolecolor": "^2.0.3",
+    "@push.rocks/smartcli": "^4.0.20",
+    "@push.rocks/smartconfig": "^6.0.1",
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartfile": "^11.0.21",
-    "@push.rocks/smartlog": "^3.0.7",
-    "@push.rocks/smartnpm": "^2.0.4",
-    "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartshell": "^3.0.6"
+    "@push.rocks/smartfile": "^13.1.2",
+    "@push.rocks/smartfs": "^1.5.0",
+    "@push.rocks/smartlog": "^3.2.1",
+    "@push.rocks/smartnpm": "^2.0.6",
+    "@push.rocks/smartpath": "^6.0.0",
+    "@push.rocks/smartrequest": "^5.0.1",
+    "@push.rocks/smartshell": "^3.3.8"
   },
   "keywords": [
     "typescript",
@@ -67,5 +70,6 @@
     "modularity",
     "module-management",
     "developer-tools"
-  ]
+  ],
+  "packageManager": "pnpm@10.11.0+sha512.6540583f41cc5f628eb3d9773ecee802f4f9ef9923cc45b69890fb47991d4b092964694ec3a4f738a420c918a333062c8b925d312f42e4f0c263eb603551f977"
 }

readme.md

@@ -1,193 +1,349 @@
-# @git.zone/tspublish
+# @git.zone/tspublish 🚀
 
-publish multiple, concise and small packages from monorepos
+> **Effortlessly publish multiple TypeScript packages from your monorepo**
 
-## Install
+[![npm version](https://img.shields.io/npm/v/@git.zone/tspublish.svg)](https://www.npmjs.com/package/@git.zone/tspublish)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-To install `@git.zone/tspublish`, you can use npm. To use the latest stable version, run:
+## 🌟 What is tspublish?
+
+`@git.zone/tspublish` is a powerful CLI tool and library for managing and publishing multiple TypeScript packages from a monorepo. It automates the tedious parts of package publishing — discovery, dependency resolution, building, version validation, and multi-registry publishing — while giving you full control over the process. Whether you're maintaining a suite of microservices, a component library, or any collection of related packages, tspublish makes your life dramatically easier.
+
+## Issue Reporting and Security
+
+For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who sign and comply with our contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
+
+### ✨ Key Features
+
+- 📦 **Automatic Package Discovery** — Scans your monorepo for publishable `ts*` directories
+- 🎨 **Beautiful CLI Output** — Color-coded logging with progress bars and status indicators
+- 🔍 **Version Collision Detection** — Prevents accidental overwrites by checking the registry first
+- 🏗️ **Build Integration** — Automatically compiles TypeScript before publishing via `@git.zone/tsbuild`
+- 🎯 **Smart Dependency Management** — Inherits dependency versions from your monorepo's `package.json`
+- 🌐 **Multi-Registry Support** — Publish to npm, GitHub Packages, Gitea, or private registries
+- 🔗 **Base Registry Inheritance** — Use `useBase` / `extendBase` to inherit registries from `.smartconfig.json`
+- ⚡ **CLI Binary Support** — Automatically generates `cli.js` wrappers for publishable CLI packages
+- 🧹 **Clean Builds** — Creates isolated `dist_publish_*` directories for each package
+
+## 📥 Installation
 
 ```bash
-npm install @git.zone/tspublish
+# Using pnpm (recommended)
+pnpm add -D @git.zone/tspublish
+
+# Global installation for CLI usage
+pnpm add -g @git.zone/tspublish
 ```
 
-Alternatively, if you are using yarn, the equivalent command would be:
+## 🚀 Quick Start
 
-```bash
-yarn add @git.zone/tspublish
-```
+### 1️⃣ Structure Your Monorepo
 
-These commands will add `@git.zone/tspublish` as a dependency in your `package.json` file and install the package into your `node_modules` directory.
-
-## Usage
-
-`@git.zone/tspublish` is designed to manage the publishing of multiple, small-scale packages within monorepos. The following sections will guide you through its usage, from setting up your environment to effectively publishing packages.
-
-### Getting Started with TypeScript and Module Setup
-
-`@git.zone/tspublish` works with monorepos that are organized using TypeScript. The package structure should follow a convention where each submodule intended for publishing is located in a directory prefixed with `ts`, for example, `tsModuleName`. Each submodule directory should contain a `tspublish.json` file to correctly configure the package to be published separately. This file is critical for the `tspublish` process to identify valid package directories and should also include necessary metadata for the package.
-
-Your monorepo structure might resemble:
+Organize your packages using directories that start with `ts`:
 
 ```
-my-monorepo/
-├── ts-package1/
-│   ├── src/
-│   ├── tspublish.json
-├── ts-package2/
-│   ├── src/
-│   ├── tspublish.json
+my-awesome-monorepo/
+├── package.json            # Main monorepo package.json (version is inherited)
+├── tsconfig.json           # Shared TypeScript config
+├── .smartconfig.json       # Optional: base registry configuration
+├── ts_core/                # Core package
+│   ├── index.ts            # Entry point
+│   ├── readme.md           # Package-specific documentation
+│   └── tspublish.json      # Publishing configuration
+├── ts_utils/               # Utilities package
+│   ├── index.ts
+│   ├── readme.md
+│   └── tspublish.json
+└── ts_cli/                 # CLI package
+    ├── index.ts
+    ├── readme.md
+    └── tspublish.json
 ```
 
-### Configuring `tspublish.json`
+### 2️⃣ Configure Each Package
 
-Each submodule must include a `tspublish.json` within its directory. This JSON file should include essential details for your publishable package, including its dependencies. Here's a basic example of what `tspublish.json` could look like:
+Create a `tspublish.json` in each publishable directory:
 
 ```json
 {
-  "name": "@myorg/ts-package1",
-  "dependencies": {
-    "some-dependency": "^1.0.0"
-  }
+  "name": "@myorg/core",
+  "order": 1,
+  "dependencies": [
+    "@push.rocks/smartpromise",
+    "@push.rocks/smartfile"
+  ],
+  "registries": [
+    "registry.npmjs.org:public"
+  ],
+  "bin": []
 }
 ```
 
-### Running the CLI
+#### Configuration Options
 
-`@git.zone/tspublish` includes a CLI that simplifies the publishing process. Begin by importing the CLI runner in a script within your project:
+| Field | Type | Description |
+|-------|------|-------------|
+| `name` | `string` | The published package name (e.g., `@myorg/core`) |
+| `order` | `number` | Build order for interdependent packages (lower builds first) |
+| `dependencies` | `string[]` | Dependencies to include — versions are resolved from the monorepo's `package.json` |
+| `registries` | `string[]` | Target registries with access level (format: `"url:accessLevel"`) |
+| `bin` | `string[]` | CLI executable names (generates a `cli.js` wrapper automatically) |
 
-```typescript
-import { runCli } from '@git.zone/tspublish';
+### 3️⃣ Publish
 
-runCli();
+```bash
+# From your monorepo root
+npx tspublish
 ```
 
-This function call orchestrates the publishing operation. It reads each directory prefixed with `ts`, looks for a `tspublish.json`, and creates an individual package based on the gathered data.
+That's it! tspublish will discover all `ts*` directories containing `tspublish.json`, build them in order, validate versions against the registry, and publish.
 
-### Core Features
+## 🎯 Advanced Usage
 
-#### Publishing Modules
+### Registry Configuration
 
-The core functionality provided by `@git.zone/tspublish` involves processing directories to check for valid submodules that are ready to be published. This occurs via the `publish` method in `TsPublish` class. This method does the following:
+TSPublish offers three approaches for configuring target registries:
 
-- **Reads all directories** within the specified monorepo path.
-- **Identifies directories** that start with `ts` and validates the presence of `tspublish.json`.
-- **Logs** information about found packages for user awareness and debugging.
-- **Checks for collisions** with existing versions on the npm registry to prevent overriding published versions.
+#### 1. Explicit Registries
+
+Define specific registries directly in `tspublish.json`:
+
+```json
+{
+  "registries": [
+    "registry.npmjs.org:public",
+    "npm.pkg.github.com:private"
+  ]
+}
+```
+
+The format is `"registryUrl:accessLevel"` where `accessLevel` is `public` or `private`.
+
+#### 2. Use Base Configuration (`useBase`)
+
+Inherit registries from your project's `.smartconfig.json` (managed by `@git.zone/cli`):
+
+```json
+{
+  "registries": ["useBase"]
+}
+```
+
+This reads from `.smartconfig.json` at the key `@git.zone/cli.release.registries`.
+
+#### 3. Extend Base Configuration (`extendBase`)
+
+Start with base registries and add or remove specific ones:
+
+```json
+{
+  "registries": [
+    "extendBase",
+    "custom-registry.example.com:public",
+    "-https://registry.npmjs.org"
+  ]
+}
+```
+
+The `-` prefix excludes a registry from the base configuration. All other entries (besides `extendBase`) are added.
+
+#### Empty Registries
+
+If `registries` is an empty array `[]`, the package will be built but **not published** — useful for internal-only packages that other packages depend on.
+
+### Build Order Management
+
+When packages depend on each other, use the `order` field to control build sequence:
+
+```json
+// ts_core/tspublish.json — builds first
+{
+  "name": "@myorg/core",
+  "order": 1,
+  "dependencies": [],
+  "registries": ["useBase"],
+  "bin": []
+}
+
+// ts_utils/tspublish.json — builds second, depends on core
+{
+  "name": "@myorg/utils",
+  "order": 2,
+  "dependencies": ["@myorg/core"],
+  "registries": ["useBase"],
+  "bin": []
+}
+```
+
+### CLI Binary Packages
+
+For packages that ship CLI tools, specify the binary names in the `bin` array:
+
+```json
+{
+  "name": "@myorg/cli",
+  "order": 3,
+  "dependencies": ["commander", "@myorg/core"],
+  "registries": ["registry.npmjs.org:public"],
+  "bin": ["my-cli", "my-tool"]
+}
+```
+
+TSPublish will:
+1. Fetch the standard `cli.js` template from the `@git.zone/cli` assets repository
+2. Adjust the import path to point to the correct `dist_*` folder
+3. Configure the `bin` field in the generated `package.json`
+
+### Programmatic Usage
 
 ```typescript
 import { TsPublish } from '@git.zone/tspublish';
 
-const tspublish = new TsPublish();
-await tspublish.publish('/path/to/your/monorepo');
+const publisher = new TsPublish();
+await publisher.publish(process.cwd());
 ```
 
-#### Package Initialization
-
-Once valid submodules are identified, the `init` method in the `PublishModule` class initializes the publish module. This includes:
-
-- Parsing `tspublish.json` for metadata.
-- Constructing full paths for necessary operations.
-- Verifying package existence to avoid duplication.
+#### Custom Publishing Pipeline
 
 ```typescript
-import { PublishModule } from '@git.zone/tspublish';
+import { TsPublish, PublishModule } from '@git.zone/tspublish';
 
-const publishModule = new PublishModule({
-  monoRepoDir: '/path/to/monorepo',
-  packageSubFolder: 'ts-package1',
-});
+const publisher = new TsPublish();
+const modules = await publisher.getModuleSubDirs('./my-monorepo');
 
-await publishModule.init();
-```
-
-#### Creating `package.json`
-
-Part of the publishing process involves automatically creating a `package.json` tailored to each submodule. This dynamically generated JSON will incorporate dependencies from `tspublish.json` and associate them with the latest version of `tsbuild` from the registry:
-
-```typescript
-await publishModule.createPackageJson();
-```
-
-This creates a structured `package.json` which includes scripts to build your TypeScript files before publishing.
-
-#### Constructing Publish-ready Directory
-
-After all configurations are verified and the `package.json` is created, the submodule is ready to be published. This step involves setting up a `dist_publish_` directory specific to each module:
-
-```typescript
-await publishModule.createPublishModuleDir();
-```
-
-The above method ensures that each module's source files are copied and prepared under a dedicated directory meant for packaging and distribution.
-
-### Logging and Debugging
-
-The package includes a structured logging mechanism using `smartlog` which provides insights into the publishing process, helping in runtime debugging and status tracking of operations:
-
-```typescript
-import { logger } from '@git.zone/tspublish/logging';
-
-logger.log('info', 'Publishing process initialized');
-```
-
-This powerful logging helps in tracking the status of each step and understanding potential issues during the operations.
-
-### Testing with tapbundle
-
-To ensure that your publishing workflow is functioning correctly, you can utilize the test suite set up with `tapbundle`. This library facilitates behavior-driven testing for your monorepo. Below is a basic test setup to verify the import and initial function accessibility of `@git.zone/tspublish`:
-
-```typescript
-import { expect, tap } from '@push.rocks/tapbundle';
-import * as tspublish from '@git.zone/tspublish';
-
-tap.test('Should run the CLI without errors', async () => {
-  await tspublish.runCli();
-  expect(tspublish).toBeTruthy();
-});
-
-tap.start();
-```
-
-### Comprehensive usage example
-
-Let's combine all the steps into a complete example where you prepare a monorepo, configure each module, and execute the publishing workflow.
-
-Suppose you have a project structure as follows:
-
-```plaintext
-my-monorepo/
-├── ts-package1/
-│   ├── src/
-│   ├── tspublish.json
-├── ts-package2/
-│   ├── src/
-│   ├── tspublish.json
-```
-
-Follow these steps:
-
-1. Ensure each package has `tspublish.json` properly configured with necessary metadata.
-2. Create a CLI script such as `publish.js`:
-
-```typescript
-import { runCli } from '@git.zone/tspublish';
-
-runCli()
-  .then(() => {
-    console.log('Publishing completed successfully');
-  })
-  .catch((error) => {
-    console.error('Error during publishing:', error);
+for (const [name, config] of Object.entries(modules)) {
+  const mod = new PublishModule(publisher, {
+    monoRepoDir: './my-monorepo',
+    packageSubFolder: name,
   });
+
+  await mod.init();                   // Resolve deps, validate version
+  await mod.createPublishModuleDir(); // Scaffold dist_publish_* directory
+  await mod.build();                  // Compile TypeScript
+  await mod.publish();                // Publish to registries
+}
 ```
 
-3. Execute your CLI script:
+## 🔧 How It Works
 
-```bash
-node publish.js
+```
+┌──────────────────────────────────────────────────────────┐
+│                   tspublish pipeline                     │
+├──────────────────────────────────────────────────────────┤
+│                                                          │
+│  1. 🔍 Discovery                                        │
+│     Scan for ts* directories containing tspublish.json   │
+│                                                          │
+│  2. 📋 Preparation                                      │
+│     Create dist_publish_* with generated package.json,   │
+│     tsconfig.json, source files, readme, and license     │
+│                                                          │
+│  3. 🔨 Build                                            │
+│     Run `tsbuild tsfolders` in the publish directory     │
+│                                                          │
+│  4. ✅ Validation                                       │
+│     Check npm registry — abort if version already exists │
+│                                                          │
+│  5. 🚀 Publish                                          │
+│     pnpm publish to each configured registry             │
+│                                                          │
+└──────────────────────────────────────────────────────────┘
 ```
 
-Your script will call `runCli`, which will traverse each `ts-package`, verify their publish readiness, and handle individual publishing processes.
+For each discovered module, tspublish:
 
-By following these comprehensive guidelines and utilizing the structured approach provided by `@git.zone/tspublish`, you can efficiently manage and publish multiple sub-packages from within a monorepo, facilitating organized, modular package management in projects of any scale.
-undefined
+1. **Discovers** all directories starting with `ts` that contain a `tspublish.json`
+2. **Resolves dependencies** from the monorepo's `package.json`, using the monorepo version for packages not found in `dependencies`
+3. **Creates an isolated publish directory** (`dist_publish_<folder>`) with a generated `package.json`, `tsconfig.json`, source code copy, readme, and license
+4. **Builds** the package using `pnpm run build` (which calls `tsbuild tsfolders`)
+5. **Validates** against the target registry — if the name+version already exists, it exits with an error
+6. **Publishes** to each configured registry via `pnpm publish`
+
+## 📚 API Reference
+
+### TsPublish
+
+```typescript
+class TsPublish {
+  /** Publish all discovered modules in a monorepo directory */
+  async publish(monorepoDirPath: string): Promise<void>;
+
+  /** Discover and return all publishable modules with their tspublish.json configs */
+  async getModuleSubDirs(dirPath: string): Promise<Record<string, ITsPublishJson>>;
+}
+```
+
+### PublishModule
+
+```typescript
+class PublishModule {
+  /** Initialize: resolve dependencies, validate version against registry */
+  async init(): Promise<void>;
+
+  /** Create the dist_publish_* directory with all necessary files */
+  async createPublishModuleDir(): Promise<void>;
+
+  /** Build the TypeScript package */
+  async build(): Promise<void>;
+
+  /** Publish to all configured registries */
+  async publish(): Promise<void>;
+}
+```
+
+### ITsPublishJson
+
+```typescript
+interface ITsPublishJson {
+  name: string;           // Published package name
+  order: number;          // Build sequence (lower = earlier)
+  dependencies: string[]; // Dependencies to include from monorepo
+  registries: string[];   // Target registries ("url:accessLevel", "useBase", or "extendBase")
+  bin: string[];          // CLI binary names
+}
+```
+
+### GiteaAssets
+
+```typescript
+class GiteaAssets {
+  constructor(options: { giteaBaseUrl: string; token?: string });
+
+  /** Fetch files from a Gitea repository directory */
+  async getFiles(owner: string, repo: string, directory: string, branch?: string): Promise<IRepoFile[]>;
+
+  /** Get the standard cli.js entry file template */
+  async getBinCliEntryFile(): Promise<IRepoFile>;
+}
+```
+
+## 🐛 Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| **"Package X already exists with version Y"** | Bump the version in your monorepo's `package.json` |
+| **No publish modules found** | Ensure directories start with `ts` and contain a valid `tspublish.json` |
+| **Build failures** | Check TypeScript errors — tspublish runs `tsbuild tsfolders` in the generated directory |
+| **useBase/extendBase error** | Ensure `.smartconfig.json` has registries at `@git.zone/cli.release.registries` |
+| **Missing dependency versions** | Add the dependency to your monorepo's `package.json` `dependencies` field |
+
+## License and Legal Information
+
+This repository contains open-source code licensed under the MIT License. A copy of the license can be found in the [license](./license) file.
+
+**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 or third parties, 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 or the guidelines of the respective third-party owners, and any usage must be approved in writing. Third-party trademarks used herein are the property of their respective owners and used only in a descriptive manner, e.g. for an implementation of an API or similar.
+
+### Company Information
+
+Task Venture Capital GmbH
+Registered at District Court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or 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.

test/test.giteaassets.ts

@@ -0,0 +1,39 @@
+import { expect, tap } from '@git.zone/tstest/tapbundle';
+import * as giteaAssets from '../ts/classes.giteaassets.js';
+
+let giteaAssetsInstance: giteaAssets.GiteaAssets;
+
+tap.test('should create a GiteaAssets instance', async () => {
+  giteaAssetsInstance = new giteaAssets.GiteaAssets({
+    giteaBaseUrl: 'https://code.foss.global',
+  });
+  expect(giteaAssetsInstance).toBeInstanceOf(giteaAssets.GiteaAssets);
+});
+
+tap.test('should get files from a repository', async () => {
+  const files = await giteaAssetsInstance.getFiles('git.zone', 'cli', 'assets/templates/cli');
+  console.log(files);
+
+  for (const file of files) {
+    if (file.name.endsWith('cli.js')) {
+      console.log(atob(file.base64Content));
+    }
+  }
+
+  expect(files).toBeTruthy();
+});
+
+tap.test('should get files from a repository', async () => {
+  const files = await giteaAssetsInstance.getFiles('git.zone', 'cli', 'assets/templates/cli/cli.js');
+  console.log(files);
+
+  for (const file of files) {
+    if (file.name.endsWith('cli.js')) {
+      console.log(atob(file.base64Content));
+    }
+  }
+
+  expect(files).toBeTruthy();
+});
+
+tap.start();

test/test.ts

@@ -1,4 +1,4 @@
-import { expect, expectAsync, tap } from '@push.rocks/tapbundle';
+import { expect, tap } from '@git.zone/tstest/tapbundle';
 import * as tspublish from '../ts/index.js';
 
 tap.test('first test', async () => {

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tspublish',
-  version: '1.7.3',
+  version: '1.11.4',
   description: 'A tool to publish multiple, concise, and small packages from monorepos, specifically for TypeScript projects within a git environment.'
 }

ts/classes.giteaassets.ts

@@ -0,0 +1,108 @@
+import * as plugins from './plugins.js';
+
+interface IRepoFile {
+  name: string;
+  path: string;
+  type: 'file' | 'dir';
+  download_url: string | null;
+  base64Content: string | null;
+  encoding: string | null;
+}
+
+interface IGiteaAssetsOptions {
+  giteaBaseUrl: string; // Base URL of your Gitea instance
+  token?: string; // Optional token for private repositories
+}
+
+export class GiteaAssets {
+  private baseUrl: string;
+  private headers: {[key: string]: string} = {};
+
+  constructor(options: IGiteaAssetsOptions) {
+    this.baseUrl = options.giteaBaseUrl
+    if (this.baseUrl.endsWith('/')) {
+      this.baseUrl = this.baseUrl.slice(0, -1);
+    }
+    this.baseUrl += '/api/v1';
+    this.headers = options.token
+        ? { ...this.headers, 'Authorization': `token ${options.token}` }
+        : this.headers;
+  }
+
+  /**
+   * Get all files in a directory of a repository
+   * @param owner - Repository owner
+   * @param repo - Repository name
+   * @param directory - Directory path ('' for root)
+   * @param branch - Branch name (optional)
+   * @returns A list of files in the directory
+   */
+  async getFiles(
+    owner: string,
+    repo: string,
+    directory: string,
+    branch?: string
+  ): Promise<IRepoFile[]> {
+    try {
+      const requestBuilder = plugins.smartrequest.SmartRequest.create()
+        .url(this.baseUrl + `/repos/${owner}/${repo}/contents/${directory}`)
+        .headers(this.headers);
+      
+      if (branch) {
+        requestBuilder.query({ ref: branch });
+      }
+      
+      const response = await requestBuilder.get();
+      let responseBody = await response.json();
+      
+      if (!Array.isArray(responseBody) && typeof responseBody === 'object') {
+        responseBody = [responseBody];
+      } else if (Array.isArray(responseBody)) {
+        for (const entry of responseBody) {
+          if (entry.type === 'dir') {
+            continue;
+          } else if (entry.type === 'file') {
+            const requestBuilder2 = plugins.smartrequest.SmartRequest.create()
+              .url(this.baseUrl + `/repos/${owner}/${repo}/contents/${entry.path}`)
+              .headers(this.headers);
+            
+            if (branch) {
+              requestBuilder2.query({ ref: branch });
+            }
+            
+            const response2 = await requestBuilder2.get();
+            const response2Body = await response2.json();
+            entry.encoding = response2Body.encoding;
+            entry.content = response2Body.content;
+          }
+        }
+      }
+
+      // lets map to the IRepoFile interface
+      responseBody = responseBody.map((entry: any) => {
+        return {
+          name: entry.name,
+          path: entry.path,
+          type: entry.type,
+          download_url: entry.download_url,
+          base64Content: entry.content,
+          encoding: entry.encoding,
+        };
+      });
+
+      return responseBody;
+    } catch (error) {
+      console.error('Error fetching repository files:', error);
+      throw error;
+    }
+  }
+
+  /**
+   * gets the current cli entry file from the code.foss.global/git.zone/cli repository
+   * @returns
+   */
+  public async getBinCliEntryFile() {
+    const files = await this.getFiles('git.zone', 'cli', 'assets/templates/cli/cli.js');
+    return files[0];
+  }
+}

ts/classes.publishmodule.ts

@@ -1,12 +1,9 @@
 import * as plugins from './plugins.js';
 import * as paths from './paths.js';
-import { logger } from './logging.js';
+import { logger, logInfo, logSuccess, logWarn, logError, logBuild, logPublish, logOngoing, logStart, logDone } from './logging.js';
 
-export interface ITsPublishJson {
-  name: string;
-  dependencies: string[];
-  registries: string[];
-}
+import { type ITsPublishJson } from './interfaces/index.js';
+import type { TsPublish } from './classes.tspublish.js';
 
 export interface IPublishModuleOptions {
   monoRepoDir: string;
@@ -19,59 +16,70 @@ export interface IPublishModuleOptions {
   dependencies?: { [key: string]: string };
 }
 
+export interface IResolvedRegistry {
+  url: string;
+  accessLevel: string;
+}
+
 export class PublishModule {
+  tsPublishRef: TsPublish;
   public options: IPublishModuleOptions;
-  constructor(options: IPublishModuleOptions) {
+  constructor(tsPublishRef: TsPublish, options: IPublishModuleOptions) {
+    this.tsPublishRef = tsPublishRef;
     this.options = options;
   }
 
   public async init() {
     this.options.packageSubFolderFullPath = plugins.path.join(
       this.options.monoRepoDir,
-      this.options.packageSubFolder,
+      this.options.packageSubFolder
     );
 
     // check requirements
     if (!this.options.packageSubFolder.startsWith('ts')) {
       throw new Error('subFolder must start with "ts"');
     }
-    this.options.tsPublishJson = plugins.smartfile.fs.toObjectSync(
-      plugins.path.join(this.options.packageSubFolderFullPath, 'tspublish.json'),
-    );
-    const monoRepoPackageJson = JSON.parse(
-      plugins.smartfile.fs.toStringSync(
-        plugins.path.join(this.options.monoRepoDir, 'package.json'),
-      ),
-    );
+    const tspublishJsonPath = plugins.path.join(this.options.packageSubFolderFullPath, 'tspublish.json');
+    const tspublishJsonContent = await plugins.smartfs.file(tspublishJsonPath).encoding('utf8').read();
+    this.options.tsPublishJson = JSON.parse(tspublishJsonContent as string);
+
+    // the package.json of the parent mono repo
+    const packageJsonPath = plugins.path.join(this.options.monoRepoDir, 'package.json');
+    const packageJsonContent = await plugins.smartfs.file(packageJsonPath).encoding('utf8').read();
+    const monoRepoPackageJson = JSON.parse(packageJsonContent as string);
+
     this.options.dependencies = {
       ...this.options.dependencies,
       ...(() => {
         const resultDependencies = {};
-        for (const dependency of this.options.tsPublishJson.dependencies) {
-          resultDependencies[dependency] = monoRepoPackageJson.dependencies[dependency];
+        for (const dependency of this.options.tsPublishJson!.dependencies) {
+          if (monoRepoPackageJson.dependencies[dependency]) {
+            resultDependencies[dependency] = monoRepoPackageJson.dependencies[dependency];
+          } else {
+            resultDependencies[dependency] = monoRepoPackageJson.version;
+          }
         }
         return resultDependencies;
       })(),
     };
-    this.options.name = this.options.name || this.options.tsPublishJson.name;
+    this.options.name = this.options.name || this.options.tsPublishJson!.name;
     this.options.version = monoRepoPackageJson.version;
 
     // now that we have a name and version, lets check if there is already a package under the same name and version.
     const smartnpmInstance = new plugins.smartnpm.NpmRegistry({}); // TODO: pass in options
-    let packageInfo: plugins.smartnpm.NpmPackage;
+    let packageInfo: plugins.smartnpm.NpmPackage | undefined;
     try {
-      packageInfo = await smartnpmInstance.getPackageInfo(this.options.name);
+      packageInfo = await smartnpmInstance.getPackageInfo(this.options.name!);
     } catch (error) {
-      logger.log('warn', `package does not yet seem to exist. Proceeding in 10 seconds...`);
+      logWarn(`Package ${this.options.name} does not yet seem to exist. Proceeding in 10 seconds...`);
       await plugins.smartdelay.delayFor(10000);
     }
     if (packageInfo) {
       const availableVersions = packageInfo.allVersions.map((versionArg) => versionArg.version);
-      logger.log('info', `available versions are: ${availableVersions.toString()}`);
-      if (availableVersions.includes(this.options.version)) {
-        logger.log(
-          'error',
-          `package ${this.options.name} already exists with version ${this.options.version}`,
+      logInfo(`Available versions for ${this.options.name}: ${availableVersions.join(', ')}`);
+      if (availableVersions.includes(this.options.version!)) {
+        logError(
+          `Package ${this.options.name} already exists with version ${this.options.version}`
         );
         process.exit(1);
       }
@@ -88,13 +96,17 @@ export class PublishModule {
   }
 
   public async createTsconfigJson() {
-    const originalTsConfig = plugins.smartfile.fs.toObjectSync(
-      plugins.path.join(paths.cwd, 'tsconfig.json'),
-    );
+    const tsconfigPath = plugins.path.join(paths.cwd, 'tsconfig.json');
+    let originalTsConfig: any = null;
+    if (await plugins.smartfs.file(tsconfigPath).exists()) {
+      const tsconfigContent = await plugins.smartfs.file(tsconfigPath).encoding('utf8').read();
+      originalTsConfig = JSON.parse(tsconfigContent as string);
+    }
     if (originalTsConfig?.compilerOptions?.paths) {
       for (const path of Object.keys(originalTsConfig.compilerOptions.paths)) {
-        originalTsConfig.compilerOptions.paths[path][0] =
-          `.${originalTsConfig.compilerOptions.paths[path][0]}`;
+        originalTsConfig.compilerOptions.paths[
+          path
+        ][0] = `.${originalTsConfig.compilerOptions.paths[path][0]}`;
       }
     }
     const tsconfigJson = {
@@ -140,75 +152,183 @@ export class PublishModule {
         'dist_ts_web/**/*',
         'assets/**/*',
         'cli.js',
-        'npmextra.json',
+        '.smartconfig.json',
         'readme.md',
       ],
+      ...this.options.tsPublishJson?.bin ? {
+        bin: (() => {
+          const binObject: {[key: string]: string} = {};
+          for (const bin of this.options.tsPublishJson!.bin) {
+            binObject[bin] = `./cli.js`;
+          }
+          return binObject;
+        })()
+      } : {},
     };
     return JSON.stringify(packageJson, null, 2);
   }
 
   public async createPublishModuleDir() {
+    logOngoing(`Creating publish directory for ${this.options.name}`);
     this.options.publishModDirFullPath = plugins.path.join(
       this.options.monoRepoDir,
-      `dist_publish_${this.options.packageSubFolder}`,
+      `dist_publish_${this.options.packageSubFolder}`
     );
-    await plugins.smartfile.fs.ensureEmptyDir(this.options.publishModDirFullPath);
+
+    // Ensure empty directory
+    const publishDir = plugins.smartfs.directory(this.options.publishModDirFullPath);
+    if (await publishDir.exists()) {
+      await publishDir.recursive().delete();
+    }
+    await publishDir.recursive().create();
 
     // package.json
-    const packageJson = await plugins.smartfile.SmartFile.fromString(
-      plugins.path.join(this.options.publishModDirFullPath, 'package.json'),
-      await this.createPackageJson(),
-      'utf8',
-    );
-    await packageJson.write();
+    const packageJsonPath = plugins.path.join(this.options.publishModDirFullPath, 'package.json');
+    await plugins.smartfs.file(packageJsonPath).encoding('utf8').write(await this.createPackageJson());
 
     // tsconfig.json
-    const originalTsConfigJson = await plugins.smartfile.SmartFile.fromString(
-      plugins.path.join(this.options.publishModDirFullPath, 'tsconfig.json'),
-      await this.createTsconfigJson(),
-      'utf8',
-    );
-    await originalTsConfigJson.write();
+    const tsconfigJsonPath = plugins.path.join(this.options.publishModDirFullPath, 'tsconfig.json');
+    await plugins.smartfs.file(tsconfigJsonPath).encoding('utf8').write(await this.createTsconfigJson());
 
-    // ts folder
-    await plugins.smartfile.fs.copy(
-      this.options.packageSubFolderFullPath,
-      plugins.path.join(this.options.publishModDirFullPath, this.options.packageSubFolder),
-    );
+    // ts subfolder, the folder that contains the source code and is being transpiled
+    const destSubFolder = plugins.path.join(this.options.publishModDirFullPath, this.options.packageSubFolder);
+    await plugins.smartfs.directory(this.options.packageSubFolderFullPath!).recursive().copy(destSubFolder);
 
     // readme
-    await plugins.smartfile.fs.copy(
-      plugins.path.join(this.options.packageSubFolderFullPath, 'readme.md'),
-      plugins.path.join(this.options.publishModDirFullPath, 'readme.md'),
-    );
+    const readmeSrc = plugins.path.join(this.options.packageSubFolderFullPath!, 'readme.md');
+    const readmeDest = plugins.path.join(this.options.publishModDirFullPath, 'readme.md');
+    await plugins.smartfs.file(readmeSrc).copy(readmeDest);
 
     // license
-    await plugins.smartfile.fs.copy(
-      plugins.path.join(this.options.monoRepoDir, 'license'),
-      plugins.path.join(this.options.publishModDirFullPath, 'license'),
-    );
+    const licenseSrc = plugins.path.join(this.options.monoRepoDir, 'license');
+    const licenseDest = plugins.path.join(this.options.publishModDirFullPath, 'license');
+    await plugins.smartfs.file(licenseSrc).copy(licenseDest);
+
+    // cli stuff
+    this.createBinCliSetup();
   }
 
   public async build() {
+    logBuild(`Building ${this.options.name}...`);
     const smartshellInstance = new plugins.smartshell.Smartshell({
       executor: 'bash',
     });
     await smartshellInstance.exec(`cd ${this.options.publishModDirFullPath} && pnpm run build`);
+    logSuccess(`Build completed for ${this.options.name}`);
+  }
+
+  public async createBinCliSetup() {
+    const binSetupApplies: boolean =
+      !!this.options.tsPublishJson?.bin &&
+      Array.isArray(this.options.tsPublishJson!.bin) &&
+      this.options.tsPublishJson!.bin.length > 0;
+    const files = await this.tsPublishRef.giteaAssetsInstance.getFiles(
+      'git.zone',
+      'cli',
+      'assets/templates/cli/cli.js'
+    );
+    const indexPath = `./dist_${this.options.packageSubFolder}/index.js`;
+    const fileContent = atob(files[0].base64Content!).replace('./dist_ts/index.js', indexPath);
+    const cliJsPath = plugins.path.join(this.options.publishModDirFullPath!, 'cli.js');
+    await plugins.smartfs.file(cliJsPath).encoding('utf8').write(fileContent);
+  }
+
+  /**
+   * Resolves the registries to publish to based on tspublish.json configuration.
+   * Supports:
+   * - "useBase": Use only registries from smartconfig.json
+   * - "extendBase": Use base registries + additions, with exclusions via "-" prefix
+   * - Explicit registries: Direct registry URLs in format "url:accessLevel"
+   */
+  private async resolveRegistries(): Promise<IResolvedRegistry[]> {
+    const rawRegistries = this.options.tsPublishJson?.registries || [];
+
+    // Empty → skip publishing
+    if (rawRegistries.length === 0) {
+      return [];
+    }
+
+    const hasUseBase = rawRegistries.includes('useBase');
+    const hasExtendBase = rawRegistries.includes('extendBase');
+
+    let baseRegistries: string[] = [];
+    let baseAccessLevel = 'public';
+
+    // Load base registries from smartconfig.json if needed
+    if (hasUseBase || hasExtendBase) {
+      const smartconfigInstance = new plugins.smartconfig.Smartconfig(this.options.monoRepoDir);
+      const gitzoneConfig = smartconfigInstance.dataFor<any>('@git.zone/cli', {});
+      baseRegistries = gitzoneConfig?.release?.registries || [];
+      baseAccessLevel = gitzoneConfig?.release?.accessLevel || 'public';
+
+      if (baseRegistries.length === 0) {
+        throw new Error(
+          `useBase/extendBase specified in tspublish.json but no registries configured in smartconfig.json at @git.zone/cli.release.registries`
+        );
+      }
+    }
+
+    // useBase: Only base registries
+    if (hasUseBase) {
+      return baseRegistries.map((url) => ({ url, accessLevel: baseAccessLevel }));
+    }
+
+    // extendBase: Base registries + additions - exclusions
+    if (hasExtendBase) {
+      const exclusions = rawRegistries
+        .filter((r) => r.startsWith('-'))
+        .map((r) => r.slice(1)); // remove '-' prefix
+
+      const additions = rawRegistries.filter((r) => r !== 'extendBase' && !r.startsWith('-'));
+
+      // Filter out excluded base registries
+      const result: IResolvedRegistry[] = baseRegistries
+        .filter((url) => !exclusions.includes(url))
+        .map((url) => ({ url, accessLevel: baseAccessLevel }));
+
+      // Add explicit registries
+      for (const addition of additions) {
+        const parts = addition.split(':');
+        const url = parts[0];
+        const access = parts[1] || 'public';
+        result.push({ url, accessLevel: access });
+      }
+
+      return result;
+    }
+
+    // Explicit registries only (original behavior)
+    return rawRegistries.map((r) => {
+      const parts = r.split(':');
+      const url = parts[0];
+      const access = parts[1] || 'public';
+      return { url, accessLevel: access };
+    });
   }
 
   public async publish() {
+    const registries = await this.resolveRegistries();
+
+    // Handle empty registries
+    if (registries.length === 0) {
+      logWarn(`No registries configured for ${this.options.name}. Skipping publish.`);
+      return;
+    }
+
+    logPublish(`Publishing ${this.options.name} v${this.options.version} to ${registries.length} registry(ies)...`);
     const smartshellInstance = new plugins.smartshell.Smartshell({
       executor: 'bash',
     });
-    for (const registry of this.options.tsPublishJson.registries) {
-      const registryArray = registry.split(':');
-      const registryUrl = registryArray[0];
-      const registryAccessLevel = registryArray[1];
+
+    for (const registry of registries) {
+      const registryUrl = registry.url.startsWith('https://') ? registry.url : `https://${registry.url}`;
+      logOngoing(`Publishing to ${registryUrl}...`);
       await smartshellInstance.exec(
         `cd ${this.options.publishModDirFullPath} && pnpm publish ${
-          registryAccessLevel === 'public' ? '--access public' : ''
-        } --no-git-checks --registry https://${registryUrl}`,
+          registry.accessLevel === 'public' ? '--access public' : ''
+        } --no-git-checks --registry ${registryUrl}`
       );
     }
+    logSuccess(`Successfully published ${this.options.name} v${this.options.version}!`);
   }
 }

ts/classes.tspublish.ts

@@ -1,26 +1,40 @@
-import { logger } from './logging.js';
+import { logger, logInfo, logSuccess, logWarn, logError, logHeader, logPackage, logProgress, logSeparator, logStart, logDone } from './logging.js';
 import * as plugins from './plugins.js';
 import * as interfaces from './interfaces/index.js';
 
 import { PublishModule } from './classes.publishmodule.js';
+import { GiteaAssets } from './classes.giteaassets.js';
 
 export class TsPublish {
-  constructor() {}
+  public giteaAssetsInstance: GiteaAssets;
+
+  constructor() {
+    this.giteaAssetsInstance = new GiteaAssets({
+      giteaBaseUrl: 'https://code.foss.global',
+    });
+  }
 
   public async publish(monorepoDirArg: string) {
+    logHeader('TSPublish - Module Publisher');
     const publishModules = await this.getModuleSubDirs(monorepoDirArg);
-    logger.log('info', `Found ${Object.keys(publishModules).length} publish modules:`);
+    logInfo(`Found ${Object.keys(publishModules).length} publish modules`);
+    logSeparator();
     for (const publishModule of Object.keys(publishModules)) {
-      logger.log(
-        'info',
-        `Publishing module: ${publishModule} -> ${publishModules[publishModule].name}`,
-      );
+      logPackage('Module found', `${publishModule} → ${publishModules[publishModule].name}`);
     }
     for (const publishModule of Object.keys(publishModules)) {
-      const publishModuleInstance = new PublishModule({
+      // lets check wether there is a name
+      if (!publishModules[publishModule].name) {
+        logWarn(`No name found in tspublish.json for ${publishModule}. Skipping...`);
+        continue;
+      }
+      const publishModuleInstance = new PublishModule(this, {
         monoRepoDir: monorepoDirArg,
         packageSubFolder: publishModule,
       });
+      const moduleCount = Object.keys(publishModules).indexOf(publishModule) + 1;
+      const totalCount = Object.keys(publishModules).length;
+      logProgress(moduleCount, totalCount, publishModules[publishModule].name || publishModule);
       await publishModuleInstance.init();
       await publishModuleInstance.createPublishModuleDir();
       await publishModuleInstance.build();
@@ -29,33 +43,31 @@ export class TsPublish {
   }
 
   public async getModuleSubDirs(dirArg: string) {
-    const subDirs = await plugins.smartfile.fs.listFolders(dirArg);
+    // List all directories
+    const dirContents = await plugins.smartfs.directory(dirArg).list();
     const publishModules: { [key: string]: interfaces.ITsPublishJson } = {};
-    for (const subDir of subDirs) {
-      if (!subDir.startsWith('ts')) {
-        continue;
-      }
-      const fileTree = await plugins.smartfile.fs.listFileTree(subDir, '**/*');
-      const hasPublishJson = fileTree.includes('tspublish.json');
-      if (!hasPublishJson) {
+
+    for (const entry of dirContents) {
+      const subDirName = entry.name;
+      if (!subDirName.startsWith('ts')) {
         continue;
       }
 
-      // lets check wether there is a name
-      const tspublishJson = JSON.parse(
-        plugins.smartfile.fs.toStringSync(plugins.path.join(subDir, 'tspublish.json')),
-      );
-      if (!tspublishJson.name) {
-        logger.log('warn', `no name found in tspublish.json for ${subDir}`);
+      // Check if this is a directory and has tspublish.json
+      const subDirPath = plugins.path.join(dirArg, subDirName);
+      const tspublishJsonPath = plugins.path.join(subDirPath, 'tspublish.json');
+
+      if (!(await plugins.smartfs.file(tspublishJsonPath).exists())) {
         continue;
       }
 
-      logger.log('info', `found publish module: ${subDir}`);
-      publishModules[subDir] = JSON.parse(
-        plugins.smartfile.fs.toStringSync(plugins.path.join(subDir, 'tspublish.json')),
-      );
+      logPackage('Found module', subDirName);
+      const tspublishContent = await plugins.smartfs.file(tspublishJsonPath).encoding('utf8').read();
+      publishModules[subDirName] = JSON.parse(tspublishContent as string);
     }
-    logger.log('ok', `found ${publishModules.length} publish modules`);
+    logSuccess(`Found ${Object.keys(publishModules).length} publish modules`);
+    logInfo('Ordering publish modules...');
+
     return publishModules;
   }
 }

ts/index.ts

@@ -1,10 +1,11 @@
 import * as paths from './paths.js';
 import { TsPublish } from './classes.tspublish.js';
+import { logStart } from './logging.js';
 
 export * from './classes.tspublish.js';
 
 export const runCli = async () => {
-  console.log('Starting tspublish...');
+  logStart('tspublish');
   const tspublish = new TsPublish();
   await tspublish.publish(paths.cwd);
 };

ts/interfaces/tspublish.ts

@@ -6,4 +6,8 @@ export interface ITsPublishJson {
   name: string;
   dependencies: string[];
   registries: string[];
+  /**
+   * allows the sepcification of bin names that invoke cli scripts
+   */
+  bin: string[];
 }

ts/logging.ts

@@ -3,3 +3,102 @@ import * as commitinfo from './00_commitinfo_data.js';
 
 export const logger = plugins.smartlog.Smartlog.createForCommitinfo(commitinfo.commitinfo);
 logger.enableConsole();
+
+// Color-coded log level indicators
+const logIcons = {
+  info: plugins.consolecolor.coloredString('ℹ', 'cyan'),
+  success: plugins.consolecolor.coloredString('✓', 'green'),
+  warn: plugins.consolecolor.coloredString('⚠', 'orange'),
+  error: plugins.consolecolor.coloredString('✖', 'red'),
+  start: plugins.consolecolor.coloredString('▶', 'blue'),
+  done: plugins.consolecolor.coloredString('✔', 'green'),
+  package: plugins.consolecolor.coloredString('📦', 'blue'),
+  build: plugins.consolecolor.coloredString('🔨', 'cyan'),
+  publish: plugins.consolecolor.coloredString('🚀', 'green'),
+};
+
+// Helper function for info messages with color
+export const logInfo = (message: string, data?: any) => {
+  const coloredMessage = `${logIcons.info} ${plugins.consolecolor.coloredString(message, 'cyan')}`;
+  logger.log('info', coloredMessage, data);
+};
+
+// Helper function for success messages
+export const logSuccess = (message: string, data?: any) => {
+  const coloredMessage = `${logIcons.success} ${plugins.consolecolor.coloredString(message, 'green')}`;
+  logger.log('ok', coloredMessage, data);
+};
+
+// Helper function for warning messages
+export const logWarn = (message: string, data?: any) => {
+  const coloredMessage = `${logIcons.warn} ${plugins.consolecolor.coloredString(message, 'orange')}`;
+  logger.log('warn', coloredMessage, data);
+};
+
+// Helper function for error messages
+export const logError = (message: string, data?: any) => {
+  const coloredMessage = `${logIcons.error} ${plugins.consolecolor.coloredString(message, 'red')}`;
+  logger.log('error', coloredMessage, data);
+};
+
+// Helper function for start of operations
+export const logStart = (operation: string) => {
+  const coloredMessage = `${logIcons.start} ${plugins.consolecolor.coloredString(`Starting ${operation}...`, 'blue')}`;
+  logger.log('info', coloredMessage);
+};
+
+// Helper function for completion of operations
+export const logDone = (operation: string) => {
+  const coloredMessage = `${logIcons.done} ${plugins.consolecolor.coloredString(`Completed ${operation}`, 'green')}`;
+  logger.log('ok', coloredMessage);
+};
+
+// Helper function for package-related messages
+export const logPackage = (message: string, packageName: string) => {
+  const coloredMessage = `${logIcons.package} ${message}: ${plugins.consolecolor.coloredString(packageName, 'blue', 'white')}`;
+  logger.log('info', coloredMessage);
+};
+
+// Helper function for build-related messages
+export const logBuild = (message: string) => {
+  const coloredMessage = `${logIcons.build} ${plugins.consolecolor.coloredString(message, 'cyan')}`;
+  logger.log('info', coloredMessage);
+};
+
+// Helper function for publish-related messages
+export const logPublish = (message: string) => {
+  const coloredMessage = `${logIcons.publish} ${plugins.consolecolor.coloredString(message, 'green')}`;
+  logger.log('info', coloredMessage);
+};
+
+// Create a visual separator for different phases
+export const logSeparator = () => {
+  const separator = plugins.consolecolor.coloredString('━'.repeat(60), 'cyan');
+  console.log(separator);
+};
+
+// Create a header for major sections
+export const logHeader = (title: string) => {
+  logSeparator();
+  const header = plugins.consolecolor.coloredString(`  ${title.toUpperCase()}  `, 'white', 'blue');
+  console.log(header);
+  logSeparator();
+};
+
+// Helper for indicating ongoing operations
+export const logOngoing = (text: string) => {
+  const spinnerIcon = plugins.consolecolor.coloredString('⟳', 'cyan');
+  const coloredMessage = `${spinnerIcon} ${plugins.consolecolor.coloredString(text, 'cyan')}`;
+  logger.log('info', coloredMessage);
+};
+
+// Progress indicator helper
+export const logProgress = (current: number, total: number, item: string) => {
+  const percentage = Math.round((current / total) * 100);
+  const progressBar = '█'.repeat(Math.floor(percentage / 5)) + '░'.repeat(20 - Math.floor(percentage / 5));
+  const coloredProgress = plugins.consolecolor.coloredString(
+    `[${progressBar}] ${percentage}% - ${item}`,
+    percentage === 100 ? 'green' : 'blue'
+  );
+  logger.log('info', coloredProgress);
+};

ts/plugins.ts

@@ -3,12 +3,19 @@ import * as path from 'path';
 export { path };
 
 // @push.rocks scope
+import * as consolecolor from '@push.rocks/consolecolor';
+import * as smartconfig from '@push.rocks/smartconfig';
 import * as smartfile from '@push.rocks/smartfile';
+import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
 import * as smartcli from '@push.rocks/smartcli';
 import * as smartdelay from '@push.rocks/smartdelay';
 import * as smartlog from '@push.rocks/smartlog';
 import * as smartnpm from '@push.rocks/smartnpm';
 import * as smartpath from '@push.rocks/smartpath';
+import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartshell from '@push.rocks/smartshell';
 
-export { smartfile, smartcli, smartdelay, smartlog, smartnpm, smartpath, smartshell };
+// Create a pre-configured SmartFs instance for Node.js filesystem operations
+const smartfs = new SmartFs(new SmartFsProviderNode());
+
+export { consolecolor, smartconfig, smartfile, smartfs, smartcli, smartdelay, smartlog, smartnpm, smartpath, smartrequest, smartshell };

tsconfig.json

@@ -6,9 +6,7 @@
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "esModuleInterop": true,
-    "verbatimModuleSyntax": true,
-    "baseUrl": ".",
-    "paths": {}
+    "verbatimModuleSyntax": true
   },
   "exclude": [
     "dist_*/**/*.d.ts"