v1.11.4

.serena/memories/code_style_conventions.md

@@ -1,31 +0,0 @@
-# Code Style and Conventions
-
-## Naming Conventions
-- Interfaces prefixed with `I` (e.g., `ITsPublishJson`)
-- Types prefixed with `T` (when applicable)
-- All filenames in lowercase
-- Class files named as `classes.<classname>.ts`
-- Test files named as `test.<name>.ts` or `*.both.ts`, `*.node.ts`, `*.browser.ts`
-
-## Import Style
-- Module dependencies imported via `ts/plugins.ts`
-- Use full path references: `plugins.myModule.myClass()`
-- Import TypeScript files directly in tests, never compiled JavaScript
-
-## Code Patterns
-- Async/await preferred over callbacks
-- Classes for main logic (TsPublish, PublishModule)
-- Centralized logging via `logging.ts`
-- Plugins pattern for external dependencies
-
-## TypeScript Conventions
-- Use type annotations
-- Export classes and functions explicitly
-- Module exports through index.ts
-- Interfaces in separate interfaces/ directory
-
-## File Organization
-- Source code in `ts/` directory
-- Tests in `test/` directory
-- Compiled output in `dist_ts/`
-- No uppercase in filenames

.serena/memories/logging_improvements_2025.md

@@ -1,49 +0,0 @@
-# Logging Improvements - January 2025
-
-## Overview
-Enhanced TSPublish logging system with @push.rocks/smartlog and @push.rocks/consolecolor for better visual feedback and user experience.
-
-## Changes Made
-
-### 1. Dependencies
-- Added @push.rocks/consolecolor (v2.0.3) for colored console output
-
-### 2. Enhanced logging.ts
-- Created color-coded log level indicators with emojis
-- Added specialized logging functions:
-  - `logInfo()` - Cyan info messages
-  - `logSuccess()` - Green success messages  
-  - `logWarn()` - Orange warning messages
-  - `logError()` - Red error messages
-  - `logStart()` - Blue start indicators
-  - `logDone()` - Green completion indicators
-  - `logPackage()` - Package-specific messages with icons
-  - `logBuild()` - Build messages with hammer icon
-  - `logPublish()` - Publish messages with rocket icon
-  - `logOngoing()` - Ongoing operations with spinner icon
-- Added visual helpers:
-  - `logSeparator()` - Cyan line separator
-  - `logHeader()` - Colored section headers
-  - `logProgress()` - Progress bar with percentage
-
-### 3. Updated classes.tspublish.ts
-- Added colored header at startup
-- Module discovery uses colored bullets
-- Progress tracking for module processing
-- Better visual separation between phases
-
-### 4. Updated classes.publishmodule.ts  
-- Added visual indicators for each operation phase
-- Build process shows building status and completion
-- Publishing shows rocket icon and success message
-- NPM registry checks have clearer warnings
-
-### 5. Updated index.ts
-- Replaced console.log with logStart()
-
-## Benefits
-- Clearer visual hierarchy of information
-- Easier to track progress through long operations
-- Better distinction between info, warnings, and errors
-- More professional and polished CLI output
-- Semantic icons make status immediately recognizable

.serena/memories/project_overview.md

