@fromeroc9/testform 1.0.3 → 1.0.4

package/dist/commands/fmt.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fmtCmd = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const logger_1 = require("../logger");
+const fmtCmd = async (options) => {
+    const { dir = '.', check = false, list = true, write = true, recursive = false } = options;
+    const files = findFeatureFiles(dir, recursive);
+    if (files.length === 0) {
+        logger_1.logger.warn('No .feature files found to format.');
+        return;
+    }
+    let unformattedCount = 0;
+    for (const file of files) {
+        const content = (0, fs_1.readFileSync)(file, 'utf8');
+        const formatted = formatGherkin(content);
+        if (content !== formatted) {
+            unformattedCount++;
+            if (!check && write) {
+                (0, fs_1.writeFileSync)(file, formatted, 'utf8');
+            }
+            if (list) {
+                if (check) {
+                    logger_1.logger.warn(file);
+                }
+                else {
+                    logger_1.logger.success(file);
+                }
+            }
+        }
+    }
+    if (check) {
+        if (unformattedCount > 0) {
+            logger_1.logger.warn(`\n${unformattedCount} file(s) would be reformatted.`);
+            process.exit(3); // fmt -check returns 3 if unformatted
+        }
+        else {
+            logger_1.logger.success('All files are formatted correctly.');
+        }
+    }
+};
+exports.fmtCmd = fmtCmd;
+function findFeatureFiles(dir, recursive) {
+    try {
+        const stat = (0, fs_1.statSync)(dir);
+        if (stat.isFile() && dir.endsWith('.feature')) {
+            return [dir];
+        }
+        if (stat.isDirectory()) {
+            // Ignore node_modules and .git
+            if (dir.includes('node_modules') || dir.includes('.git'))
+                return [];
+            const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+            const result = [];
+            for (const entry of entries) {
+                const filePath = (0, path_1.join)(dir, entry.name);
+                if (entry.isDirectory()) {
+                    if (recursive) {
+                        result.push(...findFeatureFiles(filePath, recursive));
+                    }
+                }
+                else if (entry.name.endsWith('.feature')) {
+                    result.push(filePath);
+                }
+            }
+            return result;
+        }
+        return [];
+    }
+    catch (e) {
+        return [];
+    }
+}
+function formatGherkin(content) {
+    const lines = content.split('\n');
+    const output = [];
+    let expectedIndent = 0;
+    let inDocString = false;
+    let docStringIndent = 0;
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+        // Handle docstrings
+        if (line.trim().startsWith('"""') || line.trim().startsWith('```')) {
+            if (!inDocString) {
+                inDocString = true;
+                docStringIndent = 6;
+                output.push(' '.repeat(docStringIndent) + line.trim());
+            }
+            else {
+                inDocString = false;
+                output.push(' '.repeat(docStringIndent) + line.trim());
+            }
+            continue;
+        }
+        if (inDocString) {
+            output.push(line); // Keep docstring content as is
+            continue;
+        }
+        let trimmed = line.trim();
+        if (trimmed === '') {
+            // Only add empty line if the previous line wasn't empty
+            if (output.length > 0 && output[output.length - 1] !== '') {
+                output.push('');
+            }
+            continue;
+        }
+        // Determine indentation based on keyword
+        if (trimmed.startsWith('Feature:')) {
+            expectedIndent = 0;
+        }
+        else if (trimmed.startsWith('Rule:') || trimmed.startsWith('Background:') || trimmed.startsWith('Scenario:') || trimmed.startsWith('Scenario Outline:') || trimmed.startsWith('Example:')) {
+            expectedIndent = 2;
+            // Add blank line before these blocks if needed
+            if (output.length > 0 && output[output.length - 1] !== '' && !output[output.length - 1].trim().startsWith('@')) {
+                output.push('');
+            }
+        }
+        else if (trimmed.startsWith('Given ') || trimmed.startsWith('When ') || trimmed.startsWith('Then ') || trimmed.startsWith('And ') || trimmed.startsWith('But ') || trimmed.startsWith('* ')) {
+            expectedIndent = 4;
+        }
+        else if (trimmed.startsWith('Examples:')) {
+            expectedIndent = 4;
+            if (output.length > 0 && output[output.length - 1] !== '') {
+                output.push('');
+            }
+        }
+        else if (trimmed.startsWith('|')) {
+            expectedIndent = 6;
+        }
+        else if (trimmed.startsWith('@')) {
+            // Tags go with the next element, so we peek ahead to see what it is
+            let nextIndent = 0;
+            for (let j = i + 1; j < lines.length; j++) {
+                let nextTrimmed = lines[j].trim();
+                if (nextTrimmed === '' || nextTrimmed.startsWith('@'))
+                    continue;
+                if (nextTrimmed.startsWith('Feature:'))
+                    nextIndent = 0;
+                else if (nextTrimmed.startsWith('Rule:') || nextTrimmed.startsWith('Background:') || nextTrimmed.startsWith('Scenario:') || nextTrimmed.startsWith('Scenario Outline:'))
+                    nextIndent = 2;
+                else if (nextTrimmed.startsWith('Examples:'))
+                    nextIndent = 4;
+                break;
+            }
+            expectedIndent = nextIndent;
+            if (output.length > 0 && output[output.length - 1] !== '') {
+                output.push('');
+            }
+        }
+        else if (trimmed.startsWith('#')) {
+            // Comments preserve expected indent
+        }
+        else {
+            // Continuation of text (e.g. feature description)
+            if (expectedIndent === 0)
+                expectedIndent = 2; // Feature description
+        }
+        output.push(' '.repeat(expectedIndent) + trimmed);
+    }
+    // Ensure trailing newline
+    if (output.length > 0 && output[output.length - 1] !== '') {
+        output.push('');
+    }
+    return output.join('\n');
+}

