@cxtms/cx-schema 1.1.1 → 1.3.0

package/dist/cli.js

@@ -43,9 +43,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const chalk_1 = __importDefault(require("chalk"));
-const yaml = __importStar(require("js-yaml"));
+const yaml_1 = __importStar(require("yaml"));
 const validator_1 = require("./validator");
 const workflowValidator_1 = require("./workflowValidator");
+const extractUtils_1 = require("./extractUtils");
 // ============================================================================
 // Constants
 // ============================================================================
@@ -72,8 +73,9 @@ ${chalk_1.default.bold.yellow('COMMANDS:')}
   ${chalk_1.default.green('validate')}        Validate YAML file(s) ${chalk_1.default.gray('(default command)')}
   ${chalk_1.default.green('report')}          Generate validation report for multiple files
   ${chalk_1.default.green('init')}            Initialize a new CX project with app.yaml, README.md, AGENTS.md
-  ${chalk_1.default.green('create')}          Create a new module or workflow from template
+  ${chalk_1.default.green('create')}          Create a new module, workflow, or task-schema from template
   ${chalk_1.default.green('extract')}         Extract a component (and its routes) to another module
+  ${chalk_1.default.green('sync-schemas')}    Regenerate all.json from task schema directory
   ${chalk_1.default.green('schema')}          Show JSON schema for a component or task
   ${chalk_1.default.green('example')}         Show example YAML for a component or task
   ${chalk_1.default.green('list')}            List available schemas (modules, workflows, tasks)
@@ -92,7 +94,9 @@ ${chalk_1.default.bold.yellow('OPTIONS:')}
   ${chalk_1.default.green('--template <name>')}       Template variant for create command (e.g., ${chalk_1.default.cyan('basic')})
   ${chalk_1.default.green('--feature <name>')}        Place file under features/<name>/ instead of root
   ${chalk_1.default.green('--options <json>')}        JSON field definitions for create (inline or file path)
+  ${chalk_1.default.green('--tasks <list>')}         Comma-separated task enums for create task-schema
   ${chalk_1.default.green('--to <file>')}            Target file for extract command
+  ${chalk_1.default.green('--copy')}                 Copy component instead of moving (source unchanged, target gets higher priority)
 
 ${chalk_1.default.bold.yellow('VALIDATION EXAMPLES:')}
   ${chalk_1.default.gray('# Validate a module YAML file')}
@@ -132,6 +136,12 @@ ${chalk_1.default.bold.yellow('PROJECT COMMANDS:')}
   ${chalk_1.default.gray('# Create module with custom fields')}
   ${chalk_1.default.cyan(`${PROGRAM_NAME} create module my-config --template configuration --options '[{"name":"host","type":"text"},{"name":"port","type":"number"}]'`)}
 
+  ${chalk_1.default.gray('# Create a task schema with pre-populated task enums')}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} create task-schema filetransfer --tasks "FileTransfer/Connect@1,FileTransfer/Disconnect@1"`)}
+
+  ${chalk_1.default.gray('# Sync all.json after manually adding/removing task schemas')}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} sync-schemas`)}
+
   ${chalk_1.default.gray('# Extract a component to a new module')}
   ${chalk_1.default.cyan(`${PROGRAM_NAME} extract modules/orders.yaml Orders/CreateItem --to modules/order-create.yaml`)}
 
@@ -194,9 +204,13 @@ ${chalk_1.default.bold.yellow('AVAILABLE SCHEMAS:')}
 
   ${chalk_1.default.bold('Workflow Tasks:')}
     foreach, switch, while, validation, graphql, httpRequest,
-    setVariable, map, log, error, csv, export, template,
-    order, contact, commodity, job, attachment,
-    email-send, document-render, charge, workflow-execute
+    setVariable, map, log, error, csv, export, template, import,
+    order, contact, contact-address, contact-payment-method,
+    commodity, job, attachment, charge, payment,
+    email-send, document-render, document-send, pdf-document,
+    accounting-transaction, number, workflow-execute,
+    filetransfer, caching, flow-transition, user, authentication,
+    edi, note, appmodule, action-event, inventory, movement
 
 ${chalk_1.default.bold.yellow('EXAMPLES:')}
   ${chalk_1.default.cyan(`${PROGRAM_NAME} schema form`)}