@@ -1,45 +0,0 @@
-# TSPublish Project Overview
-
-## Purpose
-TSPublish is a tool designed to publish multiple, concise, and small packages from monorepos, specifically for TypeScript projects within a git environment. It helps manage and automate the publishing of individual packages from a monorepo structure.
-
-## Tech Stack
-- **Language**: TypeScript
-- **Runtime**: Node.js
-- **Package Manager**: pnpm (v10.11.0)
-- **Build Tool**: @git.zone/tsbuild
-- **Testing**: @git.zone/tstest with @push.rocks/tapbundle
-- **CLI Framework**: @push.rocks/smartcli
-- **Logging**: @push.rocks/smartlog (currently basic usage)
-
-## Main Dependencies
-- @push.rocks/smartcli - CLI interface
-- @push.rocks/smartdelay - Delay utilities  
-- @push.rocks/smartfile - File operations
-- @push.rocks/smartlog - Logging
-- @push.rocks/smartnpm - NPM registry interactions
-- @push.rocks/smartpath - Path utilities
-- @push.rocks/smartrequest - HTTP requests
-- @push.rocks/smartshell - Shell command execution
-
-## Project Structure
-- `ts/` - TypeScript source files
-  - `index.ts` - Main entry point
-  - `classes.tspublish.ts` - Main TsPublish class
-  - `classes.publishmodule.ts` - PublishModule class for individual packages
-  - `classes.giteaassets.ts` - Gitea assets management
-  - `logging.ts` - Logger configuration
-  - `plugins.ts` - External dependencies
-  - `paths.ts` - Path constants
-  - `interfaces/` - TypeScript interfaces
-- `test/` - Test files
-- `dist_ts/` - Compiled JavaScript output
-- `cli.js` - CLI entry point (bin script)
-
-## Key Features
-1. Scans monorepo for directories starting with "ts"
-2. Validates packages via tspublish.json files
-3. Creates package.json dynamically for each module
-4. Builds TypeScript code before publishing
-5. Checks npm registry for version conflicts
-6. Publishes packages to npm registry

.serena/memories/smartrequest_api_update_2025.md

@@ -1,39 +0,0 @@
-# SmartRequest API Update - January 2025
-
-## Context
-The @push.rocks/smartrequest package (v4.2.1) uses a new chainable API that replaced the old function-based API.
-
-## Changes Made
-
-### Old API (v2.x)
-```typescript
-const response = await plugins.smartrequest.request(url, {
-  headers: this.headers,
-  method: 'GET',
-  queryParams: { key: value }
-});
-const data = response.body;
-```
-
-### New API (v4.x)
-```typescript
-const requestBuilder = plugins.smartrequest.SmartRequest.create()
-  .url(url)
-  .headers(this.headers)
-  .query({ key: value });
-
-const response = await requestBuilder.get();
-const data = await response.json();
-```
-
-## Key Differences
-1. **Request Creation**: Use `SmartRequest.create()` instead of direct function call
-2. **Chainable Methods**: Configure requests with `.url()`, `.headers()`, `.query()`
-3. **HTTP Methods**: Use `.get()`, `.post()`, `.delete()` etc. instead of method parameter
-4. **Response Parsing**: Call `.json()` on response to get parsed data (was `.body` before)
-
-## Files Updated
-- `ts/classes.giteaassets.ts` - Updated the `getFiles()` method to use new API
-
-## Testing
-All tests pass successfully, including the GiteaAssets tests that fetch real data from code.foss.global.

.serena/memories/suggested_commands.md

@@ -1,34 +0,0 @@
-# Suggested Commands for TSPublish Development
-
-## Build & Test Commands
-- `pnpm build` - Build the TypeScript project (runs tsbuild --web --allowimplicitany)
-- `pnpm test` - Run the test suite (runs tstest test/ --web)
-- `pnpm buildDocs` - Generate documentation (runs tsdoc)
-
-## Development Commands
-- `tsx ts/index.ts` - Run the main entry point directly
-- `tsx test/test.ts` - Run specific test file
-- `tstest test/test.some.ts --verbose` - Run specific test with verbose output
-- `tsbuild check test/**/* --skiplibcheck` - Type check test files
-
-## Package Management
-- `pnpm install` - Install dependencies
-- `pnpm install --save-dev <package>` - Install dev dependency
-- `pnpm add <package>` - Add production dependency
-
-## Git Commands (Linux)
-- `git status` - Check repository status
-- `git diff` - View changes
-- `git log` - View commit history
-- `git mv <old> <new>` - Move/rename files preserving history
-
-## File System Commands (Linux)
-- `ls` - List directory contents
-- `cd` - Change directory  
-- `find` - Find files
-- `grep` - Search file contents
-- `cat` - Display file contents
-
-## CLI Usage
-- `./cli.js` - Run the tspublish CLI
-- `node cli.js` - Alternative way to run CLI

.serena/memories/task_completion_checklist.md