package/dist/commands/force-unlock.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forceUnlockCmd = void 0;
+const chalk_1 = require("chalk");
+const state_1 = require("../core/state");
+const const_1 = require("../const");
+const forceUnlockCmd = async (options) => {
+    const { dir = '.', lockId, force = false, statePath } = options;
+    const stateObj = new state_1.State(dir, statePath);
+    await stateObj.init();
+    const executeUnlock = async () => {
+        const result = await stateObj.forceUnlock(lockId);
+        if (result.success) {
+            console.log((0, chalk_1.green)(`\n${const_1.TITLE_APP} state has been successfully unlocked!\n`));
+            if (!force) {
+                console.log(`The state has been unlocked, and ${const_1.TITLE_APP} commands should now be able to`);
+                console.log(`obtain a new lock on the remote state.`);
+            }
+        }
+        else {
+            if (result.currentLockId) {
+                console.error((0, chalk_1.red)(`Error: Lock ID does not match.\n\nExpected: ${lockId}\nActual:   ${result.currentLockId}\n`));
+            }
+            else if (result.error) {
+                console.error((0, chalk_1.red)(`${result.error}\n`));
+            }
+            process.exit(1);
+        }
+    };
+    if (force) {
+        await executeUnlock();
+        return;
+    }
+    console.log(`Do you really want to force-unlock?`);
+    console.log(`  ${const_1.TITLE_APP} will remove the lock on the remote state.`);
+    console.log(`  This will allow local ${const_1.TITLE_APP} commands to modify this state, even though it`);
+    console.log(`  may be still be in use. Only 'yes' will be accepted to confirm.`);
+    console.log('');
+    const { createInterface } = require('readline');
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolveReject) => {
+        rl.question('  Enter a value: ', async (answer) => {
+            rl.close();
+            if (answer.trim().toLowerCase() === 'yes') {
+                await executeUnlock();
+            }
+            else {
+                console.error((0, chalk_1.red)(`\nUnlock cancelled.\n`));
+                process.exitCode = 1;
+            }
+            resolveReject();
+        });
+    });
+};
+exports.forceUnlockCmd = forceUnlockCmd;

