v2.1.0

assets/templates/multienv/deno.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "experimentalDecorators": true,
+    "lib": ["ES2022", "DOM"],
+    "target": "ES2022",
+    "checkJs": true
+  },
+  "nodeModulesDir": true
+}

assets/templates/tsconfig_update/tsconfig.json

@@ -1,8 +1,5 @@
 {
   "compilerOptions": {
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true,
-    "useDefineForClassFields": false,
     "target": "ES2022",
     "module": "NodeNext",
     "moduleResolution": "NodeNext",

changelog.md

@@ -1,5 +1,130 @@
 # Changelog
 
+## 2025-11-29 - 2.1.0 - feat(mod_services)
+Add global service registry and global commands for managing project containers
+
+- Introduce GlobalRegistry class to track registered projects, their containers, ports and last activity (ts/mod_services/classes.globalregistry.ts)
+- Add global CLI mode for services (use -g/--global) with commands: list, status, stop, cleanup (ts/mod_services/index.ts)
+- ServiceManager now registers the current project with the global registry when starting services and unregisters when all containers are removed (ts/mod_services/classes.servicemanager.ts)
+- Global handlers to list projects, show aggregated status, stop containers across projects and cleanup stale entries
+- Bump dependency @push.rocks/smartfile to ^13.1.0 in package.json
+
+## 2025-11-27 - 2.0.0 - BREAKING CHANGE(core)
+Migrate filesystem to smartfs (async) and add Elasticsearch service support; refactor format/commit/meta modules
+
+- Replace @push.rocks/smartfile usage with @push.rocks/smartfs across the codebase; all filesystem operations are now async (SmartFs.file(...).read()/write(), SmartFs.directory(...).list()/create()/delete(), etc.)
+- Convert formerly synchronous helpers and APIs to async (notable: detectProjectType, getProjectName, readCurrentVersion and related version bumping logic). Callers updated accordingly.
+- Add Elasticsearch support to services: new config fields (ELASTICSEARCH_*), Docker run/start/stop/logs/status handling, and ELASTICSEARCH_URL in service configuration.
+- Refactor formatting subsystem: cache and rollback/backup systems removed/disabled for stability, format planner execution simplified (sequential), diff/stats reporting updated to use smartfs.
+- Update package.json dependencies: bump @git.zone/tsbuild, tsrun, tstest; upgrade @push.rocks/smartfile to v13 and add @push.rocks/smartfs dependency; update @types/node.
+- Update commit flow and changelog generation to use smartfs for reading/writing files and to await version/branch detection where necessary.
+- Expose a SmartFs instance via plugins and adjust all mod.* plugin files to import/use smartfs where required.
+- Breaking change: Public and internal APIs that previously used synchronous smartfile APIs are now asynchronous. Consumers and scripts must await these functions and use the new smartfs API.
+
+## 2025-11-17 - 1.21.5 - fix(tsconfig)
+Remove emitDecoratorMetadata from tsconfig template
+
+- Removed the "emitDecoratorMetadata" compiler option from assets/templates/tsconfig_update/tsconfig.json
+- This updates the tsconfig template to avoid emitting decorator metadata when targeting ES2022
+
+## 2025-11-17 - 1.21.4 - fix(tsconfig template)
+Remove experimentalDecorators and useDefineForClassFields from tsconfig template
+
+- Removed experimentalDecorators option from assets/templates/tsconfig_update/tsconfig.json
+- Removed useDefineForClassFields option from assets/templates/tsconfig_update/tsconfig.json
+
+## 2025-11-17 - 1.21.3 - fix(assets/templates/multienv)
+Remove unused Bun configuration template (assets/templates/multienv/bunfig.toml)
+
+- Deleted assets/templates/multienv/bunfig.toml which previously provided Bun TypeScript decorator configuration
+- Cleans up stale/unused template to avoid shipping obsolete Bun config
+- No functional code changes; removes an unused asset file
+
+## 2025-11-17 - 1.21.2 - fix(templates/multienv)
+Disable useDefineForClassFields in multienv TypeScript configs to ensure decorator compatibility
+
+- Set useDefineForClassFields = false in assets/templates/multienv/bunfig.toml to keep Bun's transpiler compatible with decorator usage
+- Set "useDefineForClassFields": false in assets/templates/multienv/deno.json to ensure Deno/TypeScript compiler emits class fields compatible with decorators
+
+## 2025-11-17 - 1.21.1 - fix(templates.multienv)
+Enable checkJs in multienv Deno template to enable JS type checking
+
+- Added "checkJs": true to compilerOptions in assets/templates/multienv/deno.json to enable JavaScript type checking for the Deno multienv template
+
+## 2025-11-17 - 1.21.0 - feat(multienv)
+Add multi-env templates enabling TypeScript decorators for Bun and Deno; rename npmextra config key to szci
+
+- Added assets/templates/multienv/bunfig.toml to enable Bun TypeScript transpiler experimentalDecorators
+- Added assets/templates/multienv/deno.json with experimentalDecorators, lib and target set for ES2022
+- Updated npmextra.json: renamed top-level config key from "npmci" to "szci" (keeps npmGlobalTools, npmAccessLevel and npmRegistryUrl unchanged)
+
+## 2025-11-06 - 1.20.0 - feat(commit)
+Add non-interactive --yes (-y) flag to commit command to auto-accept AI recommendations and optionally push with -p
+
+- Add -y / --yes flag to gitzone commit to auto-accept AI-generated commit recommendations without interactive prompts
+- Support -yp or -y -p combinations to auto-accept and push to origin; -p / --push remains the separate control for pushing
+- Implementation creates a smartinteract AnswerBucket programmatically when -y is used and populates commitType, commitScope, commitDescription and pushToOrigin
+- Preserves existing UI output and interactive flow when -y is not used; fully backward compatible and CI/CD friendly
+- Updated CLI usage and documentation (readme.hints.md) to document the new flags
+
+## 2025-11-05 - 1.19.9 - fix(mod_commit)
+Refactor version bumping to a unified implementation for npm and Deno; remove npm-exec based helpers and add file-based version readers/updaters to avoid npm warning pollution
+
+- Removed legacy npm/deno-specific helpers (bumpNpmVersion, syncVersionToDenoJson, bumpDenoVersion) that relied on executing npm and caused warning pollution
+- Added readCurrentVersion() to read version from package.json or deno.json
+- Added updateVersionFile() helper to write version directly into JSON files
+- Added unified bumpProjectVersion() that handles npm, deno and both with a single code path; reuses calculateNewVersion()
+- Stages updated files, commits v<newVersion> and creates a tag v<newVersion>
+- Benefits: no npm warning pollution in deno.json, simpler git history, consistent behavior across project types
+
+## 2025-11-04 - 1.19.8 - fix(package.json)
+Bump @git.zone/tsdoc dependency to ^1.9.2
+
+- Updated dependency @git.zone/tsdoc from ^1.9.1 to ^1.9.2 in package.json
+
+## 2025-11-04 - 1.19.7 - fix(dependencies)
+Bump @git.zone/tsdoc to ^1.9.1
+
+- Updated package.json dependency @git.zone/tsdoc from ^1.9.0 to ^1.9.1
+
+## 2025-11-04 - 1.19.6 - fix(cli)
+Bump @git.zone/tsdoc dependency to ^1.9.0
+
+- Updated dependency @git.zone/tsdoc from ^1.8.3 to ^1.9.0 in package.json
+
+## 2025-11-04 - 1.19.5 - fix(cli)
+Bump @git.zone/tsdoc to ^1.8.3 and add local .claude settings for allowed permissions
+
+- Updated dependency @git.zone/tsdoc from ^1.8.2 to ^1.8.3
+- Added .claude/settings.local.json to declare allowed permissions for local tooling (Bash commands, Docker, npm, WebFetch and MCP actions)
+
+## 2025-11-03 - 1.19.3 - fix(tsdoc)
+Bump @git.zone/tsdoc to ^1.8.0 and add .claude local settings
+
+- Upgrade dependency @git.zone/tsdoc from ^1.6.1 to ^1.8.0 in package.json
+- Add .claude/settings.local.json for local assistant permissions/configuration
+
+## 2025-11-03 - 1.19.2 - fix(tsdoc)
+Bump @git.zone/tsdoc to ^1.6.1 and add .claude/settings.local.json
+
+- Update dependency @git.zone/tsdoc from ^1.6.0 to ^1.6.1
+- Add .claude/settings.local.json to include local Claude settings/permissions
+
+## 2025-11-02 - 1.19.1 - fix(dependencies)
+Bump dependencies and add local Claude settings
+
+- Bump devDependencies: @git.zone/tsbuild -> ^2.7.1, @git.zone/tsrun -> ^1.6.2, @git.zone/tstest -> ^2.7.0
+- Upgrade runtime dependencies: @git.zone/tsdoc -> ^1.6.0; update @push.rocks packages (smartcli ^4.0.19, smartjson ^5.2.0, smartlog ^3.1.10, smartnetwork ^4.4.0, etc.)
+- Add .claude/settings.local.json (local project permissions/settings file)
+
+## 2025-10-23 - 1.19.0 - feat(mod_commit)
+Add CLI UI helpers and improve commit workflow with progress, recommendations and summary
+
+- Introduce ts/mod_commit/mod.ui.ts: reusable CLI UI helpers (pretty headers, sections, AI recommendation box, step printer, commit summary and helpers for consistent messaging).
+- Refactor ts/mod_commit/index.ts: use new UI functions to display AI recommendations, show step-by-step progress for baking commit info, generating changelog, staging, committing, bumping version and optional push; include commit SHA in final summary.
+- Enhance ts/mod_commit/mod.helpers.ts: bumpProjectVersion now accepts currentStep/totalSteps to report progress and returns a consistent newVersion after handling npm/deno/both cases.
+- Add .claude/settings.local.json: local permissions configuration for development tooling.
+
 ## 2025-10-23 - 1.18.9 - fix(mod_commit)
 Stage and commit deno.json when bumping/syncing versions and create/update git tags
 

npmextra.json

@@ -1,5 +1,5 @@
 {
-  "npmci": {
+  "szci": {
     "npmGlobalTools": [],
     "npmAccessLevel": "private",
     "npmRegistryUrl": "verdaccio.lossless.one"

package.json

@@ -1,7 +1,7 @@
 {
   "name": "@git.zone/cli",
   "private": false,
-  "version": "1.18.9",
+  "version": "2.1.0",
   "description": "A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.",
   "main": "dist_ts/index.ts",
   "typings": "dist_ts/index.d.ts",
@@ -57,18 +57,17 @@
   },
   "homepage": "https://gitlab.com/gitzone/private/gitzone#readme",
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.6.8",
-    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^2.3.6",
+    "@git.zone/tsbuild": "^3.1.0",
+    "@git.zone/tsrun": "^2.0.0",
+    "@git.zone/tstest": "^3.1.3",
     "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartfile": "^11.2.7",
     "@push.rocks/smartinteract": "^2.0.16",
-    "@push.rocks/smartnetwork": "^4.1.2",
+    "@push.rocks/smartnetwork": "^4.4.0",
     "@push.rocks/smartshell": "^3.3.0",
-    "@types/node": "^22.15.18"
+    "@types/node": "^24.10.1"
   },
   "dependencies": {
-    "@git.zone/tsdoc": "^1.5.2",
+    "@git.zone/tsdoc": "^1.9.2",
     "@git.zone/tspublish": "^1.10.3",
     "@push.rocks/commitinfo": "^1.0.12",
     "@push.rocks/early": "^4.0.4",
@@ -77,12 +76,14 @@
     "@push.rocks/npmextra": "^5.3.3",
     "@push.rocks/projectinfo": "^5.0.2",
     "@push.rocks/smartchok": "^1.1.1",
-    "@push.rocks/smartcli": "^4.0.11",
+    "@push.rocks/smartcli": "^4.0.19",
     "@push.rocks/smartdiff": "^1.0.3",
+    "@push.rocks/smartfile": "^13.1.0",
+    "@push.rocks/smartfs": "^1.1.0",
     "@push.rocks/smartgulp": "^3.0.4",
-    "@push.rocks/smartjson": "^5.0.20",
+    "@push.rocks/smartjson": "^5.2.0",
     "@push.rocks/smartlegal": "^1.0.27",
-    "@push.rocks/smartlog": "^3.1.9",
+    "@push.rocks/smartlog": "^3.1.10",
     "@push.rocks/smartlog-destination-local": "^9.0.2",
     "@push.rocks/smartmustache": "^3.0.2",
     "@push.rocks/smartnpm": "^2.0.6",

readme.hints.md

@@ -89,6 +89,41 @@ The format module is responsible for project standardization:
 5. **Performance Optimizations**: Parallel execution and caching
 6. **Reporting**: Diff views, statistics, verbose logging
 7. **Architecture**: Clean separation of concerns with new classes
+8. **Unified Version Bumping**: Self-managed version updates eliminating npm warning pollution in deno.json
+
+### Version Bumping Refactor (Latest)
+
+The commit module's version bumping has been refactored to eliminate npm command dependencies:
+
+**Changes:**
+- Removed `bumpNpmVersion()` - was causing npm warnings to pollute deno.json
+- Removed `syncVersionToDenoJson()` - no longer needed with unified approach
+- Removed separate `bumpDenoVersion()` - replaced by unified implementation
+- Added `readCurrentVersion()` helper - reads from either package.json or deno.json
+- Added `updateVersionFile()` helper - updates JSON files directly
+- Unified `bumpProjectVersion()` - handles npm/deno/both with single clean code path
+
+**Benefits:**
+- No npm warning pollution in version fields
+- Full control over version bumping process
+- Simpler git history (no amending, no force-tagging)
+- Same code path for all project types
+- Reuses existing `calculateNewVersion()` function
+
+### Auto-Accept Flag for Commits
+
+The commit module now supports `-y/--yes` flag for non-interactive commits:
+
+**Usage:**
+- `gitzone commit -y` - Auto-accepts AI recommendations without prompts
+- `gitzone commit -yp` - Auto-accepts and pushes to origin
+- Separate `-p/--push` flag controls push behavior
+
+**Implementation:**
+- Creates AnswerBucket programmatically when `-y` flag detected
+- Preserves all UI output for transparency
+- Fully backward compatible with interactive mode
+- CI/CD friendly for automated workflows
 
 ## Development Tips
 
@@ -137,6 +172,27 @@ The format module is responsible for project standardization:
 
 ## CLI Usage
 
+### Commit Commands
+
+```bash
+# Interactive commit (default)
+gitzone commit
+
+# Auto-accept AI recommendations (no prompts)
+gitzone commit -y
+gitzone commit --yes
+
+# Auto-accept and push to origin
+gitzone commit -yp
+gitzone commit -y -p
+gitzone commit --yes --push
+
+# Run format before commit
+gitzone commit --format
+```
+
+### Format Commands
+
 ```bash
 # Basic format
 gitzone format
@@ -187,7 +243,60 @@ gitzone format --clean-backups
 
 ## API Changes
 
-- smartfile API updated to use fs._ and memory._ namespaces
+### Smartfile v13 Migration (Latest - Completed)
+
+The project has been fully migrated from @push.rocks/smartfile v11 to v13, which introduced a major breaking change where filesystem operations were split into two separate packages:
+
+**Packages:**
+- `@push.rocks/smartfile` v13.0.1 - File representation classes (SmartFile, StreamFile, VirtualDirectory)
+- `@push.rocks/smartfs` v1.1.0 - Filesystem operations (read, write, exists, stat, etc.)
+
+**Key API Changes:**
+1. **File Reading**:
+   - Old: `plugins.smartfile.fs.toStringSync(path)` or `plugins.smartfile.fs.toObjectSync(path)`
+   - New: `await plugins.smartfs.file(path).encoding('utf8').read()` + JSON.parse if needed
+   - Important: `read()` returns `string | Buffer` - use `as string` type assertion when encoding is set
+
+2. **File Writing**:
+   - Old: `plugins.smartfile.memory.toFs(content, path)` or `plugins.smartfile.memory.toFsSync(content, path)`
+   - New: `await plugins.smartfs.file(path).encoding('utf8').write(content)`
+
+3. **File Existence**:
+   - Old: `plugins.smartfile.fs.fileExists(path)` or `plugins.smartfile.fs.fileExistsSync(path)`
+   - New: `await plugins.smartfs.file(path).exists()`
+
+4. **Directory Operations**:
+   - Old: `plugins.smartfile.fs.ensureDir(path)`
+   - New: `await plugins.smartfs.directory(path).recursive().create()`
+   - Old: `plugins.smartfile.fs.remove(path)`
+   - New: `await plugins.smartfs.directory(path).recursive().delete()` or `await plugins.smartfs.file(path).delete()`
+
+5. **Directory Listing**:
+   - Old: `plugins.smartfile.fs.listFolders(path)` or `plugins.smartfile.fs.listFoldersSync(path)`
+   - New: `await plugins.smartfs.directory(path).list()` then filter by `stats.isDirectory`
+   - Note: `list()` returns `IDirectoryEntry[]` with `path` and `name` properties - use `stat()` to check if directory
+
+6. **File Stats**:
+   - Old: `stats.isDirectory()` (method)
+   - New: `stats.isDirectory` (boolean property)
+   - Old: `stats.mtimeMs`
+   - New: `stats.mtime.getTime()`
+
+7. **SmartFile Factory**:
+   - Old: Direct SmartFile instantiation
+   - New: `plugins.smartfile.SmartFileFactory.nodeFs()` then factory methods
+
+**Migration Pattern:**
+All sync methods must become async. Functions that were previously synchronous (like `getProjectName()`) now return `Promise<T>` and must be awaited.
+
+**Affected Modules:**
+- ts/mod_format/* (largest area - 15+ files)
+- ts/mod_commit/* (version bumping)
+- ts/mod_services/* (configuration management)
+- ts/mod_meta/* (meta repository management)
+- ts/mod_standard/* (template listing)
+- ts/mod_template/* (template operations)
+
+**Previous API Changes:**
 - smartnpm requires instance creation: `new NpmRegistry()`
-- All file operations now use updated APIs
 - Type imports use `import type` for proper verbatim module syntax

ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@git.zone/cli',
-  version: '1.18.9',
+  version: '2.1.0',
   description: 'A comprehensive CLI tool for enhancing and managing local development workflows with gitzone utilities, focusing on project setup, version control, code formatting, and template management.'
 }

ts/mod_commit/index.ts

@@ -4,6 +4,7 @@ import * as plugins from './mod.plugins.js';
 import * as paths from '../paths.js';
 import { logger } from '../gitzone.logging.js';
 import * as helpers from './mod.helpers.js';
+import * as ui from './mod.ui.js';
 
 export const run = async (argvArg: any) => {
   if (argvArg.format) {
@@ -11,7 +12,8 @@ export const run = async (argvArg: any) => {
     await formatMod.run();
   }
 
-  logger.log('info', `gathering facts...`);
+  ui.printHeader('🔍 Analyzing repository changes...');
+
   const aidoc = new plugins.tsdoc.AiDoc();
   await aidoc.start();
 
@@ -19,16 +21,39 @@ export const run = async (argvArg: any) => {
 
   await aidoc.stop();
 
-  logger.log(
-    'info',
-    `---------
-    Next recommended commit would be:
-    ===========
-    -> ${nextCommitObject.recommendedNextVersion}:
-    -> ${nextCommitObject.recommendedNextVersionLevel}(${nextCommitObject.recommendedNextVersionScope}): ${nextCommitObject.recommendedNextVersionMessage}
-    ===========
-  `,
-  );
+  ui.printRecommendation({
+    recommendedNextVersion: nextCommitObject.recommendedNextVersion,
+    recommendedNextVersionLevel: nextCommitObject.recommendedNextVersionLevel,
+    recommendedNextVersionScope: nextCommitObject.recommendedNextVersionScope,
+    recommendedNextVersionMessage: nextCommitObject.recommendedNextVersionMessage,
+  });
+
+  let answerBucket: plugins.smartinteract.AnswerBucket;
+
+  // Check if -y or --yes flag is set to auto-accept recommendations
+  if (argvArg.y || argvArg.yes) {
+    // Auto-mode: create AnswerBucket programmatically
+    logger.log('info', '✓ Auto-accepting AI recommendations (--yes flag)');
+
+    answerBucket = new plugins.smartinteract.AnswerBucket();
+    answerBucket.addAnswer({
+      name: 'commitType',
+      value: nextCommitObject.recommendedNextVersionLevel,
+    });
+    answerBucket.addAnswer({
+      name: 'commitScope',
+      value: nextCommitObject.recommendedNextVersionScope,
+    });
+    answerBucket.addAnswer({
+      name: 'commitDescription',
+      value: nextCommitObject.recommendedNextVersionMessage,
+    });
+    answerBucket.addAnswer({
+      name: 'pushToOrigin',
+      value: !!(argvArg.p || argvArg.push), // Only push if -p flag also provided
+    });
+  } else {
+    // Interactive mode: prompt user for input
     const commitInteract = new plugins.smartinteract.SmartInteract();
     commitInteract.addQuestions([
       {
@@ -57,7 +82,8 @@ export const run = async (argvArg: any) => {
         default: true,
       },
     ]);
-  const answerBucket = await commitInteract.runQueue();
+    answerBucket = await commitInteract.runQueue();
+  }
   const commitString = createCommitStringFromAnswerBucket(answerBucket);
   const commitVersionType = (() => {
     switch (answerBucket.getAnswerFor('commitType')) {
@@ -70,20 +96,30 @@ export const run = async (argvArg: any) => {
     }
   })();
 
-  logger.log('info', `OK! Creating commit with message '${commitString}'`);
+  ui.printHeader('✨ Creating Semantic Commit');
+  ui.printCommitMessage(commitString);
   const smartshellInstance = new plugins.smartshell.Smartshell({
     executor: 'bash',
     sourceFilePaths: [],
   });
 
-  logger.log('info', `Baking commitinfo into code ...`);
+  // Determine total steps (6 if pushing, 5 if not)
+  const totalSteps = answerBucket.getAnswerFor('pushToOrigin') && !(process.env.CI === 'true') ? 6 : 5;
+  let currentStep = 0;
+
+  // Step 1: Baking commitinfo
+  currentStep++;
+  ui.printStep(currentStep, totalSteps, '🔧 Baking commit info into code', 'in-progress');
   const commitInfo = new plugins.commitinfo.CommitInfo(
     paths.cwd,
     commitVersionType,
   );
   await commitInfo.writeIntoPotentialDirs();
+  ui.printStep(currentStep, totalSteps, '🔧 Baking commit info into code', 'done');
 
-  logger.log('info', `Writing changelog.md ...`);
+  // Step 2: Writing changelog
+  currentStep++;
+  ui.printStep(currentStep, totalSteps, '📄 Generating changelog.md', 'in-progress');
   let changelog = nextCommitObject.changelog;
   changelog = changelog.replaceAll(
     '{{nextVersion}}',
@@ -106,27 +142,58 @@ export const run = async (argvArg: any) => {
     changelog = changelog.replaceAll('\n{{nextVersionDetails}}', '');
   }
 
-  await plugins.smartfile.memory.toFs(
-    changelog,
-    plugins.path.join(paths.cwd, `changelog.md`),
-  );
+  await plugins.smartfs
+    .file(plugins.path.join(paths.cwd, `changelog.md`))
+    .encoding('utf8')
+    .write(changelog);
+  ui.printStep(currentStep, totalSteps, '📄 Generating changelog.md', 'done');
 
-  logger.log('info', `Staging files for commit:`);
+  // Step 3: Staging files
+  currentStep++;
+  ui.printStep(currentStep, totalSteps, '📦 Staging files', 'in-progress');
   await smartshellInstance.exec(`git add -A`);
+  ui.printStep(currentStep, totalSteps, '📦 Staging files', 'done');
+
+  // Step 4: Creating commit
+  currentStep++;
+  ui.printStep(currentStep, totalSteps, '💾 Creating git commit', 'in-progress');
   await smartshellInstance.exec(`git commit -m "${commitString}"`);
+  ui.printStep(currentStep, totalSteps, '💾 Creating git commit', 'done');
 
-  // Detect project type and bump version accordingly
+  // Step 5: Bumping version
+  currentStep++;
   const projectType = await helpers.detectProjectType();
-  await helpers.bumpProjectVersion(projectType, commitVersionType);
+  const newVersion = await helpers.bumpProjectVersion(projectType, commitVersionType, currentStep, totalSteps);
 
+  // Step 6: Push to remote (optional)
+  const currentBranch = await helpers.detectCurrentBranch();
   if (
     answerBucket.getAnswerFor('pushToOrigin') &&
     !(process.env.CI === 'true')
   ) {
-    // Detect current branch instead of hardcoding "master"
-    const currentBranch = await helpers.detectCurrentBranch();
+    currentStep++;
+    ui.printStep(currentStep, totalSteps, `🚀 Pushing to origin/${currentBranch}`, 'in-progress');
     await smartshellInstance.exec(`git push origin ${currentBranch} --follow-tags`);
+    ui.printStep(currentStep, totalSteps, `🚀 Pushing to origin/${currentBranch}`, 'done');
   }
+
+  console.log(''); // Add spacing before summary
+
+  // Get commit SHA for summary
+  const commitShaResult = await smartshellInstance.exec('git rev-parse --short HEAD');
+  const commitSha = commitShaResult.stdout.trim();
+
+  // Print final summary
+  ui.printSummary({
+    projectType,
+    branch: currentBranch,
+    commitType: answerBucket.getAnswerFor('commitType'),
+    commitScope: answerBucket.getAnswerFor('commitScope'),
+    commitMessage: answerBucket.getAnswerFor('commitDescription'),
+    newVersion: newVersion,
+    commitSha: commitSha,
+    pushed: answerBucket.getAnswerFor('pushToOrigin') && !(process.env.CI === 'true'),
+  });
 };
 
 const createCommitStringFromAnswerBucket = (

ts/mod_commit/mod.helpers.ts

@@ -1,6 +1,7 @@
 import * as plugins from './mod.plugins.js';
 import * as paths from '../paths.js';
 import { logger } from '../gitzone.logging.js';
+import * as ui from './mod.ui.js';
 
 export type ProjectType = 'npm' | 'deno' | 'both' | 'none';
 export type VersionType = 'patch' | 'minor' | 'major';
@@ -39,8 +40,8 @@ export async function detectProjectType(): Promise<ProjectType> {
   const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
   const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
 
-  const hasPackageJson = await plugins.smartfile.fs.fileExists(packageJsonPath);
-  const hasDenoJson = await plugins.smartfile.fs.fileExists(denoJsonPath);
+  const hasPackageJson = await plugins.smartfs.file(packageJsonPath).exists();
+  const hasDenoJson = await plugins.smartfs.file(denoJsonPath).exists();
 
   if (hasPackageJson && hasDenoJson) {
     logger.log('info', 'Detected dual project (npm + deno)');
@@ -90,145 +91,128 @@ function calculateNewVersion(currentVersion: string, versionType: VersionType):
 }
 
 /**
- * Bumps the version in deno.json, commits the change, and creates a tag
- * @param versionType Type of version bump
- * @returns The new version string
+ * Reads the current version from package.json or deno.json
+ * @param projectType The project type to determine which file to read
+ * @returns The current version string
  */
-export async function bumpDenoVersion(versionType: VersionType): Promise<string> {
-  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
-  const smartshellInstance = new plugins.smartshell.Smartshell({
-    executor: 'bash',
-    sourceFilePaths: [],
-  });
+async function readCurrentVersion(projectType: ProjectType): Promise<string> {
+  if (projectType === 'npm' || projectType === 'both') {
+    const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
+    const content = (await plugins.smartfs
+      .file(packageJsonPath)
+      .encoding('utf8')
+      .read()) as string;
+    const packageJson = JSON.parse(content) as { version?: string };
 
-  try {
-    // Read deno.json
-    const denoConfig = plugins.smartfile.fs.toObjectSync(
-      denoJsonPath
-    ) as { version?: string };
+    if (!packageJson.version) {
+      throw new Error('package.json does not contain a version field');
+    }
+    return packageJson.version;
+  } else {
+    const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
+    const content = (await plugins.smartfs
+      .file(denoJsonPath)
+      .encoding('utf8')
+      .read()) as string;
+    const denoConfig = JSON.parse(content) as { version?: string };
 
     if (!denoConfig.version) {
       throw new Error('deno.json does not contain a version field');
     }
-
-    const currentVersion = denoConfig.version;
-    const newVersion = calculateNewVersion(currentVersion, versionType);
-
-    logger.log('info', `Bumping deno.json version: ${currentVersion} → ${newVersion}`);
-
-    // Update version
-    denoConfig.version = newVersion;
-
-    // Write back to disk
-    await plugins.smartfile.memory.toFs(
-      JSON.stringify(denoConfig, null, 2) + '\n',
-      denoJsonPath
-    );
-
-    // Stage the deno.json file
-    await smartshellInstance.exec('git add deno.json');
-
-    // Commit the version bump
-    await smartshellInstance.exec(`git commit -m "v${newVersion}"`);
-
-    // Create the version tag
-    await smartshellInstance.exec(`git tag v${newVersion} -m "v${newVersion}"`);
-
-    logger.log('info', `Created commit and tag v${newVersion}`);
-
-    return newVersion;
-  } catch (error) {
-    throw new Error(`Failed to bump deno.json version: ${error.message}`);
+    return denoConfig.version;
   }
 }
 
 /**
- * Bumps the version in package.json using npm version command
- * @param versionType Type of version bump
+ * Updates the version field in a JSON file (package.json or deno.json)
+ * @param filePath Path to the JSON file
+ * @param newVersion The new version to write
+ */
+async function updateVersionFile(filePath: string, newVersion: string): Promise<void> {
+  const content = (await plugins.smartfs
+    .file(filePath)
+    .encoding('utf8')
+    .read()) as string;
+  const config = JSON.parse(content) as { version?: string };
+  config.version = newVersion;
+  await plugins.smartfs
+    .file(filePath)
+    .encoding('utf8')
+    .write(JSON.stringify(config, null, 2) + '\n');
+}
+
+/**
+ * Bumps the project version based on project type
+ * Handles npm-only, deno-only, and dual projects with unified logic
+ * @param projectType The detected project type
+ * @param versionType The type of version bump
+ * @param currentStep The current step number for progress display
+ * @param totalSteps The total number of steps for progress display
  * @returns The new version string
  */
-async function bumpNpmVersion(versionType: VersionType): Promise<string> {
-  const smartshellInstance = new plugins.smartshell.Smartshell({
-    executor: 'bash',
-    sourceFilePaths: [],
-  });
-
-  logger.log('info', `Bumping package.json version using npm version ${versionType}`);
-  const result = await smartshellInstance.exec(`npm version ${versionType}`);
-
-  // npm version returns the new version with a 'v' prefix, e.g., "v1.2.3"
-  const newVersion = result.stdout.trim().replace(/^v/, '');
-  return newVersion;
+export async function bumpProjectVersion(
+  projectType: ProjectType,
+  versionType: VersionType,
+  currentStep?: number,
+  totalSteps?: number
+): Promise<string> {
+  if (projectType === 'none') {
+    throw new Error('Cannot bump version: no package.json or deno.json found');
+  }
+
+  const projectEmoji = projectType === 'npm' ? '📦' : projectType === 'deno' ? '🦕' : '🔀';
+  const description = `🏷️  Bumping version (${projectEmoji} ${projectType})`;
+
+  if (currentStep && totalSteps) {
+    ui.printStep(currentStep, totalSteps, description, 'in-progress');
   }
 
-/**
- * Syncs the version from package.json to deno.json and amends the npm commit
- * @param version The version to sync
- */
-async function syncVersionToDenoJson(version: string): Promise<void> {
-  const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
   const smartshellInstance = new plugins.smartshell.Smartshell({
     executor: 'bash',
     sourceFilePaths: [],
   });
 
   try {
-    const denoConfig = plugins.smartfile.fs.toObjectSync(
-      denoJsonPath
-    ) as { version?: string };
+    // 1. Read current version
+    const currentVersion = await readCurrentVersion(projectType);
 
-    logger.log('info', `Syncing version to deno.json: ${version}`);
-    denoConfig.version = version;
+    // 2. Calculate new version (reuse existing function!)
+    const newVersion = calculateNewVersion(currentVersion, versionType);
 
-    await plugins.smartfile.memory.toFs(
-      JSON.stringify(denoConfig, null, 2) + '\n',
-      denoJsonPath
-    );
+    logger.log('info', `Bumping version: ${currentVersion} → ${newVersion}`);
 
-    // Stage the deno.json file
-    await smartshellInstance.exec('git add deno.json');
+    // 3. Determine which files to update
+    const filesToUpdate: string[] = [];
+    const packageJsonPath = plugins.path.join(paths.cwd, 'package.json');
+    const denoJsonPath = plugins.path.join(paths.cwd, 'deno.json');
 
-    // Amend the npm version commit to include deno.json
-    await smartshellInstance.exec('git commit --amend --no-edit');
-
-    // Re-create the tag with force to update it
-    await smartshellInstance.exec(`git tag -fa v${version} -m "v${version}"`);
-
-    logger.log('info', `Amended commit to include deno.json and updated tag v${version}`);
-  } catch (error) {
-    throw new Error(`Failed to sync version to deno.json: ${error.message}`);
-  }
+    if (projectType === 'npm' || projectType === 'both') {
+      await updateVersionFile(packageJsonPath, newVersion);
+      filesToUpdate.push('package.json');
     }
 
-/**
- * Bumps the project version based on project type
- * @param projectType The detected project type
- * @param versionType The type of version bump
- * @returns The new version string
- */
-export async function bumpProjectVersion(
-  projectType: ProjectType,
-  versionType: VersionType
-): Promise<string> {
-  switch (projectType) {
-    case 'npm':
-      return await bumpNpmVersion(versionType);
+    if (projectType === 'deno' || projectType === 'both') {
+      await updateVersionFile(denoJsonPath, newVersion);
+      filesToUpdate.push('deno.json');
+    }
 
-    case 'deno':
-      return await bumpDenoVersion(versionType);
+    // 4. Stage all updated files
+    await smartshellInstance.exec(`git add ${filesToUpdate.join(' ')}`);
+
+    // 5. Create version commit
+    await smartshellInstance.exec(`git commit -m "v${newVersion}"`);
+
+    // 6. Create version tag
+    await smartshellInstance.exec(`git tag v${newVersion} -m "v${newVersion}"`);
+
+    logger.log('info', `Created commit and tag v${newVersion}`);
+
+    if (currentStep && totalSteps) {
+      ui.printStep(currentStep, totalSteps, description, 'done');
+    }
 
-    case 'both': {
-      // Bump npm version first (it handles git tags)
-      const newVersion = await bumpNpmVersion(versionType);
-      // Then sync to deno.json
-      await syncVersionToDenoJson(newVersion);
     return newVersion;
-    }
-
-    case 'none':
-      throw new Error('Cannot bump version: no package.json or deno.json found');
-
-    default:
-      throw new Error(`Unknown project type: ${projectType}`);
+  } catch (error) {
+    throw new Error(`Failed to bump project version: ${error.message}`);
   }
 }

ts/mod_commit/mod.ui.ts

@@ -0,0 +1,196 @@
+import { logger } from '../gitzone.logging.js';
+
+/**
+ * UI helper module for beautiful CLI output
+ */
+
+interface ICommitSummary {
+  projectType: string;
+  branch: string;
+  commitType: string;
+  commitScope: string;
+  commitMessage: string;
+  newVersion: string;
+  commitSha?: string;
+  pushed: boolean;
+  repoUrl?: string;
+}
+
+interface IRecommendation {
+  recommendedNextVersion: string;
+  recommendedNextVersionLevel: string;
+  recommendedNextVersionScope: string;
+  recommendedNextVersionMessage: string;
+}
+
+/**
+ * Print a header with a box around it
+ */
+export function printHeader(title: string): void {
+  const width = 57;
+  const padding = Math.max(0, width - title.length - 2);
+  const leftPad = Math.floor(padding / 2);
+  const rightPad = padding - leftPad;
+
+  console.log('');
+  console.log('╭─' + '─'.repeat(width) + '─╮');
+  console.log('│  ' + title + ' '.repeat(rightPad + leftPad) + '  │');
+  console.log('╰─' + '─'.repeat(width) + '─╯');
+  console.log('');
+}
+
+/**
+ * Print a section with a border
+ */
+export function printSection(title: string, lines: string[]): void {
+  const width = 59;
+
+  console.log('┌─ ' + title + ' ' + '─'.repeat(Math.max(0, width - title.length - 3)) + '┐');
+  console.log('│' + ' '.repeat(width) + '│');
+
+  for (const line of lines) {
+    const padding = width - line.length;
+    console.log('│  ' + line + ' '.repeat(Math.max(0, padding - 2)) + '│');
+  }
+
+  console.log('│' + ' '.repeat(width) + '│');
+  console.log('└─' + '─'.repeat(width) + '─┘');
+  console.log('');
+}
+
+/**
+ * Print AI recommendations in a nice box
+ */
+export function printRecommendation(recommendation: IRecommendation): void {
+  const lines = [
+    `Suggested Version:  v${recommendation.recommendedNextVersion}`,
+    `Suggested Type:     ${recommendation.recommendedNextVersionLevel}`,
+    `Suggested Scope:    ${recommendation.recommendedNextVersionScope}`,
+    `Suggested Message:  ${recommendation.recommendedNextVersionMessage}`,
+  ];
+
+  printSection('📊 AI Recommendations', lines);
+}
+
+/**
+ * Print a progress step
+ */
+export function printStep(
+  current: number,
+  total: number,
+  description: string,
+  status: 'in-progress' | 'done' | 'error'
+): void {
+  const statusIcon = status === 'done' ? '✓' : status === 'error' ? '✗' : '⏳';
+  const dots = '.'.repeat(Math.max(0, 40 - description.length));
+
+  console.log(`  [${current}/${total}] ${description}${dots} ${statusIcon}`);
+
+  // Clear the line on next update if in progress
+  if (status === 'in-progress') {
+    process.stdout.write('\x1b[1A'); // Move cursor up one line
+  }
+}
+
+/**
+ * Get emoji for project type
+ */
+function getProjectTypeEmoji(projectType: string): string {
+  switch (projectType) {
+    case 'npm':
+      return '📦 npm';
+    case 'deno':
+      return '🦕 Deno';
+    case 'both':
+      return '🔀 npm + Deno';
+    default:
+      return '❓ Unknown';
+  }
+}
+
+/**
+ * Get emoji for commit type
+ */
+function getCommitTypeEmoji(commitType: string): string {
+  switch (commitType) {
+    case 'fix':
+      return '🔧 fix';
+    case 'feat':
+      return '✨ feat';
+    case 'BREAKING CHANGE':
+      return '💥 BREAKING CHANGE';
+    default:
+      return commitType;
+  }
+}
+
+/**
+ * Print final commit summary
+ */
+export function printSummary(summary: ICommitSummary): void {
+  const lines = [
+    `Project Type:   ${getProjectTypeEmoji(summary.projectType)}`,
+    `Branch:         🌿 ${summary.branch}`,
+    `Commit Type:    ${getCommitTypeEmoji(summary.commitType)}`,
+    `Scope:          📍 ${summary.commitScope}`,
+    `New Version:    🏷️  v${summary.newVersion}`,
+  ];
+
+  if (summary.commitSha) {
+    lines.push(`Commit SHA:     📌 ${summary.commitSha}`);
+  }
+
+  if (summary.pushed) {
+    lines.push(`Remote:         ✓ Pushed successfully`);
+  } else {
+    lines.push(`Remote:         ⊘ Not pushed (local only)`);
+  }
+
+  if (summary.repoUrl && summary.commitSha) {
+    lines.push('');
+    lines.push(`View at: ${summary.repoUrl}/commit/${summary.commitSha}`);
+  }
+
+  printSection('✅ Commit Summary', lines);
+
+  if (summary.pushed) {
+    console.log('🎉 All done! Your changes are committed and pushed.\n');
+  } else {
+    console.log('✓ Commit created successfully.\n');
+  }
+}
+
+/**
+ * Print an info message with consistent formatting
+ */
+export function printInfo(message: string): void {
+  console.log(`  ℹ️  ${message}`);
+}
+
+/**
+ * Print a success message
+ */
+export function printSuccess(message: string): void {
+  console.log(`  ✓ ${message}`);
+}
+
+/**
+ * Print a warning message
+ */
+export function printWarning(message: string): void {
+  logger.log('warn', `⚠️  ${message}`);
+}
+
+/**
+ * Print an error message
+ */
+export function printError(message: string): void {
+  logger.log('error', `✗ ${message}`);
+}
+
+/**
+ * Print commit message being created
+ */
+export function printCommitMessage(commitString: string): void {
+  console.log(`\n  📝 Commit: ${commitString}\n`);
+}

ts/mod_format/classes.baseformatter.ts

@@ -65,15 +65,15 @@ export abstract class BaseFormatter {
       normalizedPath = './' + filepath;
     }
 
-    await plugins.smartfile.memory.toFs(content, normalizedPath);
+    await plugins.smartfs.file(normalizedPath).encoding('utf8').write(content);
   }
 
   protected async createFile(filepath: string, content: string): Promise<void> {
-    await plugins.smartfile.memory.toFs(content, filepath);
+    await plugins.smartfs.file(filepath).encoding('utf8').write(content);
   }
 
   protected async deleteFile(filepath: string): Promise<void> {
-    await plugins.smartfile.fs.remove(filepath);
+    await plugins.smartfs.file(filepath).delete();
   }
 
   protected async shouldProcessFile(filepath: string): Promise<boolean> {

ts/mod_format/classes.changecache.ts

@@ -25,7 +25,7 @@ export class ChangeCache {
   }
 
   async initialize(): Promise<void> {
-    await plugins.smartfile.fs.ensureDir(this.cacheDir);
+    await plugins.smartfs.directory(this.cacheDir).recursive().create();
   }
 
   async getManifest(): Promise<ICacheManifest> {
@@ -35,13 +35,16 @@ export class ChangeCache {
       files: [],
     };
 
-    const exists = await plugins.smartfile.fs.fileExists(this.manifestPath);
+    const exists = await plugins.smartfs.file(this.manifestPath).exists();
     if (!exists) {
       return defaultManifest;
     }
 
     try {
-      const content = plugins.smartfile.fs.toStringSync(this.manifestPath);
+      const content = (await plugins.smartfs
+        .file(this.manifestPath)
+        .encoding('utf8')
+        .read()) as string;
       const manifest = JSON.parse(content);
 
       // Validate the manifest structure
@@ -57,7 +60,7 @@ export class ChangeCache {
       );
       // Try to delete the corrupted file
       try {
-        await plugins.smartfile.fs.remove(this.manifestPath);
+        await plugins.smartfs.file(this.manifestPath).delete();
       } catch (removeError) {
         // Ignore removal errors
       }
@@ -72,11 +75,14 @@ export class ChangeCache {
     }
 
     // Ensure directory exists
-    await plugins.smartfile.fs.ensureDir(this.cacheDir);
+    await plugins.smartfs.directory(this.cacheDir).recursive().create();
 
     // Write directly with proper JSON stringification
     const jsonContent = JSON.stringify(manifest, null, 2);
-    await plugins.smartfile.memory.toFs(jsonContent, this.manifestPath);
+    await plugins.smartfs
+      .file(this.manifestPath)
+      .encoding('utf8')
+      .write(jsonContent);
   }
 
   async hasFileChanged(filePath: string): Promise<boolean> {
@@ -85,20 +91,23 @@ export class ChangeCache {
       : plugins.path.join(paths.cwd, filePath);
 
     // Check if file exists
-    const exists = await plugins.smartfile.fs.fileExists(absolutePath);
+    const exists = await plugins.smartfs.file(absolutePath).exists();
     if (!exists) {
       return true; // File doesn't exist, so it's "changed" (will be created)
     }
 
     // Get current file stats
-    const stats = await plugins.smartfile.fs.stat(absolutePath);
+    const stats = await plugins.smartfs.file(absolutePath).stat();
 
     // Skip directories
-    if (stats.isDirectory()) {
+    if (stats.isDirectory) {
       return false; // Directories are not processed
     }
 
-    const content = plugins.smartfile.fs.toStringSync(absolutePath);
+    const content = (await plugins.smartfs
+      .file(absolutePath)
+      .encoding('utf8')
+      .read()) as string;
     const currentChecksum = this.calculateChecksum(content);
 
     // Get cached info
@@ -113,7 +122,7 @@ export class ChangeCache {
     return (
       cachedFile.checksum !== currentChecksum ||
       cachedFile.size !== stats.size ||
-      cachedFile.modified !== stats.mtimeMs
+      cachedFile.modified !== stats.mtime.getTime()
     );
   }
 
@@ -123,14 +132,17 @@ export class ChangeCache {
       : plugins.path.join(paths.cwd, filePath);
 
     // Get current file stats
-    const stats = await plugins.smartfile.fs.stat(absolutePath);
+    const stats = await plugins.smartfs.file(absolutePath).stat();
 
     // Skip directories
-    if (stats.isDirectory()) {
+    if (stats.isDirectory) {
       return; // Don't cache directories
     }
 
-    const content = plugins.smartfile.fs.toStringSync(absolutePath);
+    const content = (await plugins.smartfs
+      .file(absolutePath)
+      .encoding('utf8')
+      .read()) as string;
     const checksum = this.calculateChecksum(content);
 
     // Update manifest
@@ -140,7 +152,7 @@ export class ChangeCache {
     const cacheEntry: IFileCache = {
       path: filePath,
       checksum,
-      modified: stats.mtimeMs,
+      modified: stats.mtime.getTime(),
       size: stats.size,
     };
 
@@ -176,7 +188,7 @@ export class ChangeCache {
         ? file.path
         : plugins.path.join(paths.cwd, file.path);
 
-      if (await plugins.smartfile.fs.fileExists(absolutePath)) {
+      if (await plugins.smartfs.file(absolutePath).exists()) {
         validFiles.push(file);
       }
     }

ts/mod_format/classes.diffreporter.ts

@@ -21,14 +21,15 @@ export class DiffReporter {
     }
 
     try {
-      const exists = await plugins.smartfile.fs.fileExists(change.path);
+      const exists = await plugins.smartfs.file(change.path).exists();
       if (!exists) {
         return null;
       }
 
-      const currentContent = await plugins.smartfile.fs.toStringSync(
-        change.path,
-      );
+      const currentContent = (await plugins.smartfs
+        .file(change.path)
+        .encoding('utf8')
+        .read()) as string;
 
       // For planned changes, we need the new content
       if (!change.content) {
@@ -107,10 +108,10 @@ export class DiffReporter {
       })),
     };
 
-    await plugins.smartfile.memory.toFs(
-      JSON.stringify(report, null, 2),
-      outputPath,
-    );
+    await plugins.smartfs
+      .file(outputPath)
+      .encoding('utf8')
+      .write(JSON.stringify(report, null, 2));
     logger.log('info', `Diff report saved to ${outputPath}`);
   }
 

ts/mod_format/classes.formatstats.ts

@@ -192,10 +192,10 @@ export class FormatStats {
       moduleStats: Array.from(this.stats.moduleStats.values()),
     };
 
-    await plugins.smartfile.memory.toFs(
-      JSON.stringify(report, null, 2),
-      outputPath,
-    );
+    await plugins.smartfs
+      .file(outputPath)
+      .encoding('utf8')
+      .write(JSON.stringify(report, null, 2));
     logger.log('info', `Statistics report saved to ${outputPath}`);
   }
 

ts/mod_format/classes.rollbackmanager.ts

@@ -36,21 +36,27 @@ export class RollbackManager {
       : plugins.path.join(paths.cwd, filepath);
 
     // Check if file exists
-    const exists = await plugins.smartfile.fs.fileExists(absolutePath);
+    const exists = await plugins.smartfs.file(absolutePath).exists();
     if (!exists) {
       // File doesn't exist yet (will be created), so we skip backup
       return;
     }
 
     // Read file content and metadata
-    const content = plugins.smartfile.fs.toStringSync(absolutePath);
-    const stats = await plugins.smartfile.fs.stat(absolutePath);
+    const content = (await plugins.smartfs
+      .file(absolutePath)
+      .encoding('utf8')
+      .read()) as string;
+    const stats = await plugins.smartfs.file(absolutePath).stat();
     const checksum = this.calculateChecksum(content);
 
     // Create backup
     const backupPath = this.getBackupPath(operationId, filepath);
-    await plugins.smartfile.fs.ensureDir(plugins.path.dirname(backupPath));
-    await plugins.smartfile.memory.toFs(content, backupPath);
+    await plugins.smartfs
+      .directory(plugins.path.dirname(backupPath))
+      .recursive()
+      .create();
+    await plugins.smartfs.file(backupPath).encoding('utf8').write(content);
 
     // Update operation
     operation.files.push({
@@ -84,7 +90,10 @@ export class RollbackManager {
 
       // Verify backup integrity
       const backupPath = this.getBackupPath(operationId, file.path);
-      const backupContent = plugins.smartfile.fs.toStringSync(backupPath);
+      const backupContent = await plugins.smartfs
+        .file(backupPath)
+        .encoding('utf8')
+        .read();
       const backupChecksum = this.calculateChecksum(backupContent);
 
       if (backupChecksum !== file.checksum) {
@@ -92,7 +101,10 @@ export class RollbackManager {
       }
 
       // Restore file
-      await plugins.smartfile.memory.toFs(file.originalContent, absolutePath);
+      await plugins.smartfs
+        .file(absolutePath)
+        .encoding('utf8')
+        .write(file.originalContent);
 
       // Restore permissions
       const mode = parseInt(file.permissions, 8);
@@ -129,7 +141,7 @@ export class RollbackManager {
         'operations',
         operation.id,
       );
-      await plugins.smartfile.fs.remove(operationDir);
+      await plugins.smartfs.directory(operationDir).recursive().delete();
 
       // Remove from manifest
       manifest.operations = manifest.operations.filter(
@@ -148,13 +160,16 @@ export class RollbackManager {
 
     for (const file of operation.files) {
       const backupPath = this.getBackupPath(operationId, file.path);
-      const exists = await plugins.smartfile.fs.fileExists(backupPath);
+      const exists = await plugins.smartfs.file(backupPath).exists();
 
       if (!exists) {
         return false;
       }
 
-      const content = plugins.smartfile.fs.toStringSync(backupPath);
+      const content = await plugins.smartfs
+        .file(backupPath)
+        .encoding('utf8')
+        .read();
       const checksum = this.calculateChecksum(content);
 
       if (checksum !== file.checksum) {
@@ -171,10 +186,11 @@ export class RollbackManager {
   }
 
   private async ensureBackupDir(): Promise<void> {
-    await plugins.smartfile.fs.ensureDir(this.backupDir);
-    await plugins.smartfile.fs.ensureDir(
-      plugins.path.join(this.backupDir, 'operations'),
-    );
+    await plugins.smartfs.directory(this.backupDir).recursive().create();
+    await plugins.smartfs
+      .directory(plugins.path.join(this.backupDir, 'operations'))
+      .recursive()
+      .create();
   }
 
   private generateOperationId(): string {
@@ -204,13 +220,16 @@ export class RollbackManager {
   private async getManifest(): Promise<{ operations: IFormatOperation[] }> {
     const defaultManifest = { operations: [] };
 
-    const exists = await plugins.smartfile.fs.fileExists(this.manifestPath);
+    const exists = await plugins.smartfs.file(this.manifestPath).exists();
     if (!exists) {
       return defaultManifest;
     }
 
     try {
-      const content = plugins.smartfile.fs.toStringSync(this.manifestPath);
+      const content = (await plugins.smartfs
+        .file(this.manifestPath)
+        .encoding('utf8')
+        .read()) as string;
       const manifest = JSON.parse(content);
 
       // Validate the manifest structure
@@ -228,7 +247,7 @@ export class RollbackManager {
       );
       // Try to delete the corrupted file
       try {
-        await plugins.smartfile.fs.remove(this.manifestPath);
+        await plugins.smartfs.file(this.manifestPath).delete();
       } catch (removeError) {
         // Ignore removal errors
       }
@@ -249,7 +268,10 @@ export class RollbackManager {
 
     // Write directly with proper JSON stringification
     const jsonContent = JSON.stringify(manifest, null, 2);
-    await plugins.smartfile.memory.toFs(jsonContent, this.manifestPath);
+    await plugins.smartfs
+      .file(this.manifestPath)
+      .encoding('utf8')
+      .write(jsonContent);
   }
 
   private async getOperation(

ts/mod_format/format.cleanup.ts

@@ -13,12 +13,12 @@ const filesToDelete = [
 
 export const run = async (projectArg: Project) => {
   for (const relativeFilePath of filesToDelete) {
-    const fileExists = plugins.smartfile.fs.fileExistsSync(relativeFilePath);
+    const fileExists = await plugins.smartfs.file(relativeFilePath).exists();
     if (fileExists) {
       logger.log('info', `Found ${relativeFilePath}! Removing it!`);
-      plugins.smartfile.fs.removeSync(
-        plugins.path.join(paths.cwd, relativeFilePath),
-      );
+      await plugins.smartfs
+        .file(plugins.path.join(paths.cwd, relativeFilePath))
+        .delete();
     } else {
       logger.log('info', `Project is free of ${relativeFilePath}`);
     }

ts/mod_format/format.copy.ts

@@ -24,7 +24,12 @@ export const run = async (projectArg: Project) => {
 
     try {
       // Handle glob patterns
-      const files = await plugins.smartfile.fs.listFileTree('.', pattern.from);
+      const entries = await plugins.smartfs
+        .directory('.')
+        .recursive()
+        .filter(pattern.from)
+        .list();
+      const files = entries.map((entry) => entry.path);
 
       for (const file of files) {
         const sourcePath = file;
@@ -46,10 +51,13 @@ export const run = async (projectArg: Project) => {
         }
 
         // Ensure destination directory exists
-        await plugins.smartfile.fs.ensureDir(plugins.path.dirname(destPath));
+        await plugins.smartfs
+          .directory(plugins.path.dirname(destPath))
+          .recursive()
+          .create();
 
         // Copy file
-        await plugins.smartfile.fs.copy(sourcePath, destPath);
+        await plugins.smartfs.file(sourcePath).copy(destPath);
         logger.log('info', `Copied ${sourcePath} to ${destPath}`);
       }
     } catch (error) {

ts/mod_format/format.gitignore.ts

@@ -7,13 +7,15 @@ import { logger } from '../gitzone.logging.js';
 const gitignorePath = plugins.path.join(paths.cwd, './.gitignore');
 
 export const run = async (projectArg: Project) => {
-  const gitignoreExists = await plugins.smartfile.fs.fileExists(gitignorePath);
+  const gitignoreExists = await plugins.smartfs.file(gitignorePath).exists();
   let customContent = '';
 
   if (gitignoreExists) {
     // lets get the existing gitignore file
-    const existingGitIgnoreString =
-      plugins.smartfile.fs.toStringSync(gitignorePath);
+    const existingGitIgnoreString = (await plugins.smartfs
+      .file(gitignorePath)
+      .encoding('utf8')
+      .read()) as string;
 
     // Check for different custom section markers
     const customMarkers = ['#------# custom', '# custom'];
@@ -34,12 +36,17 @@ export const run = async (projectArg: Project) => {
 
   // Append the custom content if it exists
   if (customContent) {
-    const newGitignoreContent =
-      plugins.smartfile.fs.toStringSync(gitignorePath);
+    const newGitignoreContent = (await plugins.smartfs
+      .file(gitignorePath)
+      .encoding('utf8')
+      .read()) as string;
     // The template already ends with "#------# custom", so just append the content
     const finalContent =
       newGitignoreContent.trimEnd() + '\n' + customContent + '\n';
-    await plugins.smartfile.fs.toFs(finalContent, gitignorePath);
+    await plugins.smartfs
+      .file(gitignorePath)
+      .encoding('utf8')
+      .write(finalContent);
     logger.log('info', 'Updated .gitignore while preserving custom section!');
   } else {
     logger.log('info', 'Added a .gitignore!');

ts/mod_format/format.license.ts

@@ -7,9 +7,9 @@ import { logger } from '../gitzone.logging.js';
 const incompatibleLicenses: string[] = ['AGPL', 'GPL', 'SSPL'];
 
 export const run = async (projectArg: Project) => {
-  const nodeModulesInstalled = await plugins.smartfile.fs.isDirectory(
-    plugins.path.join(paths.cwd, 'node_modules'),
-  );
+  const nodeModulesInstalled = await plugins.smartfs
+    .directory(plugins.path.join(paths.cwd, 'node_modules'))
+    .exists();
   if (!nodeModulesInstalled) {
     logger.log('warn', 'No node_modules found. Skipping license check');
     return;

ts/mod_format/format.packagejson.ts

@@ -174,9 +174,11 @@ export const run = async (projectArg: Project) => {
       );
 
       // set overrides
-      const overrides = plugins.smartfile.fs.toObjectSync(
-        plugins.path.join(paths.assetsDir, 'overrides.json'),
-      );
+      const overridesContent = (await plugins.smartfs
+        .file(plugins.path.join(paths.assetsDir, 'overrides.json'))
+        .encoding('utf8')
+        .read()) as string;
+      const overrides = JSON.parse(overridesContent);
       packageJson.pnpm = packageJson.pnpm || {};
       packageJson.pnpm.overrides = overrides;
 

ts/mod_format/format.readme.ts

@@ -6,25 +6,22 @@ export const run = async () => {
   const readmeHintsPath = plugins.path.join(paths.cwd, 'readme.hints.md');
 
   // Check and initialize readme.md if it doesn't exist
-  const readmeExists = await plugins.smartfile.fs.fileExists(readmePath);
+  const readmeExists = await plugins.smartfs.file(readmePath).exists();
   if (!readmeExists) {
-    await plugins.smartfile.fs.toFs(
-      '# Project Readme\n\nThis is the initial readme file.',
-      readmePath,
-    );
+    await plugins.smartfs.file(readmePath)
+      .encoding('utf8')
+      .write('# Project Readme\n\nThis is the initial readme file.');
     console.log('Initialized readme.md');
   } else {
     console.log('readme.md already exists');
   }
 
   // Check and initialize readme.hints.md if it doesn't exist
-  const readmeHintsExists =
-    await plugins.smartfile.fs.fileExists(readmeHintsPath);
+  const readmeHintsExists = await plugins.smartfs.file(readmeHintsPath).exists();
   if (!readmeHintsExists) {
-    await plugins.smartfile.fs.toFs(
-      '# Project Readme Hints\n\nThis is the initial readme hints file.',
-      readmeHintsPath,
-    );
+    await plugins.smartfs.file(readmeHintsPath)
+      .encoding('utf8')
+      .write('# Project Readme Hints\n\nThis is the initial readme hints file.');
     console.log('Initialized readme.hints.md');
   } else {
     console.log('readme.hints.md already exists');

ts/mod_format/format.tsconfig.ts

@@ -7,10 +7,11 @@ import { Project } from '../classes.project.js';
 export const run = async (projectArg: Project) => {
   // lets care about tsconfig.json
   logger.log('info', 'Formatting tsconfig.json...');
-  const tsconfigSmartfile = await plugins.smartfile.SmartFile.fromFilePath(
+  const factory = plugins.smartfile.SmartFileFactory.nodeFs();
+  const tsconfigSmartfile = await factory.fromFilePath(
     plugins.path.join(paths.cwd, 'tsconfig.json'),
   );
-  const tsconfigObject = JSON.parse(tsconfigSmartfile.contentBuffer.toString());
+  const tsconfigObject = JSON.parse(tsconfigSmartfile.parseContentAsString());
   tsconfigObject.compilerOptions = tsconfigObject.compilerOptions || {};
   tsconfigObject.compilerOptions.baseUrl = '.';
   tsconfigObject.compilerOptions.paths = {};
@@ -23,8 +24,8 @@ export const run = async (projectArg: Project) => {
       `./${publishModule}/index.js`,
     ];
   }
-  tsconfigSmartfile.setContentsFromString(
-    JSON.stringify(tsconfigObject, null, 2),
-  );
+  await tsconfigSmartfile.editContentAsString(async () => {
+    return JSON.stringify(tsconfigObject, null, 2);
+  });
   await tsconfigSmartfile.write();
 };

ts/mod_format/formatters/cleanup.formatter.ts

@@ -20,7 +20,7 @@ export class CleanupFormatter extends BaseFormatter {
     ];
 
     for (const file of filesToRemove) {
-      const exists = await plugins.smartfile.fs.fileExists(file);
+      const exists = await plugins.smartfs.file(file).exists();
       if (exists) {
         changes.push({
           type: 'delete',

ts/mod_format/formatters/prettier.formatter.ts

@@ -41,16 +41,23 @@ export class PrettierFormatter extends BaseFormatter {
     // Add files from TypeScript directories
     for (const dir of includeDirs) {
       const globPattern = `${dir}/**/*.${extensions}`;
-      const dirFiles = await plugins.smartfile.fs.listFileTree(
-        '.',
-        globPattern,
-      );
+      const dirEntries = await plugins.smartfs
+        .directory('.')
+        .recursive()
+        .filter(globPattern)
+        .list();
+      const dirFiles = dirEntries.map((entry) => entry.path);
       allFiles.push(...dirFiles);
     }
 
     // Add root config files
     for (const pattern of rootConfigFiles) {
-      const rootFiles = await plugins.smartfile.fs.listFileTree('.', pattern);
+      const rootEntries = await plugins.smartfs
+        .directory('.')
+        .recursive()
+        .filter(pattern)
+        .list();
+      const rootFiles = rootEntries.map((entry) => entry.path);
       // Only include files at root level (no slashes in path)
       const rootLevelFiles = rootFiles.filter((f) => !f.includes('/'));
       allFiles.push(...rootLevelFiles);
@@ -66,8 +73,8 @@ export class PrettierFormatter extends BaseFormatter {
     const validFiles: string[] = [];
     for (const file of files) {
       try {
-        const stats = await plugins.smartfile.fs.stat(file);
-        if (!stats.isDirectory()) {
+        const stats = await plugins.smartfs.file(file).stat();
+        if (!stats.isDirectory) {
           validFiles.push(file);
         }
       } catch (error) {
@@ -148,7 +155,10 @@ export class PrettierFormatter extends BaseFormatter {
       }
 
       // Read current content
-      const content = plugins.smartfile.fs.toStringSync(change.path);
+      const content = (await plugins.smartfs
+        .file(change.path)
+        .encoding('utf8')
+        .read()) as string;
 
       // Format with prettier
       const prettier = await import('prettier');

ts/mod_format/index.ts

@@ -101,7 +101,12 @@ export let run = async (
     // Plan phase
     logger.log('info', 'Analyzing project for format operations...');
     let plan = options.fromPlan
-      ? JSON.parse(await plugins.smartfile.fs.toStringSync(options.fromPlan))
+      ? JSON.parse(
+          (await plugins.smartfs
+            .file(options.fromPlan)
+            .encoding('utf8')
+            .read()) as string,
+        )
       : await planner.planFormat(activeFormatters);
 
     // Display plan
@@ -109,10 +114,10 @@ export let run = async (
 
     // Save plan if requested
     if (options.savePlan) {
-      await plugins.smartfile.memory.toFs(
-        JSON.stringify(plan, null, 2),
-        options.savePlan,
-      );
+      await plugins.smartfs
+        .file(options.savePlan)
+        .encoding('utf8')
+        .write(JSON.stringify(plan, null, 2));
       logger.log('info', `Plan saved to ${options.savePlan}`);
     }
 

ts/mod_meta/meta.classes.meta.ts

@@ -48,15 +48,17 @@ export class Meta {
   public async readDirectory() {
     await this.syncToRemote(true);
     logger.log('info', `reading directory`);
-    const metaFileExists = plugins.smartfile.fs.fileExistsSync(
-      this.filePaths.metaJson,
-    );
+    const metaFileExists = await plugins.smartfs
+      .file(this.filePaths.metaJson)
+      .exists();
     if (!metaFileExists) {
       throw new Error(`meta file does not exist at ${this.filePaths.metaJson}`);
     }
-    this.metaRepoData = plugins.smartfile.fs.toObjectSync(
-      this.filePaths.metaJson,
-    );
+    const content = (await plugins.smartfs
+      .file(this.filePaths.metaJson)
+      .encoding('utf8')
+      .read()) as string;
+    this.metaRepoData = JSON.parse(content);
   }
 
   /**
@@ -78,15 +80,15 @@ export class Meta {
    */
   public async writeToDisk() {
     // write .meta.json to disk
-    plugins.smartfile.memory.toFsSync(
-      JSON.stringify(this.metaRepoData, null, 2),
-      this.filePaths.metaJson,
-    );
+    await plugins.smartfs
+      .file(this.filePaths.metaJson)
+      .encoding('utf8')
+      .write(JSON.stringify(this.metaRepoData, null, 2));
     // write .gitignore to disk
-    plugins.smartfile.memory.toFsSync(
-      await this.generateGitignore(),
-      this.filePaths.gitIgnore,
-    );
+    await plugins.smartfs
+      .file(this.filePaths.gitIgnore)
+      .encoding('utf8')
+      .write(await this.generateGitignore());
   }
 
   /**
@@ -112,10 +114,25 @@ export class Meta {
    */
   public async updateLocalRepos() {
     await this.syncToRemote();
-    const projects = plugins.smartfile.fs.toObjectSync(
-      this.filePaths.metaJson,
-    ).projects;
-    const preExistingFolders = plugins.smartfile.fs.listFoldersSync(this.cwd);
+    const metaContent = (await plugins.smartfs
+      .file(this.filePaths.metaJson)
+      .encoding('utf8')
+      .read()) as string;
+    const projects = JSON.parse(metaContent).projects;
+    const entries = await plugins.smartfs.directory(this.cwd).list();
+    const preExistingFolders: string[] = [];
+    for (const entry of entries) {
+      try {
+        const stats = await plugins.smartfs
+          .file(plugins.path.join(this.cwd, entry.path))
+          .stat();
+        if (stats.isDirectory) {
+          preExistingFolders.push(entry.name);
+        }
+      } catch {
+        // Skip entries that can't be accessed
+      }
+    }
     for (const preExistingFolderArg of preExistingFolders) {
       if (
         preExistingFolderArg !== '.git' &&
@@ -143,9 +160,17 @@ export class Meta {
     await this.sortMetaRepoData();
     const missingRepos: string[] = [];
     for (const key of Object.keys(this.metaRepoData.projects)) {
-      plugins.smartfile.fs.isDirectory(key)
-        ? logger.log('ok', `${key} -> is already cloned`)
-        : missingRepos.push(key);
+      const fullPath = plugins.path.join(this.cwd, key);
+      try {
+        const stats = await plugins.smartfs.file(fullPath).stat();
+        if (stats.isDirectory) {
+          logger.log('ok', `${key} -> is already cloned`);
+        } else {
+          missingRepos.push(key);
+        }
+      } catch {
+        missingRepos.push(key);
+      }
     }
 
     logger.log('info', `found ${missingRepos.length} missing repos`);
@@ -165,7 +190,20 @@ export class Meta {
     await this.syncToRemote();
 
     // go recursive
-    const folders = await plugins.smartfile.fs.listFolders(this.cwd);
+    const listEntries = await plugins.smartfs.directory(this.cwd).list();
+    const folders: string[] = [];
+    for (const entry of listEntries) {
+      try {
+        const stats = await plugins.smartfs
+          .file(plugins.path.join(this.cwd, entry.path))
+          .stat();
+        if (stats.isDirectory) {
+          folders.push(entry.name);
+        }
+      } catch {
+        // Skip entries that can't be accessed
+      }
+    }
     const childMetaRepositories: string[] = [];
     for (const folder of folders) {
       logger.log('info', folder);
@@ -180,26 +218,30 @@ export class Meta {
    */
   public async initProject() {
     await this.syncToRemote(true);
-    const fileExists = await plugins.smartfile.fs.fileExists(
-      this.filePaths.metaJson,
-    );
+    const fileExists = await plugins.smartfs
+      .file(this.filePaths.metaJson)
+      .exists();
     if (!fileExists) {
-      await plugins.smartfile.memory.toFs(
+      await plugins.smartfs
+        .file(this.filePaths.metaJson)
+        .encoding('utf8')
+        .write(
           JSON.stringify({
             projects: {},
           }),
-        this.filePaths.metaJson,
         );
       logger.log(
         `success`,
         `created a new .meta.json in directory ${this.cwd}`,
       );
-      await plugins.smartfile.memory.toFs(
+      await plugins.smartfs
+        .file(this.filePaths.packageJson)
+        .encoding('utf8')
+        .write(
           JSON.stringify({
             name: this.dirName,
             version: '1.0.0',
           }),
-        this.filePaths.packageJson,
         );
       logger.log(
         `success`,
@@ -264,9 +306,10 @@ export class Meta {
     await this.writeToDisk();
 
     logger.log('info', 'removing directory from cwd');
-    await plugins.smartfile.fs.remove(
-      plugins.path.join(paths.cwd, projectNameArg),
-    );
+    await plugins.smartfs
+      .directory(plugins.path.join(paths.cwd, projectNameArg))
+      .recursive()
+      .delete();
     await this.updateLocalRepos();
   }
 }

ts/mod_services/classes.globalregistry.ts

@@ -0,0 +1,190 @@
+import * as plugins from '../plugins.js';
+import { DockerContainer } from './classes.dockercontainer.js';
+import { logger } from '../gitzone.logging.js';
+
+export interface IRegisteredProject {
+  projectPath: string;
+  projectName: string;
+  containers: {
+    mongo?: string;
+    minio?: string;
+    elasticsearch?: string;
+  };
+  ports: {
+    mongo?: number;
+    s3?: number;
+    s3Console?: number;
+    elasticsearch?: number;
+  };
+  enabledServices: string[];
+  lastActive: number;
+}
+
+export interface IGlobalRegistryData {
+  projects: { [projectPath: string]: IRegisteredProject };
+}
+
+export class GlobalRegistry {
+  private static instance: GlobalRegistry | null = null;
+  private kvStore: plugins.npmextra.KeyValueStore<IGlobalRegistryData>;
+  private docker: DockerContainer;
+
+  private constructor() {
+    this.kvStore = new plugins.npmextra.KeyValueStore({
+      typeArg: 'userHomeDir',
+      identityArg: 'gitzone-services',
+    });
+    this.docker = new DockerContainer();
+  }
+
+  /**
+   * Get the singleton instance
+   */
+  public static getInstance(): GlobalRegistry {
+    if (!GlobalRegistry.instance) {
+      GlobalRegistry.instance = new GlobalRegistry();
+    }
+    return GlobalRegistry.instance;
+  }
+
+  /**
+   * Register or update a project in the global registry
+   */
+  public async registerProject(data: Omit<IRegisteredProject, 'lastActive'>): Promise<void> {
+    const allData = await this.kvStore.readAll();
+    const projects = allData.projects || {};
+
+    projects[data.projectPath] = {
+      ...data,
+      lastActive: Date.now(),
+    };
+
+    await this.kvStore.writeKey('projects', projects);
+  }
+
+  /**
+   * Remove a project from the registry
+   */
+  public async unregisterProject(projectPath: string): Promise<void> {
+    const allData = await this.kvStore.readAll();
+    const projects = allData.projects || {};
+
+    if (projects[projectPath]) {
+      delete projects[projectPath];
+      await this.kvStore.writeKey('projects', projects);
+    }
+  }
+
+  /**
+   * Update the lastActive timestamp for a project
+   */
+  public async touchProject(projectPath: string): Promise<void> {
+    const allData = await this.kvStore.readAll();
+    const projects = allData.projects || {};
+
+    if (projects[projectPath]) {
+      projects[projectPath].lastActive = Date.now();
+      await this.kvStore.writeKey('projects', projects);
+    }
+  }
+
+  /**
+   * Get all registered projects
+   */
+  public async getAllProjects(): Promise<{ [path: string]: IRegisteredProject }> {
+    const allData = await this.kvStore.readAll();
+    return allData.projects || {};
+  }
+
+  /**
+   * Check if a project is registered
+   */
+  public async isRegistered(projectPath: string): Promise<boolean> {
+    const projects = await this.getAllProjects();
+    return !!projects[projectPath];
+  }
+
+  /**
+   * Get status of all containers across all registered projects
+   */
+  public async getGlobalStatus(): Promise<
+    Array<{
+      projectPath: string;
+      projectName: string;
+      containers: Array<{ name: string; status: string }>;
+      lastActive: number;
+    }>
+  > {
+    const projects = await this.getAllProjects();
+    const result: Array<{
+      projectPath: string;
+      projectName: string;
+      containers: Array<{ name: string; status: string }>;
+      lastActive: number;
+    }> = [];
+
+    for (const [path, project] of Object.entries(projects)) {
+      const containerStatuses: Array<{ name: string; status: string }> = [];
+
+      for (const containerName of Object.values(project.containers)) {
+        if (containerName) {
+          const status = await this.docker.getStatus(containerName);
+          containerStatuses.push({ name: containerName, status });
+        }
+      }
+
+      result.push({
+        projectPath: path,
+        projectName: project.projectName,
+        containers: containerStatuses,
+        lastActive: project.lastActive,
+      });
+    }
+
+    return result;
+  }
+
+  /**
+   * Stop all containers across all registered projects
+   */
+  public async stopAll(): Promise<{ stopped: string[]; failed: string[] }> {
+    const projects = await this.getAllProjects();
+    const stopped: string[] = [];
+    const failed: string[] = [];
+
+    for (const project of Object.values(projects)) {
+      for (const containerName of Object.values(project.containers)) {
+        if (containerName) {
+          const status = await this.docker.getStatus(containerName);
+          if (status === 'running') {
+            if (await this.docker.stop(containerName)) {
+              stopped.push(containerName);
+            } else {
+              failed.push(containerName);
+            }
+          }
+        }
+      }
+    }
+
+    return { stopped, failed };
+  }
+
+  /**
+   * Remove stale registry entries (projects that no longer exist on disk)
+   */
+  public async cleanup(): Promise<string[]> {
+    const projects = await this.getAllProjects();
+    const removed: string[] = [];
+
+    for (const projectPath of Object.keys(projects)) {
+      const exists = await plugins.smartfs.directory(projectPath).exists();
+      if (!exists) {
+        await this.unregisterProject(projectPath);
+        removed.push(projectPath);
+      }
+    }
+
+    return removed;
+  }
+}

ts/mod_services/classes.serviceconfiguration.ts

@@ -19,6 +19,11 @@ export interface IServiceConfig {
   S3_BUCKET: string;
   S3_ENDPOINT: string;
   S3_USESSL: boolean;
+  ELASTICSEARCH_HOST: string;
+  ELASTICSEARCH_PORT: string;
+  ELASTICSEARCH_USER: string;
+  ELASTICSEARCH_PASS: string;
+  ELASTICSEARCH_URL: string;
 }
 
 export class ServiceConfiguration {
@@ -61,10 +66,10 @@ export class ServiceConfiguration {
    * Save the configuration to file
    */
   public async saveConfig(): Promise<void> {
-    await plugins.smartfile.memory.toFs(
-      JSON.stringify(this.config, null, 2),
-      this.configPath
-    );
+    await plugins.smartfs
+      .file(this.configPath)
+      .encoding('utf8')
+      .write(JSON.stringify(this.config, null, 2));
   }
   
   /**
@@ -72,21 +77,24 @@ export class ServiceConfiguration {
    */
   private async ensureNogitDirectory(): Promise<void> {
     const nogitPath = plugins.path.join(process.cwd(), '.nogit');
-    await plugins.smartfile.fs.ensureDir(nogitPath);
+    await plugins.smartfs.directory(nogitPath).recursive().create();
   }
   
   /**
    * Check if configuration file exists
    */
   private async configExists(): Promise<boolean> {
-    return plugins.smartfile.fs.fileExists(this.configPath);
+    return plugins.smartfs.file(this.configPath).exists();
   }
   
   /**
    * Load configuration from file
    */
   private async loadConfig(): Promise<void> {
-    const configContent = plugins.smartfile.fs.toStringSync(this.configPath);
+    const configContent = (await plugins.smartfs
+      .file(this.configPath)
+      .encoding('utf8')
+      .read()) as string;
     this.config = JSON.parse(configContent);
   }
   
@@ -94,7 +102,7 @@ export class ServiceConfiguration {
    * Create default configuration
    */
   private async createDefaultConfig(): Promise<void> {
-    const projectName = helpers.getProjectName();
+    const projectName = await helpers.getProjectName();
     const mongoPort = await helpers.getRandomAvailablePort();
     const s3Port = await helpers.getRandomAvailablePort();
     let s3ConsolePort = s3Port + 1;
@@ -111,6 +119,10 @@ export class ServiceConfiguration {
     const mongoPortStr = mongoPort.toString();
     const s3Host = 'localhost';
     const s3PortStr = s3Port.toString();
+    const esHost = 'localhost';
+    const esPort = '9200';
+    const esUser = 'elastic';
+    const esPass = 'elastic';
 
     this.config = {
       PROJECT_NAME: projectName,
@@ -127,7 +139,12 @@ export class ServiceConfiguration {
       S3_SECRETKEY: 'defaultpass',
       S3_BUCKET: `${projectName}-documents`,
       S3_ENDPOINT: s3Host,
-      S3_USESSL: false
+      S3_USESSL: false,
+      ELASTICSEARCH_HOST: esHost,
+      ELASTICSEARCH_PORT: esPort,
+      ELASTICSEARCH_USER: esUser,
+      ELASTICSEARCH_PASS: esPass,
+      ELASTICSEARCH_URL: `http://${esUser}:${esPass}@${esHost}:${esPort}`
     };
 
     await this.saveConfig();
@@ -136,13 +153,14 @@ export class ServiceConfiguration {
     logger.log('info', `📍 MongoDB port: ${mongoPort}`);
     logger.log('info', `📍 S3 API port: ${s3Port}`);
     logger.log('info', `📍 S3 Console port: ${s3ConsolePort}`);
+    logger.log('info', `📍 Elasticsearch port: ${esPort}`);
   }
   
   /**
    * Update missing fields in existing configuration
    */
   private async updateMissingFields(): Promise<void> {
-    const projectName = helpers.getProjectName();
+    const projectName = await helpers.getProjectName();
     let updated = false;
     const fieldsAdded: string[] = [];
     
@@ -250,6 +268,38 @@ export class ServiceConfiguration {
       updated = true;
     }
 
+    if (!this.config.ELASTICSEARCH_HOST) {
+      this.config.ELASTICSEARCH_HOST = 'localhost';
+      fieldsAdded.push('ELASTICSEARCH_HOST');
+      updated = true;
+    }
+
+    if (!this.config.ELASTICSEARCH_PORT) {
+      this.config.ELASTICSEARCH_PORT = '9200';
+      fieldsAdded.push('ELASTICSEARCH_PORT');
+      updated = true;
+    }
+
+    if (!this.config.ELASTICSEARCH_USER) {
+      this.config.ELASTICSEARCH_USER = 'elastic';
+      fieldsAdded.push('ELASTICSEARCH_USER');
+      updated = true;
+    }
+
+    if (!this.config.ELASTICSEARCH_PASS) {
+      this.config.ELASTICSEARCH_PASS = 'elastic';
+      fieldsAdded.push('ELASTICSEARCH_PASS');
+      updated = true;
+    }
+
+    // Always update ELASTICSEARCH_URL based on current settings
+    const oldEsUrl = this.config.ELASTICSEARCH_URL;
+    this.config.ELASTICSEARCH_URL = `http://${this.config.ELASTICSEARCH_USER}:${this.config.ELASTICSEARCH_PASS}@${this.config.ELASTICSEARCH_HOST}:${this.config.ELASTICSEARCH_PORT}`;
+    if (oldEsUrl !== this.config.ELASTICSEARCH_URL) {
+      fieldsAdded.push('ELASTICSEARCH_URL');
+      updated = true;
+    }
+
     if (updated) {
       await this.saveConfig();
       logger.log('ok', `✅ Added missing fields: ${fieldsAdded.join(', ')}`);
@@ -272,7 +322,8 @@ export class ServiceConfiguration {
   public getContainerNames() {
     return {
       mongo: `${this.config.PROJECT_NAME}-mongodb`,
-      minio: `${this.config.PROJECT_NAME}-minio`
+      minio: `${this.config.PROJECT_NAME}-minio`,
+      elasticsearch: `${this.config.PROJECT_NAME}-elasticsearch`
     };
   }
 
@@ -282,7 +333,8 @@ export class ServiceConfiguration {
   public getDataDirectories() {
     return {
       mongo: plugins.path.join(process.cwd(), '.nogit', 'mongodata'),
-      minio: plugins.path.join(process.cwd(), '.nogit', 'miniodata')
+      minio: plugins.path.join(process.cwd(), '.nogit', 'miniodata'),
+      elasticsearch: plugins.path.join(process.cwd(), '.nogit', 'esdata')
     };
   }
   
@@ -331,10 +383,25 @@ export class ServiceConfiguration {
       }
     }
 
+    // Check Elasticsearch container
+    const esStatus = await this.docker.getStatus(containers.elasticsearch);
+    if (esStatus !== 'not_exists') {
+      const portMappings = await this.docker.getPortMappings(containers.elasticsearch);
+      if (portMappings && portMappings['9200']) {
+        const dockerPort = portMappings['9200'];
+        if (this.config.ELASTICSEARCH_PORT !== dockerPort) {
+          logger.log('note', `📍 Syncing Elasticsearch port from Docker: ${dockerPort}`);
+          this.config.ELASTICSEARCH_PORT = dockerPort;
+          updated = true;
+        }
+      }
+    }
+
     if (updated) {
       // Update derived fields
       this.config.MONGODB_URL = `mongodb://${this.config.MONGODB_USER}:${this.config.MONGODB_PASS}@${this.config.MONGODB_HOST}:${this.config.MONGODB_PORT}/${this.config.MONGODB_NAME}?authSource=admin`;
       this.config.S3_ENDPOINT = this.config.S3_HOST;
+      this.config.ELASTICSEARCH_URL = `http://${this.config.ELASTICSEARCH_USER}:${this.config.ELASTICSEARCH_PASS}@${this.config.ELASTICSEARCH_HOST}:${this.config.ELASTICSEARCH_PORT}`;
 
       await this.saveConfig();
       logger.log('ok', '✅ Configuration synced with Docker containers');
@@ -351,6 +418,7 @@ export class ServiceConfiguration {
     // Check if containers exist - if they do, ports are fine
     const mongoExists = await this.docker.exists(containers.mongo);
     const minioExists = await this.docker.exists(containers.minio);
+    const esExists = await this.docker.exists(containers.elasticsearch);
 
     // Only check port availability if containers don't exist
     if (!mongoExists) {
@@ -388,10 +456,22 @@ export class ServiceConfiguration {
       }
     }
 
+    if (!esExists) {
+      const esPort = parseInt(this.config.ELASTICSEARCH_PORT);
+      if (!(await helpers.isPortAvailable(esPort))) {
+        logger.log('note', `⚠️  Elasticsearch port ${esPort} is in use, finding new port...`);
+        const newPort = await helpers.getRandomAvailablePort();
+        this.config.ELASTICSEARCH_PORT = newPort.toString();
+        logger.log('ok', `✅ New Elasticsearch port: ${newPort}`);
+        updated = true;
+      }
+    }
+
     if (updated) {
       // Update derived fields
       this.config.MONGODB_URL = `mongodb://${this.config.MONGODB_USER}:${this.config.MONGODB_PASS}@${this.config.MONGODB_HOST}:${this.config.MONGODB_PORT}/${this.config.MONGODB_NAME}?authSource=admin`;
       this.config.S3_ENDPOINT = this.config.S3_HOST;
+      this.config.ELASTICSEARCH_URL = `http://${this.config.ELASTICSEARCH_USER}:${this.config.ELASTICSEARCH_PASS}@${this.config.ELASTICSEARCH_HOST}:${this.config.ELASTICSEARCH_PORT}`;
 
       await this.saveConfig();
     }
@@ -414,13 +494,18 @@ export class ServiceConfiguration {
       s3ConsolePort++;
     }
 
+    // Elasticsearch uses standard port 9200
+    const esPort = '9200';
+
     this.config.MONGODB_PORT = mongoPort.toString();
     this.config.S3_PORT = s3Port.toString();
     this.config.S3_CONSOLE_PORT = s3ConsolePort.toString();
+    this.config.ELASTICSEARCH_PORT = esPort;
 
     // Update derived fields
     this.config.MONGODB_URL = `mongodb://${this.config.MONGODB_USER}:${this.config.MONGODB_PASS}@${this.config.MONGODB_HOST}:${this.config.MONGODB_PORT}/${this.config.MONGODB_NAME}?authSource=admin`;
     this.config.S3_ENDPOINT = this.config.S3_HOST;
+    this.config.ELASTICSEARCH_URL = `http://${this.config.ELASTICSEARCH_USER}:${this.config.ELASTICSEARCH_PASS}@${this.config.ELASTICSEARCH_HOST}:${this.config.ELASTICSEARCH_PORT}`;
 
     await this.saveConfig();
 
@@ -428,5 +513,6 @@ export class ServiceConfiguration {
     logger.log('info', `  📍 MongoDB: ${mongoPort}`);
     logger.log('info', `  📍 S3 API: ${s3Port}`);
     logger.log('info', `  📍 S3 Console: ${s3ConsolePort}`);
+    logger.log('info', `  📍 Elasticsearch: ${esPort}`);
   }
 }

ts/mod_services/classes.servicemanager.ts

@@ -2,15 +2,19 @@ import * as plugins from './mod.plugins.js';
 import * as helpers from './helpers.js';
 import { ServiceConfiguration } from './classes.serviceconfiguration.js';
 import { DockerContainer } from './classes.dockercontainer.js';
+import { GlobalRegistry } from './classes.globalregistry.js';
 import { logger } from '../gitzone.logging.js';
 
 export class ServiceManager {
   private config: ServiceConfiguration;
   private docker: DockerContainer;
+  private enabledServices: string[] | null = null;
+  private globalRegistry: GlobalRegistry;
 
   constructor() {
     this.config = new ServiceConfiguration();
     this.docker = new DockerContainer();
+    this.globalRegistry = GlobalRegistry.getInstance();
   }
 
   /**
@@ -27,10 +31,157 @@ export class ServiceManager {
     await this.config.loadOrCreate();
     logger.log('info', `📋 Project: ${this.config.getConfig().PROJECT_NAME}`);
 
+    // Load service selection from npmextra.json
+    await this.loadServiceConfiguration();
+
     // Validate and update ports if needed
     await this.config.validateAndUpdatePorts();
   }
 
+  /**
+   * Load service configuration from npmextra.json
+   */
+  private async loadServiceConfiguration(): Promise<void> {
+    const npmextraConfig = new plugins.npmextra.Npmextra(process.cwd());
+    const gitzoneConfig = npmextraConfig.dataFor<any>('gitzone', {});
+
+    // Check if services array exists
+    if (!gitzoneConfig.services || !Array.isArray(gitzoneConfig.services) || gitzoneConfig.services.length === 0) {
+      // Prompt user to select services
+      const smartinteract = new plugins.smartinteract.SmartInteract();
+      const response = await smartinteract.askQuestion({
+        name: 'services',
+        type: 'checkbox',
+        message: 'Which services do you want to enable for this project?',
+        choices: [
+          { name: 'MongoDB', value: 'mongodb' },
+          { name: 'MinIO (S3)', value: 'minio' },
+          { name: 'Elasticsearch', value: 'elasticsearch' }
+        ],
+        default: ['mongodb', 'minio', 'elasticsearch']
+      });
+
+      this.enabledServices = response.value || ['mongodb', 'minio', 'elasticsearch'];
+
+      // Save to npmextra.json
+      await this.saveServiceConfiguration(this.enabledServices);
+    } else {
+      this.enabledServices = gitzoneConfig.services;
+      logger.log('info', `🔧 Enabled services: ${this.enabledServices.join(', ')}`);
+    }
+  }
+
+  /**
+   * Save service configuration to npmextra.json
+   */
+  private async saveServiceConfiguration(services: string[]): Promise<void> {
+    const npmextraPath = plugins.path.join(process.cwd(), 'npmextra.json');
+    let npmextraData: any = {};
+
+    // Read existing npmextra.json if it exists
+    if (await plugins.smartfs.file(npmextraPath).exists()) {
+      const content = await plugins.smartfs.file(npmextraPath).encoding('utf8').read();
+      npmextraData = JSON.parse(content as string);
+    }
+
+    // Update gitzone.services
+    if (!npmextraData.gitzone) {
+      npmextraData.gitzone = {};
+    }
+    npmextraData.gitzone.services = services;
+
+    // Write back to npmextra.json
+    await plugins.smartfs
+      .file(npmextraPath)
+      .encoding('utf8')
+      .write(JSON.stringify(npmextraData, null, 2));
+
+    logger.log('ok', `✅ Saved service configuration to npmextra.json`);
+    logger.log('info', `🔧 Enabled services: ${services.join(', ')}`);
+  }
+
+  /**
+   * Check if a service is enabled
+   */
+  private isServiceEnabled(service: string): boolean {
+    if (!this.enabledServices) {
+      return true; // If no configuration, enable all
+    }
+    return this.enabledServices.includes(service);
+  }
+
+  /**
+   * Register this project with the global registry
+   */
+  private async registerWithGlobalRegistry(): Promise<void> {
+    const config = this.config.getConfig();
+    const containers = this.config.getContainerNames();
+
+    await this.globalRegistry.registerProject({
+      projectPath: process.cwd(),
+      projectName: config.PROJECT_NAME,
+      containers: {
+        mongo: containers.mongo,
+        minio: containers.minio,
+        elasticsearch: containers.elasticsearch,
+      },
+      ports: {
+        mongo: parseInt(config.MONGODB_PORT),
+        s3: parseInt(config.S3_PORT),
+        s3Console: parseInt(config.S3_CONSOLE_PORT),
+        elasticsearch: parseInt(config.ELASTICSEARCH_PORT),
+      },
+      enabledServices: this.enabledServices || ['mongodb', 'minio', 'elasticsearch'],
+    });
+  }
+
+  /**
+   * Start all enabled services
+   */
+  public async startAll(): Promise<void> {
+    let first = true;
+    if (this.isServiceEnabled('mongodb')) {
+      if (!first) console.log();
+      await this.startMongoDB();
+      first = false;
+    }
+    if (this.isServiceEnabled('minio')) {
+      if (!first) console.log();
+      await this.startMinIO();
+      first = false;
+    }
+    if (this.isServiceEnabled('elasticsearch')) {
+      if (!first) console.log();
+      await this.startElasticsearch();
+      first = false;
+    }
+
+    // Register with global registry
+    await this.registerWithGlobalRegistry();
+  }
+
+  /**
+   * Stop all enabled services
+   */
+  public async stopAll(): Promise<void> {
+    let first = true;
+    if (this.isServiceEnabled('mongodb')) {
+      if (!first) console.log();
+      await this.stopMongoDB();
+      first = false;
+    }
+    if (this.isServiceEnabled('minio')) {
+      if (!first) console.log();
+      await this.stopMinIO();
+      first = false;
+    }
+    if (this.isServiceEnabled('elasticsearch')) {
+      if (!first) console.log();
+      await this.stopElasticsearch();
+      first = false;
+    }
+  }
+
   /**
    * Start MongoDB service
    */
@@ -42,7 +193,7 @@ export class ServiceManager {
     const directories = this.config.getDataDirectories();
     
     // Ensure data directory exists
-    await plugins.smartfile.fs.ensureDir(directories.mongo);
+    await plugins.smartfs.directory(directories.mongo).recursive().create();
     
     const status = await this.docker.getStatus(containers.mongo);
     
@@ -141,7 +292,7 @@ export class ServiceManager {
     const directories = this.config.getDataDirectories();
     
     // Ensure data directory exists
-    await plugins.smartfile.fs.ensureDir(directories.minio);
+    await plugins.smartfs.directory(directories.minio).recursive().create();
     
     const status = await this.docker.getStatus(containers.minio);
     
@@ -260,6 +411,102 @@ export class ServiceManager {
     logger.log('info', `  Console: http://${config.S3_HOST}:${config.S3_CONSOLE_PORT} (login: ${config.S3_ACCESSKEY}/***)`);
   }
 
+  /**
+   * Start Elasticsearch service
+   */
+  public async startElasticsearch(): Promise<void> {
+    logger.log('note', '📦 Elasticsearch:');
+
+    const config = this.config.getConfig();
+    const containers = this.config.getContainerNames();
+    const directories = this.config.getDataDirectories();
+
+    // Ensure data directory exists
+    await plugins.smartfs.directory(directories.elasticsearch).recursive().create();
+
+    const status = await this.docker.getStatus(containers.elasticsearch);
+
+    switch (status) {
+      case 'running':
+        logger.log('ok', '  Already running ✓');
+        break;
+
+      case 'stopped':
+        // Check if port mapping matches config
+        const esPortMappings = await this.docker.getPortMappings(containers.elasticsearch);
+        if (esPortMappings && esPortMappings['9200'] !== config.ELASTICSEARCH_PORT) {
+          logger.log('note', '  Port configuration changed, recreating container...');
+          await this.docker.remove(containers.elasticsearch, true);
+          // Fall through to create new container
+          const success = await this.docker.run({
+            name: containers.elasticsearch,
+            image: 'elasticsearch:8.11.0',
+            ports: {
+              [`0.0.0.0:${config.ELASTICSEARCH_PORT}`]: '9200'
+            },
+            volumes: {
+              [directories.elasticsearch]: '/usr/share/elasticsearch/data'
+            },
+            environment: {
+              'discovery.type': 'single-node',
+              'xpack.security.enabled': 'true',
+              'ELASTIC_PASSWORD': config.ELASTICSEARCH_PASS,
+              'ES_JAVA_OPTS': '-Xms512m -Xmx512m'
+            },
+            restart: 'unless-stopped'
+          });
+
+          if (success) {
+            logger.log('ok', '  Recreated with new port ✓');
+          } else {
+            logger.log('error', '  Failed to recreate container');
+          }
+        } else {
+          // Ports match, just start the container
+          if (await this.docker.start(containers.elasticsearch)) {
+            logger.log('ok', '  Started ✓');
+          } else {
+            logger.log('error', '  Failed to start');
+          }
+        }
+        break;
+
+      case 'not_exists':
+        logger.log('note', '  Creating container...');
+
+        const success = await this.docker.run({
+          name: containers.elasticsearch,
+          image: 'elasticsearch:8.11.0',
+          ports: {
+            [`0.0.0.0:${config.ELASTICSEARCH_PORT}`]: '9200'
+          },
+          volumes: {
+            [directories.elasticsearch]: '/usr/share/elasticsearch/data'
+          },
+          environment: {
+            'discovery.type': 'single-node',
+            'xpack.security.enabled': 'true',
+            'ELASTIC_PASSWORD': config.ELASTICSEARCH_PASS,
+            'ES_JAVA_OPTS': '-Xms512m -Xmx512m'
+          },
+          restart: 'unless-stopped'
+        });
+
+        if (success) {
+          logger.log('ok', '  Created and started ✓');
+        } else {
+          logger.log('error', '  Failed to create container');
+        }
+        break;
+    }
+
+    logger.log('info', `  Container: ${containers.elasticsearch}`);
+    logger.log('info', `  Port: ${config.ELASTICSEARCH_PORT}`);
+    logger.log('info', `  Connection: ${config.ELASTICSEARCH_URL}`);
+    logger.log('info', `  Username: ${config.ELASTICSEARCH_USER}`);
+    logger.log('info', `  Password: ${config.ELASTICSEARCH_PASS}`);
+  }
+
   /**
    * Stop MongoDB service
    */
@@ -300,6 +547,26 @@ export class ServiceManager {
     }
   }
 
+  /**
+   * Stop Elasticsearch service
+   */
+  public async stopElasticsearch(): Promise<void> {
+    logger.log('note', '📦 Elasticsearch:');
+
+    const containers = this.config.getContainerNames();
+    const status = await this.docker.getStatus(containers.elasticsearch);
+
+    if (status === 'running') {
+      if (await this.docker.stop(containers.elasticsearch)) {
+        logger.log('ok', '  Stopped ✓');
+      } else {
+        logger.log('error', '  Failed to stop');
+      }
+    } else {
+      logger.log('note', '  Not running');
+    }
+  }
+
   /**
    * Show service status
    */
@@ -385,6 +652,34 @@ export class ServiceManager {
         }
         break;
     }
+
+    // Elasticsearch status
+    const esStatus = await this.docker.getStatus(containers.elasticsearch);
+    switch (esStatus) {
+      case 'running':
+        logger.log('ok', '📦 Elasticsearch: 🟢 Running');
+        logger.log('info', `   ├─ Container: ${containers.elasticsearch}`);
+        logger.log('info', `   ├─ Port: ${config.ELASTICSEARCH_PORT}`);
+        logger.log('info', `   ├─ Connection: ${config.ELASTICSEARCH_URL}`);
+        logger.log('info', `   └─ Credentials: ${config.ELASTICSEARCH_USER}/${config.ELASTICSEARCH_PASS}`);
+        break;
+      case 'stopped':
+        logger.log('note', '📦 Elasticsearch: 🟡 Stopped');
+        logger.log('info', `   ├─ Container: ${containers.elasticsearch}`);
+        logger.log('info', `   └─ Port: ${config.ELASTICSEARCH_PORT}`);
+        break;
+      case 'not_exists':
+        logger.log('info', '📦 Elasticsearch: ⚪ Not installed');
+        // Check port availability
+        const esPort = parseInt(config.ELASTICSEARCH_PORT);
+        const esAvailable = await helpers.isPortAvailable(esPort);
+        if (!esAvailable) {
+          logger.log('error', `   └─ ⚠️  Port ${esPort} is in use by another process`);
+        } else {
+          logger.log('info', `   └─ Port ${esPort} is available`);
+        }
+        break;
+    }
   }
 
   /**
@@ -420,6 +715,15 @@ export class ServiceManager {
     logger.log('info', `  Data: ${this.config.getDataDirectories().minio}`);
     logger.log('info', `  Endpoint: ${config.S3_ENDPOINT}`);
     logger.log('info', `  Console URL: http://${config.S3_HOST}:${config.S3_CONSOLE_PORT}`);
+
+    console.log();
+    logger.log('note', 'Elasticsearch:');
+    logger.log('info', `  Host: ${config.ELASTICSEARCH_HOST}:${config.ELASTICSEARCH_PORT}`);
+    logger.log('info', `  User: ${config.ELASTICSEARCH_USER}`);
+    logger.log('info', '  Password: ***');
+    logger.log('info', `  Container: ${this.config.getContainerNames().elasticsearch}`);
+    logger.log('info', `  Data: ${this.config.getDataDirectories().elasticsearch}`);
+    logger.log('info', `  Connection: ${config.ELASTICSEARCH_URL}`);
   }
   
   /**
@@ -478,15 +782,28 @@ export class ServiceManager {
         }
         break;
 
+      case 'elasticsearch':
+      case 'es':
+        if (await this.docker.isRunning(containers.elasticsearch)) {
+          helpers.printHeader(`Elasticsearch Logs (last ${lines} lines)`);
+          const logs = await this.docker.logs(containers.elasticsearch, lines);
+          console.log(logs);
+        } else {
+          logger.log('note', 'Elasticsearch container is not running');
+        }
+        break;
+
       case 'all':
       case '':
         await this.showLogs('mongo', lines);
         console.log();
         await this.showLogs('minio', lines);
+        console.log();
+        await this.showLogs('elasticsearch', lines);
         break;
 
       default:
-        logger.log('note', 'Usage: gitzone services logs [mongo|s3|all] [lines]');
+        logger.log('note', 'Usage: gitzone services logs [mongo|s3|elasticsearch|all] [lines]');
         break;
     }
   }
@@ -512,9 +829,25 @@ export class ServiceManager {
       }
     }
 
+    if (await this.docker.exists(containers.elasticsearch)) {
+      if (await this.docker.remove(containers.elasticsearch, true)) {
+        logger.log('ok', '  Elasticsearch container removed ✓');
+        removed = true;
+      }
+    }
+
     if (!removed) {
       logger.log('note', '  No containers to remove');
     }
+
+    // Check if all containers are gone, then unregister from global registry
+    const mongoExists = await this.docker.exists(containers.mongo);
+    const minioExists = await this.docker.exists(containers.minio);
+    const esExists = await this.docker.exists(containers.elasticsearch);
+
+    if (!mongoExists && !minioExists && !esExists) {
+      await this.globalRegistry.unregisterProject(process.cwd());
+    }
   }
   
   /**
@@ -524,23 +857,59 @@ export class ServiceManager {
     const directories = this.config.getDataDirectories();
     let cleaned = false;
 
-    if (await plugins.smartfile.fs.fileExists(directories.mongo)) {
-      await plugins.smartfile.fs.remove(directories.mongo);
+    if (await plugins.smartfs.directory(directories.mongo).exists()) {
+      await plugins.smartfs.directory(directories.mongo).recursive().delete();
       logger.log('ok', '  MongoDB data removed ✓');
       cleaned = true;
     }
 
-    if (await plugins.smartfile.fs.fileExists(directories.minio)) {
-      await plugins.smartfile.fs.remove(directories.minio);
+    if (await plugins.smartfs.directory(directories.minio).exists()) {
+      await plugins.smartfs.directory(directories.minio).recursive().delete();
       logger.log('ok', '  S3/MinIO data removed ✓');
       cleaned = true;
     }
 
+    if (await plugins.smartfs.directory(directories.elasticsearch).exists()) {
+      await plugins.smartfs.directory(directories.elasticsearch).recursive().delete();
+      logger.log('ok', '  Elasticsearch data removed ✓');
+      cleaned = true;
+    }
+
     if (!cleaned) {
       logger.log('note', '  No data to clean');
     }
   }
   
+  /**
+   * Configure which services are enabled
+   */
+  public async configureServices(): Promise<void> {
+    logger.log('note', 'Select which services to enable for this project:');
+    console.log();
+
+    const currentServices = this.enabledServices || ['mongodb', 'minio', 'elasticsearch'];
+
+    const smartinteract = new plugins.smartinteract.SmartInteract();
+    const response = await smartinteract.askQuestion({
+      name: 'services',
+      type: 'checkbox',
+      message: 'Which services do you want to enable?',
+      choices: [
+        { name: 'MongoDB', value: 'mongodb' },
+        { name: 'MinIO (S3)', value: 'minio' },
+        { name: 'Elasticsearch', value: 'elasticsearch' }
+      ],
+      default: currentServices
+    });
+
+    this.enabledServices = response.value || ['mongodb', 'minio', 'elasticsearch'];
+
+    // Save to npmextra.json
+    await this.saveServiceConfiguration(this.enabledServices);
+
+    logger.log('ok', '✅ Service configuration updated');
+  }
+
   /**
    * Reconfigure services with new ports
    */
@@ -562,6 +931,11 @@ export class ServiceManager {
       logger.log('ok', '  S3/MinIO stopped ✓');
     }
 
+    if (await this.docker.exists(containers.elasticsearch)) {
+      await this.docker.stop(containers.elasticsearch);
+      logger.log('ok', '  Elasticsearch stopped ✓');
+    }
+
     // Reconfigure ports
     await this.config.reconfigurePorts();
 
@@ -576,8 +950,7 @@ export class ServiceManager {
 
     if (response.value) {
       console.log();
-      await this.startMongoDB();
-      await this.startMinIO();
+      await this.startAll();
     }
   }
 }

ts/mod_services/helpers.ts

@@ -42,11 +42,15 @@ export const getRandomAvailablePort = async (): Promise<number> => {
 /**
  * Get the project name from package.json or directory
  */
-export const getProjectName = (): string => {
+export const getProjectName = async (): Promise<string> => {
   try {
     const packageJsonPath = plugins.path.join(process.cwd(), 'package.json');
-    if (plugins.smartfile.fs.fileExistsSync(packageJsonPath)) {
-      const packageJson = plugins.smartfile.fs.toObjectSync(packageJsonPath);
+    if (await plugins.smartfs.file(packageJsonPath).exists()) {
+      const content = (await plugins.smartfs
+        .file(packageJsonPath)
+        .encoding('utf8')
+        .read()) as string;
+      const packageJson = JSON.parse(content);
       if (packageJson.name) {
         // Sanitize: @fin.cx/skr → fin-cx-skr
         return packageJson.name.replace(/@/g, '').replace(/[\/\.]/g, '-');

ts/mod_services/index.ts

@@ -1,13 +1,23 @@
 import * as plugins from './mod.plugins.js';
 import * as helpers from './helpers.js';
 import { ServiceManager } from './classes.servicemanager.js';
+import { GlobalRegistry } from './classes.globalregistry.js';
 import { logger } from '../gitzone.logging.js';
 
 export const run = async (argvArg: any) => {
+  const isGlobal = argvArg.g || argvArg.global;
+  const command = argvArg._[1] || 'help';
+
+  // Handle global commands first
+  if (isGlobal) {
+    await handleGlobalCommand(command);
+    return;
+  }
+
+  // Local project commands
   const serviceManager = new ServiceManager();
   await serviceManager.init();
 
-  const command = argvArg._[1] || 'help';
   const service = argvArg._[2] || 'all';
 
   switch (command) {
@@ -28,7 +38,11 @@ export const run = async (argvArg: any) => {
       break;
       
     case 'config':
+      if (service === 'services' || argvArg._[2] === 'services') {
+        await handleConfigureServices(serviceManager);
+      } else {
         await serviceManager.showConfig();
+      }
       break;
 
     case 'compass':
@@ -73,16 +87,19 @@ async function handleStart(serviceManager: ServiceManager, service: string) {
       await serviceManager.startMinIO();
       break;
 
+    case 'elasticsearch':
+    case 'es':
+      await serviceManager.startElasticsearch();
+      break;
+
     case 'all':
     case '':
-      await serviceManager.startMongoDB();
-      console.log();
-      await serviceManager.startMinIO();
+      await serviceManager.startAll();
       break;
 
     default:
       logger.log('error', `Unknown service: ${service}`);
-      logger.log('note', 'Use: mongo, s3, or all');
+      logger.log('note', 'Use: mongo, s3, elasticsearch, or all');
       break;
   }
 }
@@ -101,16 +118,19 @@ async function handleStop(serviceManager: ServiceManager, service: string) {
       await serviceManager.stopMinIO();
       break;
 
+    case 'elasticsearch':
+    case 'es':
+      await serviceManager.stopElasticsearch();
+      break;
+
     case 'all':
     case '':
-      await serviceManager.stopMongoDB();
-      console.log();
-      await serviceManager.stopMinIO();
+      await serviceManager.stopAll();
       break;
 
     default:
       logger.log('error', `Unknown service: ${service}`);
-      logger.log('note', 'Use: mongo, s3, or all');
+      logger.log('note', 'Use: mongo, s3, elasticsearch, or all');
       break;
   }
 }
@@ -133,14 +153,18 @@ async function handleRestart(serviceManager: ServiceManager, service: string) {
       await serviceManager.startMinIO();
       break;
 
+    case 'elasticsearch':
+    case 'es':
+      await serviceManager.stopElasticsearch();
+      await plugins.smartdelay.delayFor(2000);
+      await serviceManager.startElasticsearch();
+      break;
+
     case 'all':
     case '':
-      await serviceManager.stopMongoDB();
-      await serviceManager.stopMinIO();
+      await serviceManager.stopAll();
       await plugins.smartdelay.delayFor(2000);
-      await serviceManager.startMongoDB();
-      console.log();
-      await serviceManager.startMinIO();
+      await serviceManager.startAll();
       break;
 
     default:
@@ -185,6 +209,11 @@ async function handleClean(serviceManager: ServiceManager) {
   }
 }
 
+async function handleConfigureServices(serviceManager: ServiceManager) {
+  helpers.printHeader('Configure Services');
+  await serviceManager.configureServices();
+}
+
 function showHelp() {
   helpers.printHeader('GitZone Services Manager');
 
@@ -192,22 +221,30 @@ function showHelp() {
   console.log();
 
   logger.log('note', 'Commands:');
-  logger.log('info', '  start [service]   Start services (mongo|s3|all)');
-  logger.log('info', '  stop [service]    Stop services (mongo|s3|all)');
-  logger.log('info', '  restart [service] Restart services (mongo|s3|all)');
+  logger.log('info', '  start [service]   Start services (mongo|s3|elasticsearch|all)');
+  logger.log('info', '  stop [service]    Stop services (mongo|s3|elasticsearch|all)');
+  logger.log('info', '  restart [service] Restart services (mongo|s3|elasticsearch|all)');
   logger.log('info', '  status            Show service status');
   logger.log('info', '  config            Show current configuration');
+  logger.log('info', '  config services   Configure which services are enabled');
   logger.log('info', '  compass           Show MongoDB Compass connection string');
-  logger.log('info', '  logs [service]    Show logs (mongo|s3|all) [lines]');
+  logger.log('info', '  logs [service]    Show logs (mongo|s3|elasticsearch|all) [lines]');
   logger.log('info', '  reconfigure       Reassign ports and restart services');
   logger.log('info', '  remove            Remove all containers');
   logger.log('info', '  clean             Remove all containers and data ⚠️');
   logger.log('info', '  help              Show this help message');
   console.log();
 
+  logger.log('note', 'Available Services:');
+  logger.log('info', '  • MongoDB (mongo) - Document database');
+  logger.log('info', '  • MinIO (s3) - S3-compatible object storage');
+  logger.log('info', '  • Elasticsearch (elasticsearch) - Search and analytics engine');
+  console.log();
+
   logger.log('note', 'Features:');
   logger.log('info', '  • Auto-creates .nogit/env.json with smart defaults');
-  logger.log('info', '  • Random ports (20000-30000) to avoid conflicts');
+  logger.log('info', '  • Random ports (20000-30000) for MongoDB/MinIO to avoid conflicts');
+  logger.log('info', '  • Elasticsearch uses standard port 9200');
   logger.log('info', '  • Project-specific containers for multi-project support');
   logger.log('info', '  • Preserves custom configuration values');
   logger.log('info', '  • MongoDB Compass connection support');
@@ -216,9 +253,181 @@ function showHelp() {
   logger.log('note', 'Examples:');
   logger.log('info', '  gitzone services start               # Start all services');
   logger.log('info', '  gitzone services start mongo         # Start only MongoDB');
+  logger.log('info', '  gitzone services start elasticsearch # Start only Elasticsearch');
   logger.log('info', '  gitzone services stop                # Stop all services');
   logger.log('info', '  gitzone services status              # Check service status');
   logger.log('info', '  gitzone services config              # Show configuration');
   logger.log('info', '  gitzone services compass             # Get MongoDB Compass connection');
-  logger.log('info', '  gitzone services logs mongo 50  # Show last 50 lines of MongoDB logs');
+  logger.log('info', '  gitzone services logs elasticsearch  # Show Elasticsearch logs');
+  console.log();
+
+  logger.log('note', 'Global Commands (-g/--global):');
+  logger.log('info', '  list -g           List all registered projects');
+  logger.log('info', '  status -g         Show status across all projects');
+  logger.log('info', '  stop -g           Stop all containers across all projects');
+  logger.log('info', '  cleanup -g        Remove stale registry entries');
+  console.log();
+
+  logger.log('note', 'Global Examples:');
+  logger.log('info', '  gitzone services list -g    # List all registered projects');
+  logger.log('info', '  gitzone services status -g  # Show global container status');
+  logger.log('info', '  gitzone services stop -g    # Stop all (prompts for confirmation)');
+}
+
+// ==================== Global Command Handlers ====================
+
+async function handleGlobalCommand(command: string) {
+  const globalRegistry = GlobalRegistry.getInstance();
+
+  switch (command) {
+    case 'list':
+      await handleGlobalList(globalRegistry);
+      break;
+
+    case 'status':
+      await handleGlobalStatus(globalRegistry);
+      break;
+
+    case 'stop':
+      await handleGlobalStop(globalRegistry);
+      break;
+
+    case 'cleanup':
+      await handleGlobalCleanup(globalRegistry);
+      break;
+
+    case 'help':
+    default:
+      showHelp();
+      break;
+  }
+}
+
+async function handleGlobalList(globalRegistry: GlobalRegistry) {
+  helpers.printHeader('Registered Projects (Global)');
+
+  const projects = await globalRegistry.getAllProjects();
+  const projectPaths = Object.keys(projects);
+
+  if (projectPaths.length === 0) {
+    logger.log('note', 'No projects registered');
+    return;
+  }
+
+  for (const path of projectPaths) {
+    const project = projects[path];
+    const lastActive = new Date(project.lastActive).toLocaleString();
+
+    console.log();
+    logger.log('ok', `📁 ${project.projectName}`);
+    logger.log('info', `   Path: ${project.projectPath}`);
+    logger.log('info', `   Services: ${project.enabledServices.join(', ')}`);
+    logger.log('info', `   Last Active: ${lastActive}`);
+  }
+}
+
+async function handleGlobalStatus(globalRegistry: GlobalRegistry) {
+  helpers.printHeader('Global Service Status');
+
+  const statuses = await globalRegistry.getGlobalStatus();
+
+  if (statuses.length === 0) {
+    logger.log('note', 'No projects registered');
+    return;
+  }
+
+  let runningCount = 0;
+  let totalContainers = 0;
+
+  for (const project of statuses) {
+    console.log();
+    logger.log('ok', `📁 ${project.projectName}`);
+    logger.log('info', `   Path: ${project.projectPath}`);
+
+    if (project.containers.length === 0) {
+      logger.log('note', '   No containers configured');
+      continue;
+    }
+
+    for (const container of project.containers) {
+      totalContainers++;
+      const statusIcon = container.status === 'running' ? '🟢' : container.status === 'exited' ? '🟡' : '⚪';
+      if (container.status === 'running') runningCount++;
+      logger.log('info', `   ${statusIcon} ${container.name}: ${container.status}`);
+    }
+  }
+
+  console.log();
+  logger.log('note', `Summary: ${runningCount}/${totalContainers} containers running across ${statuses.length} project(s)`);
+}
+
+async function handleGlobalStop(globalRegistry: GlobalRegistry) {
+  helpers.printHeader('Stop All Containers (Global)');
+
+  const statuses = await globalRegistry.getGlobalStatus();
+
+  // Count running containers
+  let runningCount = 0;
+  for (const project of statuses) {
+    for (const container of project.containers) {
+      if (container.status === 'running') runningCount++;
+    }
+  }
+
+  if (runningCount === 0) {
+    logger.log('note', 'No running containers found');
+    return;
+  }
+
+  logger.log('note', `Found ${runningCount} running container(s) across ${statuses.length} project(s)`);
+  console.log();
+
+  // Show what will be stopped
+  for (const project of statuses) {
+    const runningContainers = project.containers.filter(c => c.status === 'running');
+    if (runningContainers.length > 0) {
+      logger.log('info', `${project.projectName}:`);
+      for (const container of runningContainers) {
+        logger.log('info', `  • ${container.name}`);
+      }
+    }
+  }
+
+  console.log();
+  const shouldContinue = await plugins.smartinteract.SmartInteract.getCliConfirmation(
+    'Stop all containers?',
+    false
+  );
+
+  if (!shouldContinue) {
+    logger.log('note', 'Cancelled');
+    return;
+  }
+
+  logger.log('note', 'Stopping all containers...');
+  const result = await globalRegistry.stopAll();
+
+  if (result.stopped.length > 0) {
+    logger.log('ok', `Stopped: ${result.stopped.join(', ')}`);
+  }
+  if (result.failed.length > 0) {
+    logger.log('error', `Failed to stop: ${result.failed.join(', ')}`);
+  }
+}
+
+async function handleGlobalCleanup(globalRegistry: GlobalRegistry) {
+  helpers.printHeader('Cleanup Registry (Global)');
+
+  logger.log('note', 'Checking for stale registry entries...');
+  const removed = await globalRegistry.cleanup();
+
+  if (removed.length === 0) {
+    logger.log('ok', 'No stale entries found');
+    return;
+  }
+
+  logger.log('ok', `Removed ${removed.length} stale entr${removed.length === 1 ? 'y' : 'ies'}:`);
+  for (const path of removed) {
+    logger.log('info', `  • ${path}`);
+  }
 }

ts/mod_standard/index.ts

@@ -6,23 +6,36 @@ import * as paths from '../paths.js';
 
 import { logger } from '../gitzone.logging.js';
 
-export let run = () => {
+export let run = async () => {
   const done = plugins.smartpromise.defer();
   logger.log('warn', 'no action specified');
+
+  const dirEntries = await plugins.smartfs.directory(paths.templatesDir).list();
+  const templates: string[] = [];
+  for (const entry of dirEntries) {
+    try {
+      const stats = await plugins.smartfs
+        .file(plugins.path.join(paths.templatesDir, entry.path))
+        .stat();
+      if (stats.isDirectory) {
+        templates.push(entry.name);
+      }
+    } catch {
+      // Skip entries that can't be accessed
+    }
+  }
+
+  let projects = `\n`;
+  for (const template of templates) {
+    projects += `       - ${template}\n`;
+  }
+
   logger.log(
     'info',
     `
     You can do one of the following things:
     * create a new project with 'gitzone template [template]'
-      the following templates exist: ${(() => {
-        let projects = `\n`;
-        for (const template of plugins.smartfile.fs.listFoldersSync(
-          paths.templatesDir,
-        )) {
-          projects += `       - ${template}\n`;
-        }
-        return projects;
-      })()}
+      the following templates exist: ${projects}
     * format a project with 'gitzone format'
   `,
   );

ts/mod_template/index.ts

@@ -11,7 +11,7 @@ export const getTemplatePath = (templateNameArg: string) => {
  * receives a template name and returns wether there is a corresponding template
  */
 export const isTemplate = async (templateNameArg: string) => {
-  return plugins.smartfile.fs.isDirectory(getTemplatePath(templateNameArg));
+  return plugins.smartfs.directory(getTemplatePath(templateNameArg)).exists();
 };
 
 export const getTemplate = async (templateNameArg: string) => {

ts/plugins.ts

@@ -10,9 +10,13 @@ import * as smartupdate from '@push.rocks/smartupdate';
 import * as smartshell from '@push.rocks/smartshell';
 import * as smartnetwork from '@push.rocks/smartnetwork';
 import * as smartfile from '@push.rocks/smartfile';
+import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
 import * as smartinteract from '@push.rocks/smartinteract';
 import * as smartdelay from '@push.rocks/smartdelay';
 
+// Create smartfs instance for filesystem operations
+export const smartfs = new SmartFs(new SmartFsProviderNode());
+
 export {
   smartlog,
   smartlogDestinationLocal,