@@ -1,29 +0,0 @@
-# Task Completion Checklist
-
-When completing any development task on TSPublish:
-
-## 1. Build Verification
-- Run `pnpm build` to ensure TypeScript compiles without errors
-- No use of --skiplibcheck flag
-
-## 2. Test Execution  
-- Run `pnpm test` to verify all tests pass
-- For specific test files: `tsx test/test.specific.ts`
-
-## 3. Type Checking
-- Type check test files: `tsbuild check test/**/* --skiplibcheck`
-- Type check source files: `pnpm build`
-
-## 4. Code Quality
-- Ensure changes are focused and goal-oriented
-- Verify no unnecessary modifications were made
-- Check that code follows existing patterns and conventions
-
-## 5. Documentation
-- Update readme.hints.md if new insights discovered
-- Update readme.plan.md if working from a plan
-
-## 6. Version Control
-- Use `git mv` for file renames to preserve history
-- Make small, focused commits
-- Never commit without explicit user request

.serena/project.yml

@@ -1,68 +0,0 @@
-# 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 or directory.
-#  * `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: "tspublish"

.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,59 @@
 # 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
 

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.10.2",
+  "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",
@@ -17,11 +17,11 @@
     "tspublish": "./cli.js"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.6.4",
-    "@git.zone/tsbundle": "^2.5.1",
-    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^2.3.4",
-    "@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",
@@ -43,19 +43,21 @@
     "dist_ts_web/**/*",
     "assets/**/*",
     "cli.js",
-    "npmextra.json",
+    ".smartconfig.json",
     "readme.md"
   ],
   "dependencies": {
     "@push.rocks/consolecolor": "^2.0.3",
-    "@push.rocks/smartcli": "^4.0.11",
+    "@push.rocks/smartcli": "^4.0.20",
+    "@push.rocks/smartconfig": "^6.0.1",
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartfile": "^11.2.7",
-    "@push.rocks/smartlog": "^3.1.8",
-    "@push.rocks/smartnpm": "^2.0.4",
+    "@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": "^4.2.2",
-    "@push.rocks/smartshell": "^3.3.0"
+    "@push.rocks/smartrequest": "^5.0.1",
+    "@push.rocks/smartshell": "^3.3.8"
   },
   "keywords": [
     "typescript",

pnpm-workspace.yaml

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

readme.md

@@ -7,66 +7,62 @@
 
 ## 🌟 What is tspublish?
 
-`@git.zone/tspublish` is your Swiss Army knife for managing and publishing multiple TypeScript packages from a monorepo. It automates the tedious parts of package 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 easier.
+`@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 packages
-- 🎨 **Beautiful CLI Output** - Color-coded logging with progress indicators
-- 🔍 **Version Collision Detection** - Prevents accidental overwrites
-- 🏗️ **Build Integration** - Automatically builds TypeScript before publishing
-- 🎯 **Smart Dependency Management** - Inherits dependencies from your monorepo
-- 🌐 **Multi-Registry Support** - Publish to npm, GitHub packages, or private registries
-- ⚡ **Zero Config** - Works out of the box with sensible defaults
+- 📦 **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
 
-### As a Development Dependency (Recommended)
-
 ```bash
 # Using pnpm (recommended)
 pnpm add -D @git.zone/tspublish
 
-# Using npm
-npm install --save-dev @git.zone/tspublish
-
-# Using yarn
-yarn add -D @git.zone/tspublish
-```
-
-### Global Installation
-
-```bash
-npm install -g @git.zone/tspublish
+# Global installation for CLI usage
+pnpm add -g @git.zone/tspublish
 ```
 
 ## 🚀 Quick Start
 
 ### 1️⃣ Structure Your Monorepo
 
-Organize your packages with the `ts` prefix convention:
+Organize your packages using directories that start with `ts`:
 
 ```
 my-awesome-monorepo/
-├── package.json          # Main monorepo package.json
-├── tsconfig.json         # Shared TypeScript config
-├── ts-core/              # Core package
-│   ├── ts/               # TypeScript source files
-│   ├── readme.md         # Package documentation
-│   └── tspublish.json    # Publishing configuration
-├── ts-utils/             # Utilities package
-│   ├── ts/
+├── 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
-    ├── ts/
+└── ts_cli/                 # CLI package
+    ├── index.ts
     ├── readme.md
     └── tspublish.json
 ```
 
 ### 2️⃣ Configure Each Package
 
-Create a `tspublish.json` in each package directory:
+Create a `tspublish.json` in each publishable directory:
 
 ```json
 {
@@ -77,10 +73,9 @@ Create a `tspublish.json` in each package directory:
     "@push.rocks/smartfile"
   ],
   "registries": [
-    "registry.npmjs.org:public",
-    "npm.pkg.github.com:private"
+    "registry.npmjs.org:public"
   ],
-  "bin": ["my-cli"]
+  "bin": []
 }
 ```
 
@@ -88,22 +83,118 @@ Create a `tspublish.json` in each package directory:
 
 | Field | Type | Description |
 |-------|------|-------------|
-| `name` | string | Package name (required) |
-| `order` | number | Build order for interdependent packages |
-| `dependencies` | string[] | Dependencies from the monorepo to include |
-| `registries` | string[] | Target registries with access level |
-| `bin` | string[] | CLI executable names |
+| `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) |
 
