1.10.1

.serena/memories/code_style_conventions.md

@@ -0,0 +1,31 @@
+# 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

@@ -0,0 +1,49 @@
+# 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

@@ -0,0 +1,45 @@
+# 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

@@ -0,0 +1,39 @@
+# 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

@@ -0,0 +1,34 @@
+# 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

@@ -0,0 +1,29 @@
+# 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

@@ -0,0 +1,68 @@
+# language of the project (csharp, python, rust, java, typescript, go, cpp, or ruby)
+#  * For C, use cpp
+#  * For JavaScript, use typescript
+# Special requirements:
+#  * csharp: Requires the presence of a .sln file in the project folder.
+language: typescript
+
+# whether to use the project's gitignore file to ignore files
+# Added on 2025-04-07
+ignore_all_files_in_gitignore: true
+# list of additional paths to ignore
+# same syntax as gitignore, so you can use * and **
+# Was previously called `ignored_dirs`, please update your config if you are using that.
+# Added (renamed)on 2025-04-07
+ignored_paths: []
+
+# whether the project is in read-only mode
+# If set to true, all editing tools will be disabled and attempts to use them will result in an error
+# Added on 2025-04-18
+read_only: false
+
+
+# list of tool names to exclude. We recommend not excluding any tools, see the readme for more details.
+# Below is the complete list of tools for convenience.
+# To make sure you have the latest list of tools, and to view their descriptions, 
+# execute `uv run scripts/print_tool_overview.py`.
+#
+#  * `activate_project`: Activates a project by name.
+#  * `check_onboarding_performed`: Checks whether project onboarding was already performed.
+#  * `create_text_file`: Creates/overwrites a file in the project directory.
+#  * `delete_lines`: Deletes a range of lines within a file.
+#  * `delete_memory`: Deletes a memory from Serena's project-specific memory store.
+#  * `execute_shell_command`: Executes a shell command.
+#  * `find_referencing_code_snippets`: Finds code snippets in which the symbol at the given location is referenced.
+#  * `find_referencing_symbols`: Finds symbols that reference the symbol at the given location (optionally filtered by type).
+#  * `find_symbol`: Performs a global (or local) search for symbols with/containing a given name/substring (optionally filtered by type).
+#  * `get_current_config`: Prints the current configuration of the agent, including the active and available projects, tools, contexts, and modes.
+#  * `get_symbols_overview`: Gets an overview of the top-level symbols defined in a given file 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"

changelog.md

@@ -1,5 +1,79 @@
 # Changelog
 
+## 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
+
+- Ensure that the tspublish.json file contains a valid name field before processing.
+- Log a warning message if the name is not found in tspublish.json.
+
+## 2024-11-05 - 1.7.2 - fix(project)
+Fixed minor formatting issues and improved code consistency.
+
+- Added missing semicolons for consistency
+- Improved indentation in various files for better readability
+- Corrected usage of newlines and whitespace across the codebase
+
 ## 2024-11-05 - 1.7.1 - fix(core)
 Implement error handling for missing publish module directories
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@git.zone/tspublish",
-  "version": "1.7.1",
+  "version": "1.10.1",
   "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,19 +9,18 @@
   "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/tsbuild": "^2.6.4",
+    "@git.zone/tsbundle": "^2.5.1",
     "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.44",