@@ -269,16 +283,25 @@ ${chalk_1.default.bold.yellow('EXTRACT COMMAND')}
 Extract a component (and its routes) from one module into another.
 
 ${chalk_1.default.bold.yellow('USAGE:')}
-  ${chalk_1.default.cyan(`${PROGRAM_NAME} extract <source-file> <component-name> --to <target-file>`)}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} extract <source-file> <component-name> --to <target-file> [--copy]`)}
+
+${chalk_1.default.bold.yellow('OPTIONS:')}
+  ${chalk_1.default.green('--copy')}   Copy instead of move. Source stays unchanged, target gets higher priority.
 
 ${chalk_1.default.bold.yellow('WHAT GETS MOVED:')}
   ${chalk_1.default.green('Component')}   - The component matching the exact name
   ${chalk_1.default.green('Routes')}      - Any routes whose component field matches the name
   ${chalk_1.default.gray('Permissions and entities are NOT moved')}
 
+${chalk_1.default.bold.yellow('PRIORITY (--copy mode):')}
+  When using --copy, the target module gets a priority higher than the source:
+  ${chalk_1.default.gray('Source priority 1  → Target priority 2')}
+  ${chalk_1.default.gray('Source no priority → Target priority 1')}
+
 ${chalk_1.default.bold.yellow('EXAMPLES:')}
   ${chalk_1.default.cyan(`${PROGRAM_NAME} extract modules/orders.yaml Orders/CreateItem --to modules/order-create.yaml`)}
   ${chalk_1.default.cyan(`${PROGRAM_NAME} extract modules/main.yaml Dashboard --to modules/dashboard.yaml`)}
+  ${chalk_1.default.cyan(`${PROGRAM_NAME} extract modules/orders.yaml Orders/CreateItem --to modules/order-create.yaml --copy`)}
 `;
 // ============================================================================
 // Templates
@@ -798,7 +821,7 @@ function applyCreateOptions(content, optionsArg) {
         }
     }
     // Parse YAML
-    const doc = yaml.load(content);
+    const doc = yaml_1.default.parse(content);
     if (!doc)
         throw new Error('Failed to parse template YAML for --options processing');
     let applied = false;
@@ -837,12 +860,10 @@ function applyCreateOptions(content, optionsArg) {
         return content;
     }
     // Dump back to YAML
-    const yamlContent = yaml.dump(doc, {
+    const yamlContent = yaml_1.default.stringify(doc, {
         indent: 2,
-        lineWidth: -1,
-        noRefs: true,
-        quotingType: '"',
-        forceQuotes: false
+        lineWidth: 0,
+        singleQuote: false,
     });
     return headerLines.join('\n') + yamlContent;
 }
@@ -910,8 +931,13 @@ function runInit() {
     console.log('');
 }
 function runCreate(type, name, template, feature, createOptions) {
+    // Handle task-schema creation separately
+    if (type === 'task-schema') {
+        runCreateTaskSchema(name, createOptions);
+        return;
+    }
     if (!type || !['module', 'workflow'].includes(type)) {
-        console.error(chalk_1.default.red('Error: Invalid or missing type. Use: module or workflow'));
+        console.error(chalk_1.default.red('Error: Invalid or missing type. Use: module, workflow, or task-schema'));
         console.error(chalk_1.default.gray(`Example: ${PROGRAM_NAME} create module my-module`));
         process.exit(2);
     }
@@ -920,13 +946,13 @@ function runCreate(type, name, template, feature, createOptions) {
         console.error(chalk_1.default.gray(`Example: ${PROGRAM_NAME} create ${type} my-${type}`));
         process.exit(2);
     }
-    // Sanitize name
-    const safeName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-');
+    // Sanitize name: replace invalid chars with hyphen, collapse runs, trim edges
+    const safeName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-{2,}/g, '-').replace(/^-|-$/g, '');
     // Determine output directory and file
     // workflows/ or features/<feature>/workflows/ (same for modules)
     const baseDir = type === 'module' ? 'modules' : 'workflows';
     const dir = feature
-        ? path.join('features', feature.toLowerCase().replace(/[^a-z0-9-]/g, '-'), baseDir)
+        ? path.join('features', feature.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-{2,}/g, '-').replace(/^-|-$/g, ''), baseDir)
         : baseDir;
     const fileName = `${safeName}.yaml`;
     const filePath = path.join(process.cwd(), dir, fileName);