-### 3️⃣ Run the Publisher
-
-#### Command Line
+### 3️⃣ Publish
 
 ```bash
 # From your monorepo root
 npx tspublish
 ```
 
-#### Programmatic Usage
+That's it! tspublish will discover all `ts*` directories containing `tspublish.json`, build them in order, validate versions against the registry, and publish.
+
+## 🎯 Advanced Usage
+
+### Registry Configuration
+
+TSPublish offers three approaches for configuring target registries:
+
+#### 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';
@@ -112,264 +203,147 @@ const publisher = new TsPublish();
 await publisher.publish(process.cwd());
 ```
 
-## 🎯 Advanced Usage
-
-### Custom Publishing Pipeline
+#### Custom Publishing Pipeline
 
 ```typescript
 import { TsPublish, PublishModule } from '@git.zone/tspublish';
 
-// Initialize the publisher
 const publisher = new TsPublish();
-
-// Get all publishable modules
 const modules = await publisher.getModuleSubDirs('./my-monorepo');
 
-// Custom processing for each module
 for (const [name, config] of Object.entries(modules)) {
-  const module = new PublishModule(publisher, {
+  const mod = new PublishModule(publisher, {
     monoRepoDir: './my-monorepo',
-    packageSubFolder: name
+    packageSubFolder: name,
   });
-  
-  // Initialize module
-  await module.init();
-  
-  // Create publish directory
-  await module.createPublishModuleDir();
-  
-  // Custom build step
-  console.log(`Building ${config.name}...`);
-  await module.build();
-  
-  // Publish to registries
-  await module.publish();
+
+  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
 }
 ```
 
-### Registry Configuration
-
-TSPublish supports multiple registries with different access levels:
-
-```json
-{
-  "registries": [
-    "registry.npmjs.org:public",        // Public npm package
-    "npm.pkg.github.com:private",       // Private GitHub package
-    "my-company.jfrog.io/npm:restricted" // Corporate registry
-  ]
-}
-```
-
-### Build Order Management
-
-When packages depend on each other, use the `order` field to ensure correct build sequence:
-
-```json
-// ts-core/tspublish.json
-{
-  "name": "@myorg/core",
-  "order": 1,
-  "dependencies": []
-}
-
-// ts-utils/tspublish.json
-{
-  "name": "@myorg/utils",
-  "order": 2,
-  "dependencies": ["@myorg/core"]
-}
-```
-
-### CLI Binary Configuration
-
-For packages that include CLI tools:
-
-```json
-{
-  "name": "@myorg/cli",
-  "bin": ["my-cli", "my-tool"],
-  "dependencies": ["commander", "chalk"]
-}
-```
-
-This automatically generates the necessary `cli.js` wrapper and configures the package.json `bin` field.
-
-## 🎨 Beautiful Output
-
-TSPublish provides rich, colored console output with:
-
-- 📊 Progress bars for multi-package operations
-- 🎯 Clear status indicators (ℹ info, ✓ success, ⚠ warning, ✖ error)
-- 📦 Package-specific icons and formatting
-- 🚀 Visual separators between operation phases
-
 ## 🔧 How It Works
 
-1. **Discovery Phase** 🔍
-   - Scans for directories starting with `ts`
-   - Validates `tspublish.json` presence
-   - Orders packages by dependency
-
-2. **Preparation Phase** 📋
-   - Creates temporary `dist_publish_*` directories
-   - Generates package.json from tspublish.json
-   - Copies source files and assets
-   - Sets up TypeScript configuration
-
-3. **Build Phase** 🔨
-   - Runs TypeScript compilation
-   - Generates declaration files
-   - Prepares distribution bundle
-
-4. **Validation Phase** ✅
-   - Checks npm registry for existing versions
-   - Prevents accidental overwrites
-   - Validates package metadata
-
-5. **Publishing Phase** 🚀
-   - Publishes to configured registries
-   - Handles authentication
-   - Reports success/failure
-
-## 🤝 Integration with CI/CD
-
-### GitHub Actions
-
-```yaml
-name: Publish Packages
-
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  publish:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      
-      - uses: pnpm/action-setup@v2
-        with:
-          version: 8
-          
-      - uses: actions/setup-node@v3
-        with:
-          node-version: '20'
-          cache: 'pnpm'
-          
-      - run: pnpm install
-      
-      - run: pnpm build
-      
-      - run: npx tspublish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+```
+┌──────────────────────────────────────────────────────────┐
+│                   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             │
+│                                                          │
+└──────────────────────────────────────────────────────────┘
 ```
 
-### GitLab CI
+For each discovered module, tspublish:
 
-```yaml
-publish:
-  stage: deploy
-  image: node:20
-  before_script:
-    - npm install -g pnpm
-    - pnpm install
-  script:
-    - pnpm build
-    - npx tspublish
-  only:
-    - tags
-```
+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 Class
+### TsPublish
 
 ```typescript
 class TsPublish {
-  // Publish all packages in a monorepo
-  async publish(monorepoDirPath: string): Promise<void>
-  
-  // Get all publishable module configurations
-  async getModuleSubDirs(dirPath: string): Promise<{[key: string]: ITsPublishJson}>
+  /** 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 Class
+### PublishModule
 
 ```typescript
 class PublishModule {
-  // Initialize the module for publishing
-  async init(): Promise<void>
-  
-  // Create the publishing directory structure
-  async createPublishModuleDir(): Promise<void>
-  
-  // Build the TypeScript package
-  async build(): Promise<void>
-  
-  // Publish to configured registries
-  async publish(): Promise<void>
+  /** 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 Interface
+### ITsPublishJson
 
 ```typescript
 interface ITsPublishJson {
-  name: string           // Package name
-  order: number          // Build order
-  dependencies: string[] // Dependencies to include
-  registries: string[]   // Target registries
-  bin: string[]         // CLI binaries
+  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
 
-### Common Issues
-
-**Package already exists with version X.X.X**
-- TSPublish detected a version collision
-- Update your monorepo's package.json version
-- Or unpublish the existing version if appropriate
-
-**No publish modules found**
-- Ensure your packages follow the `ts-*` naming convention
-- Check that each package has a valid `tspublish.json`
-
-**Build failures**
-- Verify TypeScript configuration
-- Check that all dependencies are installed
-- Review the build output for specific errors
-
-## 🔮 Future Features
-
-- 🎯 Selective publishing with pattern matching
-- 🔄 Automatic version bumping strategies
-- 📊 Dry-run mode with detailed preview
-- 🏷️ Git tag integration
-- 📝 Changelog generation
-- 🔐 Enhanced authentication handling
+| 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 that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. 
+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 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.
+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
+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.
+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.
+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.

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/tspublish',
-  version: '1.10.2',
+  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.publishmodule.ts

@@ -16,6 +16,11 @@ export interface IPublishModuleOptions {
   dependencies?: { [key: string]: string };
 }
 
+export interface IResolvedRegistry {
+  url: string;
+  accessLevel: string;
+}
+
 export class PublishModule {
   tsPublishRef: TsPublish;
   public options: IPublishModuleOptions;
@@ -34,20 +39,20 @@ export class PublishModule {
     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 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 monoRepoPackageJson = JSON.parse(
-      plugins.smartfile.fs.toStringSync(plugins.path.join(this.options.monoRepoDir, 'package.json'))
-    );
+    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) {
+        for (const dependency of this.options.tsPublishJson!.dependencies) {
           if (monoRepoPackageJson.dependencies[dependency]) {
             resultDependencies[dependency] = monoRepoPackageJson.dependencies[dependency];
           } else {
@@ -57,14 +62,14 @@ export class PublishModule {
         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) {
       logWarn(`Package ${this.options.name} does not yet seem to exist. Proceeding in 10 seconds...`);
       await plugins.smartdelay.delayFor(10000);
@@ -72,7 +77,7 @@ export class PublishModule {
     if (packageInfo) {
       const availableVersions = packageInfo.allVersions.map((versionArg) => versionArg.version);
       logInfo(`Available versions for ${this.options.name}: ${availableVersions.join(', ')}`);
-      if (availableVersions.includes(this.options.version)) {
+      if (availableVersions.includes(this.options.version!)) {
         logError(
           `Package ${this.options.name} already exists with version ${this.options.version}`
         );
@@ -91,9 +96,12 @@ 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[
@@ -144,13 +152,13 @@ export class PublishModule {
         'dist_ts_web/**/*',
         'assets/**/*',
         'cli.js',
-        'npmextra.json',
+        '.smartconfig.json',
         'readme.md',
       ],
-      ...this.options.tsPublishJson.bin ? {
+      ...this.options.tsPublishJson?.bin ? {
         bin: (() => {
           const binObject: {[key: string]: string} = {};
-          for (const bin of this.options.tsPublishJson.bin) {
+          for (const bin of this.options.tsPublishJson!.bin) {
             binObject[bin] = `./cli.js`;
           }
           return binObject;
@@ -166,41 +174,35 @@ export class PublishModule {
       this.options.monoRepoDir,
       `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 tsconfigJson = await plugins.smartfile.SmartFile.fromString(
-      plugins.path.join(this.options.publishModDirFullPath, 'tsconfig.json'),
-      await this.createTsconfigJson(),
-      'utf8'
-    );
-    await tsconfigJson.write();
+    const tsconfigJsonPath = plugins.path.join(this.options.publishModDirFullPath, 'tsconfig.json');
+    await plugins.smartfs.file(tsconfigJsonPath).encoding('utf8').write(await this.createTsconfigJson());
 
     // ts subfolder, the folder that contains the source code and is being transpiled
-    await plugins.smartfile.fs.copy(
-      this.options.packageSubFolderFullPath,
-      plugins.path.join(this.options.publishModDirFullPath, this.options.packageSubFolder)
-    );
+    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();
@@ -217,32 +219,114 @@ export class PublishModule {
 
   public async createBinCliSetup() {
     const binSetupApplies: boolean =
-      this.options.tsPublishJson.bin &&
-      Array.isArray(this.options.tsPublishJson.bin) &&
-      this.options.tsPublishJson.bin.length > 0;
+      !!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);
-    await plugins.smartfile.memory.toFs(fileContent, plugins.path.join(this.options.publishModDirFullPath, 'cli.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() {
-    logPublish(`Publishing ${this.options.name} v${this.options.version}...`);
+    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

@@ -43,22 +43,27 @@ 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;
       }
 
-      logPackage('Found module', subDir);
-      publishModules[subDir] = JSON.parse(
-        plugins.smartfile.fs.toStringSync(plugins.path.join(subDir, 'tspublish.json'))
-      );
+      // 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;
+      }
+
+      logPackage('Found module', subDirName);
+      const tspublishContent = await plugins.smartfs.file(tspublishJsonPath).encoding('utf8').read();
+      publishModules[subDirName] = JSON.parse(tspublishContent as string);
     }
     logSuccess(`Found ${Object.keys(publishModules).length} publish modules`);
     logInfo('Ordering publish modules...');

ts/plugins.ts

@@ -4,7 +4,9 @@ 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';
@@ -13,4 +15,7 @@ import * as smartpath from '@push.rocks/smartpath';
 import * as smartrequest from '@push.rocks/smartrequest';
 import * as smartshell from '@push.rocks/smartshell';
 
-export { consolecolor, smartfile, smartcli, smartdelay, smartlog, smartnpm, smartpath, smartrequest, 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"