package/dist/commands/generate.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCmd = void 0;
+const path_1 = require("path");
+const fs_1 = require("fs");
+const config_1 = require("../core/config");
+const logger_1 = require("../logger");
+function findFeatures(dirPath) {
+    const result = [];
+    try {
+        const entries = (0, fs_1.readdirSync)(dirPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = (0, path_1.join)(dirPath, entry.name);
+            if (entry.isDirectory()) {
+                if (!entry.name.startsWith('.') && entry.name !== 'node_modules') {
+                    result.push(...findFeatures(fullPath));
+                }
+            }
+            else if (entry.name.endsWith('.feature')) {
+                result.push(fullPath);
+            }
+        }
+    }
+    catch (e) { }
+    return result;
+}
+function findNextIdentity(dirPath, pattern) {
+    if (!pattern.includes('*'))
+        return null;
+    const prefix = pattern.split('*')[0].replace(/^@/, '');
+    const suffix = pattern.split('*')[1] || '';
+    const regex = new RegExp(`@${prefix}(\\d+)${suffix}\\b`, 'g');
+    let max = 0;
+    const allFeatures = findFeatures(dirPath);
+    for (const file of allFeatures) {
+        const content = require('fs').readFileSync(file, 'utf-8');
+        let match;
+        while ((match = regex.exec(content)) !== null) {
+            const num = parseInt(match[1], 10);
+            if (num > max)
+                max = num;
+        }
+    }
+    return `@${prefix}${max + 1}${suffix}`;
+}
+const generateCmd = async (options) => {
+    const { dir, scope, title } = options;
+    const config = new config_1.Config(dir);
+    const convention = config.getConvention(scope);
+    const identityPattern = config.getIdentity(scope);
+    const scopeExt = scope.replace('test', ''); // e.g., 'run', 'case', 'plan'
+    // Default directory is the scope itself (e.g. 'testrun') if not specified in convention
+    const outDir = convention?.directory || scope;
+    const fileTpl = convention?.filename || `{YYYYMMDD}_{HHmmss}.${scopeExt}.feature`;
+    const now = new Date();
+    const YYYYMMDD = now.toISOString().split('T')[0].replace(/-/g, '');
+    const HHmmss = now.toTimeString().split(' ')[0].replace(/:/g, '');
+    const timestamp = now.getTime().toString();
+    let generatedTitle = title;
+    let slug = '';
+    if (generatedTitle) {
+        slug = generatedTitle.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+    }
+    let filename = fileTpl
+        .replace(/{YYYYMMDD}/g, YYYYMMDD)
+        .replace(/{HHmmss}/g, HHmmss)
+        .replace(/{timestamp}/g, timestamp)
+        .replace(/{slug}/g, slug);
+    // Clean up any stray underscores or hyphens left by an empty slug (e.g. "_.run.feature" -> ".run.feature")
+    // or "_2026.run.feature" -> "2026.run.feature"
+    filename = filename.replace(/^[_\-]+/, '').replace(/[_\-]+(\.)/g, '$1');
+    // Generate a short 6-character random hash for unique identity
+    const shortHash = Math.random().toString(16).substring(2, 8);
+    // Always resolve the extension to .feature and inject the hash before the scope extension
+    if (filename.endsWith('.feature')) {
+        // If they already included .feature in the template, we inject the hash before the extension
+        if (filename.endsWith(`.${scopeExt}.feature`)) {
+            filename = filename.replace(`.${scopeExt}.feature`, `_${shortHash}.${scopeExt}.feature`);
+        }
+        else {
+            filename = filename.replace(`.feature`, `_${shortHash}.feature`);
+        }
+    }
+    else {
+        // If it doesn't end with .feature, append hash then extension
+        if (filename.endsWith(`.${scopeExt}`)) {
+            filename = filename.replace(`.${scopeExt}`, `_${shortHash}.${scopeExt}.feature`);
+        }
+        else {
+            filename += `_${shortHash}.${scopeExt}.feature`;
+        }
+    }
+    // If title was not provided, use the generated filename EXACTLY without .feature
+    if (!generatedTitle) {
+        generatedTitle = filename.replace(/\.feature$/, '');
+    }
+    const fullPath = (0, path_1.join)(dir, outDir, filename);
+    if ((0, fs_1.existsSync)(fullPath)) {
+        logger_1.logger.error(`File already exists: ${fullPath}`);
+        process.exit(1);
+    }
+    if (options.rules && options.rules.length > 0) {
+        const allFeatures = findFeatures(dir);
+        for (const rule of options.rules) {
+            const ruleFile = rule.includes('::') ? rule.split('::')[0] : rule;
+            const exists = allFeatures.some(f => f.endsWith(ruleFile) || f.includes(ruleFile));
+            if (!exists) {
+                logger_1.logger.error([
+                    `Not Found`,
+                    `The feature file for Rule '${ruleFile}' does not exist in the workspace.`
+                ]);
+                process.exit(1);
+            }
+        }
+    }
+    const parentDir = (0, path_1.dirname)(fullPath);
+    if (!(0, fs_1.existsSync)(parentDir)) {
+        (0, fs_1.mkdirSync)(parentDir, { recursive: true });
+    }
+    const nextIdentityTag = (scope === 'testrun' || scope === 'testplan') && identityPattern
+        ? findNextIdentity(dir, identityPattern)
+        : null;
+    let content = `@${scope}`;
+    if (nextIdentityTag) {
+        content += ` ${nextIdentityTag}`;
+    }
+    content += `\nFeature: ${generatedTitle}\n`;
+    if (options.rules && options.rules.length > 0) {
+        content += `\n`;
+        for (const rule of options.rules) {
+            content += `  Rule: ${rule}\n`;
+        }
+    }
+    try {
+        (0, fs_1.writeFileSync)(fullPath, content, 'utf-8');
+        logger_1.logger.success(`Generated ${scope} file: ${fullPath}`, { bold: true });
+    }
+    catch (e) {
+        logger_1.logger.error(`Failed to generate file: ${e.message}`);
+        process.exit(1);
+    }
+};
+exports.generateCmd = generateCmd;