@@ -960,13 +986,167 @@ function runCreate(type, name, template, feature, createOptions) {
     console.log('');
 }
 // ============================================================================
+// Create Task Schema Command
+// ============================================================================
+function runCreateTaskSchema(name, tasks) {
+    if (!name) {
+        console.error(chalk_1.default.red('Error: Missing name for task-schema'));
+        console.error(chalk_1.default.gray(`Example: ${PROGRAM_NAME} create task-schema filetransfer --tasks "FileTransfer/Connect@1,FileTransfer/Disconnect@1"`));
+        process.exit(2);
+    }
+    const safeName = name.toLowerCase().replace(/[^a-z0-9-]/g, '-').replace(/-{2,}/g, '-').replace(/^-|-$/g, '');
+    // Find schemas directory — prefer source schemas/ in dev, fall back to standard resolution
+    let schemasDir = path.join(process.cwd(), 'schemas');
+    if (!fs.existsSync(schemasDir)) {
+        const resolved = findSchemasPath();
+        if (!resolved) {
+            console.error(chalk_1.default.red('Error: Cannot find schemas directory'));
+            process.exit(2);
+        }
+        schemasDir = resolved;
+    }
+    const tasksDir = path.join(schemasDir, 'workflows', 'tasks');
+    if (!fs.existsSync(tasksDir)) {
+        fs.mkdirSync(tasksDir, { recursive: true });
+    }
+    const filePath = path.join(tasksDir, `${safeName}.json`);
+    if (fs.existsSync(filePath)) {
+        console.error(chalk_1.default.red(`Error: Schema file already exists: ${filePath}`));
+        process.exit(2);
+    }
+    // Parse --tasks flag (passed via --options)
+    const taskEnums = [];
+    if (tasks) {
+        for (const t of tasks.split(',')) {
+            const trimmed = t.trim();
+            if (trimmed)
+                taskEnums.push(trimmed);
+        }
+    }
+    // Derive a title from the name
+    const title = safeName
+        .split('-')
+        .map(w => w.charAt(0).toUpperCase() + w.slice(1))
+        .join(' ') + ' Tasks';
+    // Build the schema JSON
+    const schema = {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        title,
+        description: `${title} operations`,
+        type: 'object',
+        properties: {
+            task: {
+                type: 'string',
+                ...(taskEnums.length > 0 ? { enum: taskEnums } : {}),
+                description: 'Task type identifier'
+            },
+            name: {
+                type: 'string',
+                description: 'Step name identifier'
+            },
+            description: {
+                type: 'string',
+                description: 'Step description'
+            },
+            conditions: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        expression: { type: 'string' }
+                    },
+                    required: ['expression']
+                }
+            },
+            continueOnError: {
+                type: 'boolean'
+            },
+            inputs: {
+                type: 'object',
+                description: `${title} inputs`,
+                additionalProperties: true
+            },
+            outputs: {
+                type: 'array',
+                items: {
+                    type: 'object',
+                    properties: {
+                        name: { type: 'string' },
+                        mapping: { type: 'string' }
+                    },
+                    required: ['name', 'mapping']
+                }
+            }
+        },
+        required: ['task'],
+        additionalProperties: true
+    };
+    fs.writeFileSync(filePath, JSON.stringify(schema, null, 2) + '\n', 'utf-8');
+    // Sync all.json
+    syncAllJson(tasksDir);
+    // Invalidate cache so new schema is immediately discoverable
+    _workflowTaskNamesCache = null;
+    console.log(chalk_1.default.green(`\n✓ Created task schema: ${path.relative(process.cwd(), filePath)}`));
+    console.log(chalk_1.default.gray(`\n  Next steps:`));
+    console.log(chalk_1.default.gray(`    1. Edit ${chalk_1.default.white(filePath)} to add typed input properties`));
+    console.log(chalk_1.default.gray(`    2. Verify: ${chalk_1.default.white(`${PROGRAM_NAME} schema ${safeName}`)}`));
+    console.log(chalk_1.default.gray(`    3. all.json has been auto-updated with the new reference`));
+    console.log('');
+}
+// ============================================================================
+// Sync all.json (auto-regenerate $ref entries from task schema directory)
+// ============================================================================
+function syncAllJson(tasksDir) {
+    const files = fs.readdirSync(tasksDir)
+        .filter(f => f.endsWith('.json') && f !== 'all.json' && f !== 'generic.json')
+        .sort();
+    const anyOfRefs = files.map(f => ({ $ref: f }));
+    // generic.json always last as fallback
+    if (fs.existsSync(path.join(tasksDir, 'generic.json'))) {
+        anyOfRefs.push({ $ref: 'generic.json' });
+    }
+    const allJson = {
+        $schema: 'http://json-schema.org/draft-07/schema#',
+        title: 'All Workflow Tasks',
+        description: 'Aggregator schema for all workflow task types. Uses anyOf to allow matching any known task type or falling back to generic task structure.',
+        type: 'object',
+        anyOf: anyOfRefs
+    };
+    fs.writeFileSync(path.join(tasksDir, 'all.json'), JSON.stringify(allJson, null, 2) + '\n', 'utf-8');
+}
+function runSyncSchemas() {
+    // Find schemas directory
+    let schemasDir = path.join(process.cwd(), 'schemas');
+    if (!fs.existsSync(schemasDir)) {
+        const resolved = findSchemasPath();
+        if (!resolved) {
+            console.error(chalk_1.default.red('Error: Cannot find schemas directory'));
+            process.exit(2);
+        }
+        schemasDir = resolved;
+    }
+    const tasksDir = path.join(schemasDir, 'workflows', 'tasks');
+    if (!fs.existsSync(tasksDir)) {
+        console.error(chalk_1.default.red('Error: Tasks directory not found'));
+        process.exit(2);
+    }
+    syncAllJson(tasksDir);
+    // Invalidate cache
+    _workflowTaskNamesCache = null;
+    const taskCount = fs.readdirSync(tasksDir)
+        .filter(f => f.endsWith('.json') && f !== 'all.json' && f !== 'generic.json')
+        .length;
+    console.log(chalk_1.default.green(`\n✓ Synced all.json with ${taskCount} task schemas (+ generic fallback)`));
+    console.log('');
+}
+// ============================================================================
 // Extract Command
 // ============================================================================