-    "@push.rocks/tapbundle": "^5.0.15",
+    "@git.zone/tstest": "^2.3.2",
     "@types/node": "^22.8.7"
   },
   "repository": {
@@ -48,13 +47,15 @@
     "readme.md"
   ],
   "dependencies": {
+    "@push.rocks/consolecolor": "^2.0.3",
     "@push.rocks/smartcli": "^4.0.11",
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartfile": "^11.0.21",
-    "@push.rocks/smartlog": "^3.0.7",
+    "@push.rocks/smartfile": "^11.2.5",
+    "@push.rocks/smartlog": "^3.1.8",
     "@push.rocks/smartnpm": "^2.0.4",
-    "@push.rocks/smartpath": "^5.0.18",
-    "@push.rocks/smartshell": "^3.0.6"
+    "@push.rocks/smartpath": "^6.0.0",
+    "@push.rocks/smartrequest": "^4.2.1",
+    "@push.rocks/smartshell": "^3.2.3"
   },
   "keywords": [
     "typescript",
@@ -67,5 +68,6 @@
     "modularity",
     "module-management",
     "developer-tools"
-  ]
+  ],
+  "packageManager": "pnpm@10.11.0+sha512.6540583f41cc5f628eb3d9773ecee802f4f9ef9923cc45b69890fb47991d4b092964694ec3a4f738a420c918a333062c8b925d312f42e4f0c263eb603551f977"
 }

pnpm-workspace.yaml

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

readme.md

@@ -1,191 +1,375 @@
-# @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 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.
+
+### ✨ 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
+
+## 📥 Installation
+
+### As a Development Dependency (Recommended)
 
 ```bash
-npm install @git.zone/tspublish
+# 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
 ```
 
-Alternatively, if you are using yarn, the equivalent command would be:
+### Global Installation
 
 ```bash
-yarn add @git.zone/tspublish
+npm install -g @git.zone/tspublish
 ```
 
-These commands will add `@git.zone/tspublish` as a dependency in your `package.json` file and install the package into your `node_modules` directory.
+## 🚀 Quick Start
 
-## Usage
+### 1️⃣ Structure Your Monorepo
 
-`@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 with the `ts` prefix convention:
 
 ```
-my-monorepo/
-├── ts-package1/
-│   ├── src/
-│   ├── tspublish.json
-├── ts-package2/
-│   ├── src/
-│   ├── tspublish.json
+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/
+│   ├── readme.md
+│   └── tspublish.json
+└── ts-cli/               # CLI package
+    ├── 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 package 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",
+    "npm.pkg.github.com:private"
+  ],
+  "bin": ["my-cli"]
 }
 ```
 
-### 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 | 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 |
 
-```typescript
-import { runCli } from '@git.zone/tspublish';
+### 3️⃣ Run the Publisher
 
-runCli();
+#### Command Line
+
+```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.
-
-### Core Features
-
-#### Publishing Modules
-
-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:
-
-- **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.
+#### 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
+## 🎯 Advanced Usage
 
-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',
-});
+// Initialize the publisher
+const publisher = new TsPublish();
 
-await publishModule.init();
+// 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, {
+    monoRepoDir: './my-monorepo',
+    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();
+}
 ```
 
-#### Creating `package.json`
+### Registry Configuration
 
-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:
+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 }}
+```
+
+### GitLab CI
+
+```yaml
+publish:
+  stage: deploy
+  image: node:20
+  before_script:
+    - npm install -g pnpm
+    - pnpm install
+  script:
+    - pnpm build
+    - npx tspublish
+  only:
+    - tags
+```
+
+## 📚 API Reference
+
+### TsPublish Class
 
 ```typescript
-await publishModule.createPackageJson();
+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}>
+}
 ```
 
-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:
+### PublishModule Class
 
 ```typescript
-await publishModule.createPublishModuleDir();
+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>
+}
 ```
 
-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:
+### ITsPublishJson Interface
 
 ```typescript
-import { logger } from '@git.zone/tspublish/logging';
-
-logger.log('info', 'Publishing process initialized');
+interface ITsPublishJson {
+  name: string           // Package name
+  order: number          // Build order
+  dependencies: string[] // Dependencies to include
+  registries: string[]   // Target registries
+  bin: string[]         // CLI binaries
+}
 ```
 
-This powerful logging helps in tracking the status of each step and understanding potential issues during the operations.
+## 🐛 Troubleshooting
 
-### Testing with tapbundle
+### Common Issues
 
-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`:
+**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
 
