@burgan-tech/vnext-workflow-cli 1.0.0 → 1.0.2

package/.github/CODEOWNERS

@@ -0,0 +1,2 @@
+# For all repo
+*   @burgan-tech/code-owners

package/README.md

@@ -53,18 +53,62 @@ npm link
 
 ---
 
+## 📄 vnext.config.json (Required)
+
+Every vNext project must have a `vnext.config.json` file in the **project root**. This file defines the domain and component paths.
+
+### Example Configuration
+
+```json
+{
+  "version": "1.0.0",
+  "domain": "core",
+  "paths": {
+    "componentsRoot": "core",
+    "tasks": "Tasks",
+    "views": "Views",
+    "functions": "Functions",
+    "extensions": "Extensions",
+    "workflows": "Workflows",
+    "schemas": "Schemas"
+  }
+}
+```
+
+### Key Properties
+
+| Property | Description |
+|----------|-------------|
+| `domain` | Domain name used for API calls (replaces config's API_DOMAIN) |
+| `paths.componentsRoot` | Root folder where all components are located |
+| `paths.tasks` | Tasks folder name under componentsRoot |
+| `paths.workflows` | Workflows folder name under componentsRoot |
+| `paths.schemas` | Schemas folder name under componentsRoot |
+| `paths.views` | Views folder name under componentsRoot |
+| `paths.functions` | Functions folder name under componentsRoot |
+| `paths.extensions` | Extensions folder name under componentsRoot |
+
+### Component Discovery
+
+The CLI scans `componentsRoot` recursively and:
+- Includes all `.json` files in subfolders
+- Ignores `.meta` folders
+- Ignores `*.diagram.json` files
+- Ignores `package*.json` and `*config*.json` files
+
+---
+
 ## ⚡ Quick Start
 
 ### Initial Configuration
 
-After installation, configure the CLI:
+After installation, navigate to your vNext project and run:
 
 ```bash
-# Set project root path (REQUIRED)
-wf config set PROJECT_ROOT /path/to/your/vnext-project
+# Go to your vNext project directory
+cd /path/to/your/vnext-project
 
-# Database settings
-wf config set DB_PASSWORD postgres
+# Database settings (if using Docker)
 wf config set USE_DOCKER true
 wf config set DOCKER_POSTGRES_CONTAINER vnext-postgres
 
@@ -72,6 +116,8 @@ wf config set DOCKER_POSTGRES_CONTAINER vnext-postgres
 wf check
 ```
 
+**Note:** The CLI automatically uses the current working directory as the project root. Just `cd` into your project folder before running commands.
+
 ### Basic Usage
 
 ```bash
@@ -93,147 +139,256 @@ wf reset
 ## 📖 Commands
 
 ### `wf check`
-Checks system status (API, DB, folders).
 
-### `wf config <action> [key] [value]`
-Configuration management:
+**Purpose**: System health check
+
+Checks and displays:
+- vnext.config.json status and domain info
+- API connection status
+- Database connection status
+- Component folders found
+
 ```bash
-wf config get              # Show all settings
-wf config get PROJECT_ROOT # Show a specific setting
-wf config set DB_PASSWORD pass # Change a setting
+wf check
 ```
 
-### `wf csx [options]`
-Converts CSX files to Base64 and embeds them in JSON files.
+---
+
+### `wf sync`
+
+**Purpose**: Add missing components to database (skip existing)
+
+**What it does**:
+1. Scans all CSX files and updates JSON files with base64 encoded content
+2. For each component JSON file:
+   - Checks if it exists in DB (by key)
+   - If **exists** → Skip (already synced)
+   - If **not exists** → Publish to API
+3. Re-initializes the system
+
+**Use when**: Initial setup, adding new components without affecting existing ones
+
 ```bash
-wf csx              # Process changed files in Git
-wf csx --all        # Process all CSX files
-wf csx --file x.csx # Process a single file
+wf sync
 ```
 
+---
+
 ### `wf update [options]`
-Updates workflows (CSX is automatically updated!).
+
+**Purpose**: Update changed components (delete + re-add)
+
+**What it does**:
+1. Finds changed CSX files (Git) and updates JSON files
+2. For each component JSON file:
+   - Checks if it exists in DB (by key)
+   - If **exists** → Delete from DB, then publish to API
+   - If **not exists** → Publish to API
+3. Re-initializes the system
+
+**Use when**: You modified existing components and want to update them
+
 ```bash
 wf update                # Process changed files in Git (CSX + JSON)
 wf update --all          # Update all (asks for confirmation)
 wf update --file x.json  # Process a single file
 ```
 
-**Process steps:**
-1. 📝 Converts changed CSX files to base64 and writes to JSON files
-2. 🗑️ Deletes existing record from DB
-3. 📤 POSTs to API
-4. ✅ Activates the workflow
-5. 🔄 Restarts the system
-
-### `wf sync`
-Updates all CSX files and adds missing ones to the database.
-```bash
-wf sync  # Update all CSX files + add missing ones
-```
+---
 
 ### `wf reset`
-Resets workflows with an interactive menu (even if there are no changes).
+
+**Purpose**: Force reset components (always delete + re-add)
+
+**What it does**:
+1. Shows interactive menu to select component type
+2. For each component JSON file:
+   - Checks if it exists in DB (by key)
+   - If **exists** → Delete from DB, then publish to API
+   - If **not exists** → Publish to API
+3. Re-initializes the system
+
+**Use when**: You need to force reset components regardless of changes
+
 ```bash
-wf reset  # Select folder from menu
+wf reset  # Select folder from interactive menu
 ```
 
-**Menu:**
+**Menu Options**:
 ```
 ? Which folder should be reset?
-❯ 🔵 Workflows (sys-flows)
-  📋 Tasks (sys-tasks)
-  📊 Schemas (sys-schemas)
-  👁️  Views (sys-views)
-  ⚙️  Functions (sys-functions)
-  🔌 Extensions (sys-extensions)
+❯ tasks (Tasks/)
+  views (Views/)
+  functions (Functions/)
+  extensions (Extensions/)
+  workflows (Workflows/)
+  schemas (Schemas/)
   ──────────────
-  🔴 ALL (All folders)
+  TUMU (All folders)
 ```
 
 ---
 
-## 💡 Usage Scenarios
+### `wf csx [options]`
 
-### 1. Changing and Updating CSX File
-```bash
-# Edit CSX file
-vim AddToCartMapping.csx
+**Purpose**: Convert CSX files to Base64 and embed in JSON files
 
-# Update in one command (CSX + JSON automatic)
-wf update
-```
+**What it does**:
+1. Finds CSX files (changed or all)
+2. Converts to Base64
+3. Updates ALL JSON files that reference the CSX file
+4. Updates ALL matching `location` references in each JSON
 
-### 2. Updating Only CSX (Without Writing to DB)
-```bash
-# Convert CSX files to base64 and write to JSON files
-wf csx
-```
+**Use when**: You only want to update CSX content in JSONs without publishing to API
 
-### 3. Initial Setup / Full Sync
 ```bash
-# Update all CSX files + add missing ones
-wf sync
+wf csx              # Process changed files in Git
+wf csx --all        # Process all CSX files
+wf csx --file x.csx # Process a single file
 ```
 
-### 4. Resetting Workflows (Delete from DB and Re-add)
-```bash
-# With interactive menu (RECOMMENDED)
-wf reset
+---
 
-# Reset all
-wf update --all
+### `wf config <action> [key] [value]`
+
+**Purpose**: Configuration management
 
-# Single file
-wf update --file /path/to/file.json
+```bash
+wf config get              # Show all settings
+wf config get PROJECT_ROOT # Show a specific setting
+wf config set DB_PASSWORD pass # Change a setting
 ```
 
 ---
 
-## ⚙️ Configuration
+## ⚙️ Configuration Variables
 
 Config file location: `~/.config/vnext-workflow-cli/config.json`
 
-### Important Settings
-```bash
-# Project root path (REQUIRED)
-wf config set PROJECT_ROOT /path/to/project
+### All Available Settings
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `PROJECT_ROOT` | `process.cwd()` | **Auto.** Always uses current working directory (cannot be changed) |
+| `AUTO_DISCOVER` | `true` | Enable automatic component folder discovery |
+| `API_BASE_URL` | `http://localhost:4201` | vNext API base URL |
+| `API_VERSION` | `v1` | API version |
+| `DB_HOST` | `localhost` | PostgreSQL host |
+| `DB_PORT` | `5432` | PostgreSQL port |
+| `DB_NAME` | `vNext_WorkflowDb` | PostgreSQL database name |
+| `DB_USER` | `postgres` | PostgreSQL username |
+| `DB_PASSWORD` | `postgres` | PostgreSQL password |
+| `USE_DOCKER` | `false` | Use Docker for PostgreSQL connection |
+| `DOCKER_POSTGRES_CONTAINER` | `vnext-postgres` | Docker container name for PostgreSQL |
+| `DEBUG_MODE` | `false` | Enable debug logging |
+
+**Note:** `PROJECT_ROOT` is always the current working directory (`process.cwd()`). Simply `cd` into your project folder before running any command.
+
+### Quick Setup Examples
 
+```bash
 # API settings
 wf config set API_BASE_URL http://localhost:4201
 wf config set API_VERSION v1
 
-# Database settings
+# Database settings (direct connection)
 wf config set DB_HOST localhost
 wf config set DB_PORT 5432
 wf config set DB_NAME vNext_WorkflowDb
 wf config set DB_USER postgres
 wf config set DB_PASSWORD your_password
+wf config set USE_DOCKER false
 
-# Docker settings
+# Database settings (Docker)
 wf config set USE_DOCKER true
 wf config set DOCKER_POSTGRES_CONTAINER vnext-postgres
 
-# Auto discovery
+# Other settings
 wf config set AUTO_DISCOVER true
+wf config set DEBUG_MODE false
 ```
 
 ---
 
+## 💡 Usage Scenarios
+
+### 1. First Time Setup
+```bash
+# Go to your vNext project
+cd /path/to/project
+
+# Check system status
+wf check
+
+# Sync all components (add missing ones)
+wf sync
+```
+
+### 2. Daily Development - Changed Files
+```bash
+# Edit CSX or JSON files
+vim MyTask.csx
+
+# Update only changed components
+wf update
+```
+
+### 3. Update All Components
+```bash
+# Force update all components
+wf update --all
+```
+
+### 4. Reset Specific Component Type
+```bash
+# Interactive menu
+wf reset
+```
+
+### 5. Only Update CSX in JSONs (No API)
+```bash
+# Update CSX content in JSON files without publishing
+wf csx
+```
+
+---
+
+## 🔄 Command Comparison
+
+| Command | DB Check | Existing Action | New Action | Use Case |
+|---------|----------|-----------------|------------|----------|
+| `sync` | Yes | Skip | Publish | Add missing components |
+| `update` | Yes | Delete + Publish | Publish | Update changed components |
+| `reset` | Yes | Delete + Publish | Publish | Force reset components |
+| `csx` | No | N/A | N/A | Only update CSX in JSONs |
+
+---
+
 ## 🆘 Troubleshooting
 
-### "Files not found" (When using on another PC)
+### "vnext.config.json not found"
 ```bash
-# Check current config
+# Make sure you're in the correct directory
+pwd
+
+# Check if vnext.config.json exists
+ls -la vnext.config.json
+
+# Check current working directory
 wf config get PROJECT_ROOT
+```
 
-# Set new PC's path
-wf config set PROJECT_ROOT /Users/NewUser/path/to/project
+### "Files not found" (When using on another PC)
+```bash
+# Just cd into the project directory
+cd /Users/NewUser/path/to/project
 
 # Verify
 wf check
 ```
 
+**Note:** No need to set PROJECT_ROOT - just `cd` into your project folder.
+
 ### "Cannot connect to API"
 ```bash
 # Check API
@@ -350,12 +505,13 @@ vnext-workflow-cli/
 │   │   ├── sync.js
 │   │   └── update.js
 │   └── lib/                 # Library modules
-│       ├── api.js
-│       ├── config.js
-│       ├── csx.js
-│       ├── db.js
-│       ├── discover.js
-│       └── workflow.js
+│       ├── api.js           # API client (publish, reinitialize)
+│       ├── config.js        # CLI configuration
+│       ├── csx.js           # CSX processing
+│       ├── db.js            # Database operations
+│       ├── discover.js      # Component discovery
+│       ├── vnextConfig.js   # vnext.config.json reader
+│       └── workflow.js      # Workflow processing
 ├── .github/
 │   └── workflows/           # GitHub Actions workflows
 │       ├── build-and-publish.yml
@@ -379,4 +535,10 @@ wf check
 
 # Run development
 npm run dev
-```
+```
+
+---
+
+## 📝 License
+
+MIT License - see [LICENSE](LICENSE) for details.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@burgan-tech/vnext-workflow-cli",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "vNext Workflow Manager - CLI tool for managing workflows, tasks, schemas and more",
   "main": "dist/index.js",
   "bin": {
@@ -32,13 +32,13 @@
     "node": ">=14.0.0"
   },
   "dependencies": {
-    "commander": "^11.1.0",
-    "chalk": "^4.1.2",
     "axios": "^1.6.2",
-    "pg": "^8.11.3",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "conf": "^10.2.0",
     "glob": "^10.3.10",
     "inquirer": "^8.2.6",
     "ora": "^5.4.1",
-    "conf": "^10.2.0"
+    "pg": "^8.11.3"
   }
 }

package/src/commands/check.js

@@ -2,73 +2,113 @@ const chalk = require('chalk');
 const ora = require('ora');
 const config = require('../lib/config');
 const { discoverComponents, listDiscovered } = require('../lib/discover');
+const { getDomain, getComponentTypes, getComponentsRoot } = require('../lib/vnextConfig');
 const { testApiConnection } = require('../lib/api');
 const { testDbConnection } = require('../lib/db');
 
+// Logging helpers
+const LOG = {
+  separator: () => console.log(chalk.cyan('═'.repeat(60))),
+  subSeparator: () => console.log(chalk.cyan('─'.repeat(60))),
+  header: (text) => {
+    console.log();
+    LOG.separator();
+    console.log(chalk.cyan.bold(`  ${text}`));
+    LOG.separator();
+  },
+  success: (text) => console.log(chalk.green(`  ✓ ${text}`)),
+  error: (text) => console.log(chalk.red(`  ✗ ${text}`)),
+  warning: (text) => console.log(chalk.yellow(`  ⚠ ${text}`)),
+  info: (text) => console.log(chalk.dim(`  ○ ${text}`))
+};
+
 async function checkCommand() {
-  console.log(chalk.cyan.bold('\n🔄 Workflow Yönetim Sistemi - Sistem Kontrolü\n'));
+  LOG.header('SYSTEM CHECK');
   
   const projectRoot = config.get('PROJECT_ROOT');
   const autoDiscover = config.get('AUTO_DISCOVER');
   
-  // API kontrolü
-  let apiSpinner = ora('API kontrolü...').start();
+  // vnext.config.json check
+  console.log(chalk.white.bold('\n  Configuration:\n'));
+  
+  let domain, componentTypes, componentsRoot;
+  try {
+    domain = getDomain(projectRoot);
+    componentTypes = getComponentTypes(projectRoot);
+    componentsRoot = getComponentsRoot(projectRoot);
+    
+    LOG.success(`vnext.config.json found`);
+    console.log(chalk.dim(`    Domain: ${domain}`));
+    console.log(chalk.dim(`    Components Root: ${componentsRoot}`));
+  } catch (error) {
+    LOG.error(`vnext.config.json: ${error.message}`);
+    componentTypes = {};
+  }
+  
+  // API check
+  console.log(chalk.white.bold('\n  Connection Status:\n'));
+  
+  let apiSpinner = ora('  Checking API...').start();
   try {
     const apiUrl = config.get('API_BASE_URL');
     const isApiOk = await testApiConnection(apiUrl);
     if (isApiOk) {
-      apiSpinner.succeed(chalk.green('API: ✓ Erişilebilir'));
+      apiSpinner.succeed(chalk.green(`  API: Accessible (${apiUrl})`));
     } else {
-      apiSpinner.fail(chalk.red('API: ✗ Erişilemiyor'));
+      apiSpinner.fail(chalk.red(`  API: Not accessible (${apiUrl})`));
     }
   } catch (error) {
-    apiSpinner.fail(chalk.red(`API: ✗ Hata - ${error.message}`));
+    apiSpinner.fail(chalk.red(`  API: Error - ${error.message}`));
   }
   
-  // DB kontrolü
-  let dbSpinner = ora('Veritabanı kontrolü...').start();
+  // DB check
+  let dbSpinner = ora('  Checking database...').start();
   try {
+    const useDockerValue = config.get('USE_DOCKER');
     const isDbOk = await testDbConnection({
       host: config.get('DB_HOST'),
       port: config.get('DB_PORT'),
       database: config.get('DB_NAME'),
       user: config.get('DB_USER'),
       password: config.get('DB_PASSWORD'),
-      useDocker: config.get('USE_DOCKER'),
+      useDocker: useDockerValue === true || useDockerValue === 'true',
       dockerContainer: config.get('DOCKER_POSTGRES_CONTAINER')
     });
     if (isDbOk) {
-      dbSpinner.succeed(chalk.green('DB: ✓ Bağlı'));
+      dbSpinner.succeed(chalk.green(`  DB: Connected (${config.get('DB_HOST')}:${config.get('DB_PORT')})`));
     } else {
-      dbSpinner.fail(chalk.red('DB: ✗ Bağlanamıyor'));
+      dbSpinner.fail(chalk.red('  DB: Cannot connect'));
     }
   } catch (error) {
-    dbSpinner.fail(chalk.red(`DB: ✗ Hata - ${error.message}`));
+    dbSpinner.fail(chalk.red(`  DB: Error - ${error.message}`));
   }
   
-  // Klasör tarama
-  if (autoDiscover) {
-    console.log(chalk.cyan('\n📁 Bulunan Klasörler:\n'));
-    let discoverSpinner = ora('Klasörler taranıyor...').start();
+  // Folder scan
+  if (autoDiscover && Object.keys(componentTypes).length > 0) {
+    console.log(chalk.white.bold('\n  Component Folders:\n'));
+    
+    let discoverSpinner = ora('  Scanning folders...').start();
     try {
       const discovered = await discoverComponents(projectRoot);
       discoverSpinner.stop();
       
-      const list = listDiscovered(discovered);
+      const list = listDiscovered(discovered, componentTypes);
       for (const item of list) {
         if (item.found) {
-          console.log(chalk.green(`  ✓ ${item.name}`));
+          console.log(chalk.green(`  ✓ ${item.name.padEnd(12)} → ${item.folderName}/`));
         } else {
-          console.log(chalk.yellow(`  ○ ${item.name} ${chalk.dim('(bulunamadı)')}`));
+          console.log(chalk.yellow(`  ○ ${item.name.padEnd(12)} ${chalk.dim('(not found)')}`));
         }
       }
     } catch (error) {
-      discoverSpinner.fail(chalk.red(`Klasör tarama hatası: ${error.message}`));
+      discoverSpinner.fail(chalk.red(`  Folder scan error: ${error.message}`));
     }
+  } else if (!autoDiscover) {
+    console.log(chalk.yellow('\n  ⚠ AUTO_DISCOVER is disabled'));
   }
   
-  console.log(chalk.green.bold('\n✓ Kontrol tamamlandı\n'));
+  LOG.separator();
+  console.log(chalk.green.bold('\n  ✓ Check completed\n'));
 }
 
 module.exports = checkCommand;
-

package/src/commands/config.js

@@ -7,25 +7,24 @@ async function configCommand(action, key, value) {
       const val = config.get(key);
       console.log(chalk.cyan(`${key}:`), val);
     } else {
-      // Tüm config'i göster
-      console.log(chalk.cyan.bold('\n📝 Mevcut Konfigürasyon:\n'));
+      // Show all config
+      console.log(chalk.cyan.bold('\n📝 Current Configuration:\n'));
       const all = config.getAll();
       for (const [k, v] of Object.entries(all)) {
         console.log(chalk.cyan(`${k}:`), chalk.white(v));
       }
-      console.log(chalk.dim(`\nKonfig dosyası: ${config.path}\n`));
+      console.log(chalk.dim(`\nConfig file: ${config.path}\n`));
     }
   } else if (action === 'set') {
     if (!key || value === undefined) {
-      console.log(chalk.red('Kullanım: workflow config set <key> <value>'));
+      console.log(chalk.red('Usage: workflow config set <key> <value>'));
       return;
     }
     config.set(key, value);
     console.log(chalk.green(`✓ ${key} = ${value}`));
   } else {
-    console.log(chalk.red('Geçersiz action. Kullanın: get veya set'));
+    console.log(chalk.red('Invalid action. Use: get or set'));
   }
 }
 
 module.exports = configCommand;
-