-function runExtract(sourceFile, componentName, targetFile) {
+function runExtract(sourceFile, componentName, targetFile, copy) {
     // Validate args
     if (!sourceFile || !componentName || !targetFile) {
         console.error(chalk_1.default.red('Error: Missing required arguments'));
-        console.error(chalk_1.default.gray(`Usage: ${PROGRAM_NAME} extract <source-file> <component-name> --to <target-file>`));
+        console.error(chalk_1.default.gray(`Usage: ${PROGRAM_NAME} extract <source-file> <component-name> --to <target-file> [--copy]`));
         process.exit(2);
     }
     // Check source exists
@@ -974,17 +1154,26 @@ function runExtract(sourceFile, componentName, targetFile) {
         console.error(chalk_1.default.red(`Error: Source file not found: ${sourceFile}`));
         process.exit(2);
     }
-    // Read and parse source
+    // Read and parse source (Document API preserves comments)
     const sourceContent = fs.readFileSync(sourceFile, 'utf-8');
-    const sourceDoc = yaml.load(sourceContent);
-    if (!sourceDoc || !Array.isArray(sourceDoc.components)) {
+    const srcDoc = yaml_1.default.parseDocument(sourceContent);
+    const sourceJS = srcDoc.toJS();
+    if (!sourceJS || !Array.isArray(sourceJS.components)) {
         console.error(chalk_1.default.red(`Error: Source file is not a valid module (missing components array): ${sourceFile}`));
         process.exit(2);
     }
+    // Get the AST components sequence
+    const srcComponents = srcDoc.get('components', true);
+    if (!(0, yaml_1.isSeq)(srcComponents)) {
+        console.error(chalk_1.default.red(`Error: Source components is not a sequence: ${sourceFile}`));
+        process.exit(2);
+    }
     // Find component by exact name match
-    const compIndex = sourceDoc.components.findIndex((c) => c.name === componentName);
+    const compIndex = srcComponents.items.findIndex((item) => {
+        return (0, yaml_1.isMap)(item) && item.get('name') === componentName;
+    });
     if (compIndex === -1) {
-        const available = sourceDoc.components.map((c) => c.name).filter(Boolean);
+        const available = sourceJS.components.map((c) => c.name).filter(Boolean);
         console.error(chalk_1.default.red(`Error: Component not found: ${componentName}`));
         if (available.length > 0) {
             console.error(chalk_1.default.gray('Available components:'));
@@ -994,32 +1183,52 @@ function runExtract(sourceFile, componentName, targetFile) {
         }
         process.exit(2);
     }
-    const component = sourceDoc.components[compIndex];
-    // Find matching routes
-    const matchedRoutes = [];
-    const remainingRoutes = [];
-    if (Array.isArray(sourceDoc.routes)) {
-        for (const route of sourceDoc.routes) {
-            if (route.component === componentName) {
-                matchedRoutes.push(route);
-            }
-            else {
-                remainingRoutes.push(route);
-            }
+    // Get the component AST node (clone for copy, take for move)
+    const componentNode = copy
+        ? srcDoc.createNode(sourceJS.components[compIndex])
+        : srcComponents.items[compIndex];
+    // Capture comment: if this is the first item, the comment lives on the parent seq
+    let componentComment;
+    if (compIndex === 0 && srcComponents.commentBefore) {
+        componentComment = srcComponents.commentBefore;
+        if (!copy) {
+            // Transfer the comment away from the source seq (it belongs to the extracted component)
+            srcComponents.commentBefore = undefined;
         }
     }
-    // Load or create target
-    let targetDoc;
+    else {
+        componentComment = componentNode.commentBefore;
+    }
+    // Find matching routes (by index in AST)
+    const srcRoutes = srcDoc.get('routes', true);
+    const matchedRouteIndices = [];
+    if ((0, yaml_1.isSeq)(srcRoutes)) {
+        srcRoutes.items.forEach((item, idx) => {
+            if ((0, yaml_1.isMap)(item) && item.get('component') === componentName) {
+                matchedRouteIndices.push(idx);
+            }
+        });
+    }
+    // Collect route AST nodes (clone for copy, reference for move)
+    const routeNodes = matchedRouteIndices.map(idx => {
+        if (copy) {
+            return srcDoc.createNode(sourceJS.routes[idx]);
+        }
+        return srcRoutes.items[idx];
+    });
+    // Load or create target document
+    let tgtDoc;
     let targetCreated = false;
     if (fs.existsSync(targetFile)) {
         const targetContent = fs.readFileSync(targetFile, 'utf-8');
-        targetDoc = yaml.load(targetContent);
-        if (!targetDoc || !Array.isArray(targetDoc.components)) {
+        tgtDoc = yaml_1.default.parseDocument(targetContent);
+        const targetJS = tgtDoc.toJS();
+        if (!targetJS || !Array.isArray(targetJS.components)) {
             console.error(chalk_1.default.red(`Error: Target file is not a valid module (missing components array): ${targetFile}`));
             process.exit(2);
         }
         // Check for duplicate component name
-        const duplicate = targetDoc.components.find((c) => c.name === componentName);
+        const duplicate = targetJS.components.find((c) => c.name === componentName);
         if (duplicate) {
             console.error(chalk_1.default.red(`Error: Target already contains a component named "${componentName}"`));
             process.exit(2);
@@ -1032,41 +1241,92 @@ function runExtract(sourceFile, componentName, targetFile) {
             .split('-')
             .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
             .join('');
-        targetDoc = {
-            module: moduleName,
+        const sourceModule = typeof sourceJS.module === 'object' ? sourceJS.module : null;
+        const displayName = moduleName.replace(/([a-z])([A-Z])/g, '$1 $2');
+        const moduleObj = {
+            name: moduleName,
             appModuleId: generateUUID(),
-            application: sourceDoc.application || 'cx',
+            displayName: { 'en-US': displayName },
+            description: { 'en-US': `${displayName} module` },
+            application: sourceModule?.application || sourceJS.application || 'cx',
+        };
+        // In copy mode, set priority higher than source
+        if (copy) {
+            const sourcePriority = sourceModule?.priority;
+            moduleObj.priority = (0, extractUtils_1.computeExtractPriority)(sourcePriority);
+        }
+        // Parse from string so the document has proper AST context for comment preservation
+        const scaffoldStr = yaml_1.default.stringify({
+            module: moduleObj,
             entities: [],
             permissions: [],
             components: [],
             routes: []
-        };
+        }, { indent: 2, lineWidth: 0, singleQuote: false });
+        tgtDoc = yaml_1.default.parseDocument(scaffoldStr);
         targetCreated = true;
     }
-    // Move component to target
-    targetDoc.components.push(component);
-    sourceDoc.components.splice(compIndex, 1);
-    // Move routes to target
-    if (matchedRoutes.length > 0) {
-        if (!Array.isArray(targetDoc.routes)) {
-            targetDoc.routes = [];
+    // Add component to target (ensure block style so comments are preserved)
+    const tgtComponents = tgtDoc.get('components', true);
+    if ((0, yaml_1.isSeq)(tgtComponents)) {
+        tgtComponents.flow = false;
+        // Apply the captured comment: if it's the first item in target, set on seq; otherwise on node
+        if (componentComment) {
+            if (tgtComponents.items.length === 0) {
+                tgtComponents.commentBefore = componentComment;
+            }
+            else {
+                componentNode.commentBefore = componentComment;
+            }
+        }
+        tgtComponents.items.push(componentNode);
+    }
+    else {
+        tgtDoc.addIn(['components'], componentNode);
+    }
+    // In move mode, remove component from source
+    if (!copy) {
+        srcComponents.items.splice(compIndex, 1);
+    }
+    // Add routes to target
+    if (routeNodes.length > 0) {
+        let tgtRoutes = tgtDoc.get('routes', true);
+        if (!(0, yaml_1.isSeq)(tgtRoutes)) {
+            tgtDoc.set('routes', tgtDoc.createNode([]));
+            tgtRoutes = tgtDoc.get('routes', true);
+        }
+        tgtRoutes.flow = false;
+        for (const routeNode of routeNodes) {
+            tgtRoutes.items.push(routeNode);
+        }
+        // In move mode, remove routes from source (reverse order to preserve indices)
+        if (!copy && (0, yaml_1.isSeq)(srcRoutes)) {
+            for (let i = matchedRouteIndices.length - 1; i >= 0; i--) {
+                srcRoutes.items.splice(matchedRouteIndices[i], 1);
+            }
         }
-        targetDoc.routes.push(...matchedRoutes);
-        sourceDoc.routes = remainingRoutes;
     }
     // Ensure target directory exists
     const targetDir = path.dirname(targetFile);
     if (!fs.existsSync(targetDir)) {
         fs.mkdirSync(targetDir, { recursive: true });
     }
-    // Write both files
-    const dumpOptions = { indent: 2, lineWidth: -1, noRefs: true, quotingType: '"', forceQuotes: false };
-    fs.writeFileSync(sourceFile, yaml.dump(sourceDoc, dumpOptions), 'utf-8');
-    fs.writeFileSync(targetFile, yaml.dump(targetDoc, dumpOptions), 'utf-8');
+    // Write files (toString preserves comments)
+    const toStringOpts = { indent: 2, lineWidth: 0, singleQuote: false };
+    if (!copy) {
+        fs.writeFileSync(sourceFile, srcDoc.toString(toStringOpts), 'utf-8');
+    }
+    fs.writeFileSync(targetFile, tgtDoc.toString(toStringOpts), 'utf-8');
     // Print summary
-    console.log(chalk_1.default.green(`\n✓ Extracted component: ${chalk_1.default.bold(componentName)}`));
-    console.log(chalk_1.default.gray(`  Routes moved: ${matchedRoutes.length}`));
-    console.log(chalk_1.default.gray(`  Source: ${sourceFile} (updated)`));
+    const action = copy ? 'Copied' : 'Extracted';
+    console.log(chalk_1.default.green(`\n✓ ${action} component: ${chalk_1.default.bold(componentName)}`));
+    console.log(chalk_1.default.gray(`  Routes ${copy ? 'copied' : 'moved'}: ${matchedRouteIndices.length}`));
+    if (!copy) {
+        console.log(chalk_1.default.gray(`  Source: ${sourceFile} (updated)`));
+    }
+    else {
+        console.log(chalk_1.default.gray(`  Source: ${sourceFile} (unchanged)`));
+    }
     console.log(chalk_1.default.gray(`  Target: ${targetFile} (${targetCreated ? 'created' : 'updated'})`));
     console.log('');
 }
@@ -1090,7 +1350,7 @@ function parseArgs(args) {
         reportFormat: 'json'
     };
     // Check for commands
-    const commands = ['validate', 'schema', 'example', 'list', 'help', 'report', 'init', 'create', 'extract'];
+    const commands = ['validate', 'schema', 'example', 'list', 'help', 'report', 'init', 'create', 'extract', 'sync-schemas'];
     if (args.length > 0 && commands.includes(args[0])) {
         command = args[0];
         args = args.slice(1);
@@ -1157,9 +1417,15 @@ function parseArgs(args) {
         else if (arg === '--options') {
             options.createOptions = args[++i];
         }
+        else if (arg === '--tasks') {
+            options.createTasks = args[++i];
+        }
         else if (arg === '--to') {
             options.extractTo = args[++i];
         }
+        else if (arg === '--copy') {
+            options.extractCopy = true;
+        }
         else if (!arg.startsWith('-')) {
             files.push(arg);
         }
@@ -1218,7 +1484,7 @@ function findSchemasPath() {
 function detectFileType(filePath) {
     try {
         const content = fs.readFileSync(filePath, 'utf-8');
-        const data = yaml.load(content);
+        const data = yaml_1.default.parse(content);
         if (data && typeof data === 'object') {
             if ('workflow' in data) {
                 return 'workflow';
@@ -1244,47 +1510,81 @@ function detectFileType(filePath) {
 // ============================================================================
 // Schema Display
 // ============================================================================
+// Cache for dynamically discovered workflow task schema names
+let _workflowTaskNamesCache = null;
+function getWorkflowTaskNames(schemasPath) {
+    if (_workflowTaskNamesCache)
+        return _workflowTaskNamesCache;
+    const tasksDir = path.join(schemasPath, 'workflows', 'tasks');
+    _workflowTaskNamesCache = new Set();
+    if (fs.existsSync(tasksDir)) {
+        for (const file of fs.readdirSync(tasksDir)) {
+            if (file.endsWith('.json') && file !== 'all.json') {
+                _workflowTaskNamesCache.add(file.replace('.json', '').toLowerCase().replace(/[^a-z0-9-]/g, ''));
+            }
+        }
+    }
+    // Also include common definitions
+    const commonDir = path.join(schemasPath, 'workflows', 'common');
+    if (fs.existsSync(commonDir)) {
+        for (const file of fs.readdirSync(commonDir)) {
+            if (file.endsWith('.json')) {
+                _workflowTaskNamesCache.add(file.replace('.json', '').toLowerCase().replace(/[^a-z0-9-]/g, ''));
+            }
+        }
+    }
+    return _workflowTaskNamesCache;
+}
 function findSchemaFile(schemasPath, name, preferWorkflow = false) {
-    // Normalize name
+    // Normalize name: lowercase, strip non-alphanumeric except hyphens
     const normalizedName = name.toLowerCase().replace(/[^a-z0-9-]/g, '');
-    // Workflow schema names - these should match workflow schemas first
+    // Dynamically detect workflow schema names from directory contents
     const workflowCoreNames = ['workflow', 'activity', 'input', 'output', 'variable', 'trigger', 'schedule'];
-    const workflowTaskNames = [
-        'foreach', 'switch', 'while', 'validation', 'map', 'setvariable', 'httprequest',
-        'log', 'error', 'csv', 'export', 'template', 'graphql', 'order', 'contact',
-        'commodity', 'job', 'attachment', 'email-send', 'document-render', 'document-send',
-        'charge', 'accounting-transaction', 'payment', 'workflow-execute', 'condition',
-        'expression', 'mapping'
-    ];
+    const workflowTaskNames = getWorkflowTaskNames(schemasPath);
     const isWorkflowSchema = workflowCoreNames.includes(normalizedName) ||
-        workflowTaskNames.includes(normalizedName);
-    // Search patterns in order of priority
+        workflowTaskNames.has(normalizedName);
+    // Build search paths using normalized name for consistency
     const searchPaths = preferWorkflow || isWorkflowSchema
         ? [
             // Workflow schemas first for workflow-related names
-            path.join(schemasPath, 'workflows', `${name}.json`),
-            path.join(schemasPath, 'workflows', 'tasks', `${name}.json`),
-            path.join(schemasPath, 'workflows', 'common', `${name}.json`),
+            path.join(schemasPath, 'workflows', `${normalizedName}.json`),
+            path.join(schemasPath, 'workflows', 'tasks', `${normalizedName}.json`),
+            path.join(schemasPath, 'workflows', 'common', `${normalizedName}.json`),
             // Then module schemas
-            path.join(schemasPath, 'components', `${name}.json`),
-            path.join(schemasPath, 'fields', `${name}.json`),
-            path.join(schemasPath, 'actions', `${name}.json`)
+            path.join(schemasPath, 'components', `${normalizedName}.json`),
+            path.join(schemasPath, 'fields', `${normalizedName}.json`),
+            path.join(schemasPath, 'actions', `${normalizedName}.json`)
         ]
         : [
             // Module schemas first
-            path.join(schemasPath, 'components', `${name}.json`),
-            path.join(schemasPath, 'fields', `${name}.json`),
-            path.join(schemasPath, 'actions', `${name}.json`),
+            path.join(schemasPath, 'components', `${normalizedName}.json`),
+            path.join(schemasPath, 'fields', `${normalizedName}.json`),
+            path.join(schemasPath, 'actions', `${normalizedName}.json`),
             // Then workflow schemas
-            path.join(schemasPath, 'workflows', `${name}.json`),
-            path.join(schemasPath, 'workflows', 'tasks', `${name}.json`),
-            path.join(schemasPath, 'workflows', 'common', `${name}.json`)
+            path.join(schemasPath, 'workflows', `${normalizedName}.json`),
+            path.join(schemasPath, 'workflows', 'tasks', `${normalizedName}.json`),
+            path.join(schemasPath, 'workflows', 'common', `${normalizedName}.json`)
         ];
     for (const schemaPath of searchPaths) {
         if (fs.existsSync(schemaPath)) {
             return schemaPath;
         }
     }
+    // Also try with the original name (preserving case) for backwards compatibility
+    if (normalizedName !== name) {
+        const caseSensitivePaths = [
+            path.join(schemasPath, 'workflows', 'tasks', `${name}.json`),
+            path.join(schemasPath, 'workflows', `${name}.json`),
+            path.join(schemasPath, 'components', `${name}.json`),
+            path.join(schemasPath, 'fields', `${name}.json`),
+            path.join(schemasPath, 'actions', `${name}.json`)
+        ];
+        for (const schemaPath of caseSensitivePaths) {
+            if (fs.existsSync(schemaPath)) {
+                return schemaPath;
+            }
+        }
+    }
     // Try fuzzy matching
     const allSchemas = getAllSchemas(schemasPath);
     for (const schema of allSchemas) {
@@ -1342,7 +1642,7 @@ function showExample(schemasPath, name) {
     console.log(chalk_1.default.gray('─'.repeat(70)));
     // Generate example from schema
     const example = generateExampleFromSchema(schema, name);
-    console.log(yaml.dump(example, { indent: 2, lineWidth: 100 }));
+    console.log(yaml_1.default.stringify(example, { indent: 2, lineWidth: 100 }));
     console.log(chalk_1.default.gray('─'.repeat(70)));
 }
 function generateExampleFromSchema(schema, name) {
@@ -1940,12 +2240,23 @@ async function main() {
     }
     // Handle create command
     if (command === 'create') {
-        runCreate(files[0], files[1], options.template, options.feature, options.createOptions);
+        // For task-schema, pass --tasks (from options.createTasks) as the tasks argument
+        if (files[0] === 'task-schema') {
+            runCreate(files[0], files[1], options.template, options.feature, options.createTasks);
+        }
+        else {
+            runCreate(files[0], files[1], options.template, options.feature, options.createOptions);
+        }
+        process.exit(0);
+    }
+    // Handle sync-schemas command
+    if (command === 'sync-schemas') {
+        runSyncSchemas();
         process.exit(0);
     }
     // Handle extract command
     if (command === 'extract') {
-        runExtract(files[0], files[1], options.extractTo);
+        runExtract(files[0], files[1], options.extractTo, options.extractCopy);
         process.exit(0);
     }
     // Validate files