-```typescript
-import { expect, tap } from '@push.rocks/tapbundle';
-import * as tspublish from '@git.zone/tspublish';
+**No publish modules found**
+- Ensure your packages follow the `ts-*` naming convention
+- Check that each package has a valid `tspublish.json`
 
-tap.test('Should run the CLI without errors', async () => {
-  await tspublish.runCli();
-  expect(tspublish).toBeTruthy();
-});
+**Build failures**
+- Verify TypeScript configuration
+- Check that all dependencies are installed
+- Review the build output for specific errors
 
-tap.start();
-```
+## 🔮 Future Features
 
-### Comprehensive usage example
+- 🎯 Selective publishing with pattern matching
+- 🔄 Automatic version bumping strategies
+- 📊 Dry-run mode with detailed preview
+- 🏷️ Git tag integration
+- 📝 Changelog generation
+- 🔐 Enhanced authentication handling
 
-Let's combine all the steps into a complete example where you prepare a monorepo, configure each module, and execute the publishing workflow.
+## License and Legal Information
 
-Suppose you have a project structure as follows:
+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. 
 
-```plaintext
-my-monorepo/
-├── ts-package1/
-│   ├── src/
-│   ├── tspublish.json
-├── ts-package2/
-│   ├── src/
-│   ├── tspublish.json
-```
+**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.
 
-Follow these steps:
+### Trademarks
 
-1. Ensure each package has `tspublish.json` properly configured with necessary metadata.
-2. Create a CLI script such as `publish.js`:
+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.
 
-```typescript
-import { runCli } from '@git.zone/tspublish';
+### Company Information
 
-runCli().then(() => {
-  console.log('Publishing completed successfully');
-}).catch((error) => {
-  console.error('Error during publishing:', error);
-});
-```
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
 
-3. Execute your CLI script:
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
 
-```bash
-node publish.js
-```
-
-Your script will call `runCli`, which will traverse each `ts-package`, verify their publish readiness, and handle individual publishing processes.
-
-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
+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.1',
+  version: '1.10.1',
   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;