package/dist/commands/graph.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphCmd = void 0;
+const chalk_1 = require("chalk");
+const parser_1 = require("../core/parser");
+const graphCmd = async (options = {}) => {
+    const { dir = '.', scope = 'testcase', drawCycles = false } = options;
+    const parser = new parser_1.Parser(dir);
+    const scenarios = parser.content();
+    const testcases = scenarios.filter(s => !s.uri.endsWith('.run.feature') && !s.uri.endsWith('.plan.feature'));
+    const testrunsAll = scenarios.filter(s => s.uri.endsWith('.run.feature'));
+    const testplansAll = scenarios.filter(s => s.uri.endsWith('.plan.feature'));
+    // Group testplans by URI
+    const testplansMap = new Map();
+    for (const p of testplansAll) {
+        if (!testplansMap.has(p.uri)) {
+            testplansMap.set(p.uri, { name: p.feature?.name || 'Unnamed Plan', testruns: [] });
+        }
+        if (p.rule?.name)
+            testplansMap.get(p.uri).testruns.push(p.rule.name);
+    }
+    const testplans = Array.from(testplansMap.values());
+    // Group testruns by URI
+    const testrunsMap = new Map();
+    for (const r of testrunsAll) {
+        if (!testrunsMap.has(r.uri)) {
+            testrunsMap.set(r.uri, { name: r.feature?.name || 'Unnamed Run', testcases: [], identity: r.custom?.identity || r.feature?.name || '', uri: r.uri });
+        }
+        if (r.rule?.name)
+            testrunsMap.get(r.uri).testcases.push(r.rule.name);
+        else if (r.name)
+            testrunsMap.get(r.uri).testcases.push(`${r.feature?.name}::${r.name}`);
+    }
+    const testruns = Array.from(testrunsMap.values());
+    if (testplans.length === 0 && testruns.length === 0 && testcases.length === 0) {
+        console.log('No test configurations found.');
+        return;
+    }
+    console.log((0, chalk_1.bold)('Test Infrastructure Graph\n'));
+    const link = (str) => drawCycles ? (0, chalk_1.magenta)(str) : str;
+    function findTcs(tcId) {
+        let scenarioName = '*';
+        let ruleName = tcId;
+        if (tcId.includes('::')) {
+            const parts = tcId.split('::');
+            scenarioName = parts.pop() || '*';
+            ruleName = parts.join('::');
+        }
+        const matches = testcases.filter(r => {
+            const matchesFile = r.uri.endsWith(ruleName) || r.uri.includes(ruleName);
+            const matchesScenario = scenarioName === '*' || r.name === scenarioName || r.name.includes(scenarioName);
+            return matchesFile && matchesScenario;
+        });
+        // Detect duplicates
+        const uris = Array.from(new Set(matches.map(tc => tc.uri)));
+        if (uris.length > 1) {
+            if (scenarioName !== '*') {
+                const { logger } = require('../logger');
+                logger.error(`Ambiguous reference for Scenario '${scenarioName}' under Rule '${ruleName}'. It matches multiple files:\n` + uris.map(u => `  - ${u}`).join('\n') + `\nPlease specify the full file path in your Rule to disambiguate.`);
+            }
+            else {
+                const { logger } = require('../logger');
+                logger.warn(`Rule '${ruleName}' matches multiple feature files. Processing all of them:\n` + uris.map(u => `  - ${u}`).join('\n') + `\nIf this was unintentional, specify the full file path.`);
+            }
+        }
+        return matches;
+    }
+    if (scope === 'testplan' || scope === 'testcase') {
+        // Print Test Plans at root
+        for (const plan of testplans) {
+            const planName = plan.name;
+            console.log(`📦 ${(0, chalk_1.cyan)((0, chalk_1.bold)(planName))} ${(0, chalk_1.dim)(`(testplan)`)}`);
+            const trIds = plan.testruns;
+            for (const [i, trId] of trIds.entries()) {
+                const isLastRun = i === trIds.length - 1;
+                const runPrefix = isLastRun ? '└── ' : '├── ';
+                const run = testruns.find(r => r.identity === trId || r.name === trId || r.name.endsWith(trId) || trId.endsWith(r.name) || r.uri.endsWith(trId));
+                if (run) {
+                    const runName = run.name;
+                    console.log(`   ${link(runPrefix)}📂 ${(0, chalk_1.green)(runName)} ${(0, chalk_1.dim)(`(testrun)`)}`);
+                    if (scope === 'testcase') {
+                        const tcIds = run.testcases;
+                        for (let j = 0; j < tcIds.length; j++) {
+                            const tcId = tcIds.at(j);
+                            const isLastTc = j === tcIds.length - 1;
+                            const tcPrefix = isLastRun ? '    ' : '│   ';
+                            const tcConnector = isLastTc ? '└── ' : '├── ';
+                            const tcs = findTcs(tcId);
+                            if (tcs.length > 0) {
+                                for (let k = 0; k < tcs.length; k++) {
+                                    const tc = tcs.at(k);
+                                    const tcIsLast = isLastTc && k === tcs.length - 1;
+                                    const tcFinalConnector = tcIsLast ? '└── ' : '├── ';
+                                    console.log(`   ${tcPrefix}${link(tcFinalConnector)}📄 ${tc.name} ${(0, chalk_1.dim)(`(testcase)`)}`);
+                                }
+                            }
+                            else {
+                                console.log(`   ${tcPrefix}${link(tcConnector)}📄 ${(0, chalk_1.dim)(tcId + ' (Not found)')}`);
+                            }
+                        }
+                    }
+                }
+                else {
+                    console.log(`   ${link(runPrefix)}📂 ${(0, chalk_1.dim)(trId + ' (Not found)')}`);
+                }
+            }
+            console.log('');
+        }
+        if (scope === 'testcase') {
+            // Identify orphaned testruns
+            const referencedRuns = new Set(testplans.flatMap(p => p.testruns || []));
+            const orphanedRuns = testruns.filter(r => {
+                return !Array.from(referencedRuns).some(ref => r.identity === ref || r.name === ref || r.uri.endsWith(ref) || ref.endsWith(r.name));
+            });
+            if (orphanedRuns.length > 0) {
+                console.log((0, chalk_1.bold)('Orphaned Test Runs (Not linked to any testplan)\n'));
+                for (const run of orphanedRuns) {
+                    const runName = run.name;
+                    console.log(`📂 ${(0, chalk_1.green)(runName)} ${(0, chalk_1.dim)(`(testrun)`)}`);
+                    const tcIds = run.testcases;
+                    for (let j = 0; j < tcIds.length; j++) {
+                        const tcId = tcIds.at(j);
+                        const isLastTc = j === tcIds.length - 1;
+                        const tcConnector = isLastTc ? '└── ' : '├── ';
+                        console.log(`   ${link(tcConnector)}📄 ${tcId}`);
+                    }
+                    console.log('');
+                }
+            }
+        }
+    }
+    else if (scope === 'testrun') {
+        // Print Test Runs at root
+        for (const run of testruns) {
+            const runName = run.name;
+            console.log(`📂 ${(0, chalk_1.green)((0, chalk_1.bold)(runName))} ${(0, chalk_1.dim)(`(testrun)`)}`);
+            const tcIds = run.testcases;
+            for (let j = 0; j < tcIds.length; j++) {
+                const tcId = tcIds.at(j);
+                const isLastTc = j === tcIds.length - 1;
+                const tcConnector = isLastTc ? '└── ' : '├── ';
+                const tcs = findTcs(tcId);
+                if (tcs.length > 0) {
+                    for (let k = 0; k < tcs.length; k++) {
+                        const tc = tcs.at(k);
+                        const tcIsLast = isLastTc && k === tcs.length - 1;
+                        const tcFinalConnector = tcIsLast ? '└── ' : '├── ';
+                        console.log(`   ${link(tcFinalConnector)}📄 ${tc.name} ${(0, chalk_1.dim)(`(testcase)`)}`);
+                    }
+                }
+                else {
+                    console.log(`   ${link(tcConnector)}📄 ${(0, chalk_1.dim)(tcId + ' (Not found)')}`);
+                }
+            }
+            console.log('');
+        }
+    }
+};
+exports.graphCmd = graphCmd;