@@ -20,8 +17,10 @@ export interface IPublishModuleOptions {
 }
 
 export class PublishModule {
+  tsPublishRef: TsPublish;
   public options: IPublishModuleOptions;
-  constructor(options: IPublishModuleOptions) {
+  constructor(tsPublishRef: TsPublish, options: IPublishModuleOptions) {
+    this.tsPublishRef = tsPublishRef;
     this.options = options;
   }
 
@@ -38,15 +37,22 @@ export class PublishModule {
     this.options.tsPublishJson = plugins.smartfile.fs.toObjectSync(
       plugins.path.join(this.options.packageSubFolderFullPath, 'tspublish.json')
     );
+
+    // the package.json of the parent mono repo
     const monoRepoPackageJson = JSON.parse(
       plugins.smartfile.fs.toStringSync(plugins.path.join(this.options.monoRepoDir, 'package.json'))
     );
+
     this.options.dependencies = {
       ...this.options.dependencies,
       ...(() => {
         const resultDependencies = {};
         for (const dependency of this.options.tsPublishJson.dependencies) {
-          resultDependencies[dependency] = monoRepoPackageJson.dependencies[dependency];
+          if (monoRepoPackageJson.dependencies[dependency]) {
+            resultDependencies[dependency] = monoRepoPackageJson.dependencies[dependency];
+          } else {
+            resultDependencies[dependency] = monoRepoPackageJson.version;
+          }
         }
         return resultDependencies;
       })(),
@@ -60,14 +66,16 @@ export class PublishModule {
     try {
       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()}`);
+      logInfo(`Available versions for ${this.options.name}: ${availableVersions.join(', ')}`);
       if (availableVersions.includes(this.options.version)) {
-        logger.log('error', `package ${this.options.name} already exists with version ${this.options.version}`);
+        logError(
+          `Package ${this.options.name} already exists with version ${this.options.version}`
+        );
         process.exit(1);
       }
     }
@@ -88,7 +96,9 @@ export class PublishModule {
     );
     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 = {
@@ -102,9 +112,7 @@ export class PublishModule {
         verbatimModuleSyntax: true,
         paths: originalTsConfig?.compilerOptions?.paths,
       },
-      exclude: [
-        'dist_*/**/*.d.ts',
-      ],
+      exclude: ['dist_*/**/*.d.ts'],
     };
     return JSON.stringify(tsconfigJson, null, 2);
   }
@@ -139,11 +147,21 @@ export class PublishModule {
         'npmextra.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}`
@@ -159,14 +177,14 @@ export class PublishModule {
     await packageJson.write();
 
     // tsconfig.json
-    const originalTsConfigJson = await plugins.smartfile.SmartFile.fromString(
+    const tsconfigJson = await plugins.smartfile.SmartFile.fromString(
       plugins.path.join(this.options.publishModDirFullPath, 'tsconfig.json'),
       await this.createTsconfigJson(),
       'utf8'
     );
-    await originalTsConfigJson.write();
+    await tsconfigJson.write();
 
-    // ts folder
+    // 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)
@@ -183,16 +201,37 @@ export class PublishModule {
       plugins.path.join(this.options.monoRepoDir, 'license'),
       plugins.path.join(this.options.publishModDirFullPath, 'license')
     );
+
+    // 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);
+    await plugins.smartfile.memory.toFs(fileContent, plugins.path.join(this.options.publishModDirFullPath, 'cli.js'));
   }
 
   public async publish() {
+    logPublish(`Publishing ${this.options.name} v${this.options.version}...`);
     const smartshellInstance = new plugins.smartshell.Smartshell({
       executor: 'bash',
     });
@@ -206,5 +245,6 @@ export class PublishModule {
         } --no-git-checks --registry https://${registryUrl}`
       );
     }
+    logSuccess(`Successfully published ${this.options.name} v${this.options.version}!`);
   }
 }

ts/classes.tspublish.ts

@@ -1,23 +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;
 
-  public async publish (monorepoDirArg: string) {
+  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();
@@ -25,9 +42,9 @@ export class TsPublish {
     }
   }
 
-  public async getModuleSubDirs (dirArg: string) {
+  public async getModuleSubDirs(dirArg: string) {
     const subDirs = await plugins.smartfile.fs.listFolders(dirArg);
-    const publishModules: {[key: string]: interfaces.ITsPublishJson} = {};
+    const publishModules: { [key: string]: interfaces.ITsPublishJson } = {};
     for (const subDir of subDirs) {
       if (!subDir.startsWith('ts')) {
         continue;
@@ -37,10 +54,15 @@ export class TsPublish {
       if (!hasPublishJson) {
         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', subDir);
+      publishModules[subDir] = JSON.parse(
+        plugins.smartfile.fs.toStringSync(plugins.path.join(subDir, 'tspublish.json'))
+      );
     }
-    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 * 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

@@ -2,4 +2,103 @@ import * as plugins from './plugins.js';
 import * as commitinfo from './00_commitinfo_data.js';
 
 export const logger = plugins.smartlog.Smartlog.createForCommitinfo(commitinfo.commitinfo);
-logger.enableConsole();
+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/paths.ts

@@ -2,6 +2,8 @@ import * as plugins from './plugins.js';
 
 export const cwd = process.cwd();
 
-export const packageDir = plugins.path.join(plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url), '..');
+export const packageDir = plugins.path.join(
+  plugins.smartpath.get.dirnameFromImportMetaUrl(import.meta.url),
+  '..',
+);
 export const nogitDir = plugins.path.join(packageDir, '.nogit');
-

ts/plugins.ts

@@ -1,16 +1,16 @@
 // node native scope
 import * as path from 'path';
-export {
-  path,
-}
+export { path };
 
 // @push.rocks scope
+import * as consolecolor from '@push.rocks/consolecolor';
 import * as smartfile from '@push.rocks/smartfile';
 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 };
+export { consolecolor, smartfile, smartcli, smartdelay, smartlog, smartnpm, smartpath, smartrequest, smartshell };

tsconfig.json

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