@fromeroc9/testform 1.0.3 → 1.0.5

package/dist/commands/show.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showCmd = void 0;
+const chalk_1 = require("chalk");
+const state_1 = require("../core/state");
+const logger_1 = require("../logger");
+const const_1 = require("../const");
+const path_1 = __importDefault(require("path"));
+const showCmd = async (options = {}) => {
+    const { path, isJson = false, verbose = false, dir = '.', statePath, backupPath } = options;
+    const logger = new logger_1.Logger(verbose);
+    // If path is "state" or "plan" (legacy support)
+    let actualPath = path;
+    if (path === 'state')
+        actualPath = undefined;
+    if (path === 'plan') {
+        logger.info(`Use "${const_1.TITLE_CLI} plan" to generate and view an execution plan.`);
+        return;
+    }
+    const state = new state_1.State(dir, actualPath || statePath, backupPath);
+    await state.init();
+    const current = state.getState();
+    const resources = current.resources;
+    if (isJson) {
+        console.log(JSON.stringify(current, null, 2));
+        return;
+    }
+    console.log('');
+    console.log((0, chalk_1.bold)(`# ${const_1.TITLE_APP} State`));
+    console.log(`  Version:    ${current.version}`);
+    console.log(`  Serial:     ${current.serial}`);
+    console.log(`  Lineage:    ${current.lineage}`);
+    console.log(`  Last Sync:  ${current.lastSync || '(never)'}`);
+    console.log(`  Resources:  ${resources.length}`);
+    console.log('');
+    if (resources.length > 0) {
+        for (const res of resources) {
+            const remoteId = res.attributes.remoteId ?? '(unknown)';
+            const status = res.attributes.issueNumber ? (0, chalk_1.green)('synced') : (0, chalk_1.yellow)('pending');
+            let formattedIdentity = res.identity;
+            if (formattedIdentity.includes('::')) {
+                const parts = formattedIdentity.split('::');
+                const base = path_1.default.basename(parts[0], '.feature');
+                formattedIdentity = `${base}::${parts.slice(1).join('::')}`;
+            }
+            else {
+                formattedIdentity = path_1.default.basename(formattedIdentity, '.feature');
+            }
+            console.log(`  ${(0, chalk_1.cyan)(res.type)}.${(0, chalk_1.bold)(formattedIdentity)} [id=${remoteId}] ${status}`);
+            console.log(`    title:        ${res.attributes.title}`);
+            console.log(`    issueNumber:  ${res.attributes.issueNumber ?? '(none)'}`);
+            console.log(`    localHash:    ${(0, chalk_1.dim)(res.attributes.localHash.substring(0, 12))}...`);
+            console.log(`    lastApplied:  ${res.lastApplied}`);
+            console.log('');
+        }
+    }
+};
+exports.showCmd = showCmd;

package/dist/commands/state.js

@@ -0,0 +1,197 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stateCmd = void 0;
+const chalk_1 = require("chalk");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const state_1 = require("../core/state");
+const const_1 = require("../const");
+const utils_1 = require("../core/utils");
+const ERROR_NO_STATE = `No state file was found!
+
+State management commands require a state file. Run this command
+in a directory where ${const_1.TITLE_CLI} has been run or use the -state flag
+to point the command to a specific state location.`;
+const stateCmd = async (options) => {
+    const { dir = '.', action, args, statePath, backupPath, isJson, id, dryRun, force } = options;
+    const state = new state_1.State(dir, statePath, backupPath);
+    if (action !== 'push' && !(await state.hasState())) {
+        console.error((0, chalk_1.red)(ERROR_NO_STATE));
+        process.exit(1);
+    }
+    await state.init();
+    // Commands that don't need a lock
+    if (action === 'pull') {
+        const current = state.getState();
+        console.log(JSON.stringify(current, null, 2));
+        return;
+    }
+    if (action === 'push') {
+        if (args.length !== 1) {
+            console.error((0, chalk_1.red)(`Usage: ${const_1.TITLE_CLI} state push [path]`));
+            process.exit(1);
+        }
+        const localPath = (0, path_1.resolve)(process.cwd(), args[0]);
+        if (!(0, fs_1.existsSync)(localPath)) {
+            console.error((0, chalk_1.red)(`Error: File ${localPath} not found.`));
+            process.exit(1);
+        }
+        try {
+            const raw = (0, fs_1.readFileSync)(localPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            await state.acquireLock(true, '0s');
+            const current = state.getState();
+            // Handle lineage validation if not forced
+            if (!force && current.lineage && parsed.lineage && current.lineage !== parsed.lineage) {
+                console.error((0, chalk_1.red)(`Error: Cannot push state with different lineage. Use -force to override.`));
+                process.exit(1);
+            }
+            const mutCurrent = current;
+            mutCurrent.resources = parsed.resources || [];
+            mutCurrent.serial += 1;
+            await state.save();
+            await state.releaseLock();
+            console.log((0, chalk_1.green)(`Successfully pushed state from ${args[0]}`));
+            return;
+        }
+        catch (e) {
+            console.error((0, chalk_1.red)(`Error parsing or pushing state: ${e.message}`));
+            process.exit(1);
+        }
+    }
+    await state.acquireLock(true, '0s');
+    try {
+        const rawResources = state.getResources();
+        const filterResources = (resources) => {
+            let filtered = resources;
+            if (id) {
+                filtered = filtered.filter(r => r.attributes.issueNumber?.toString() === id || r.attributes.remoteId === id);
+            }
+            if (args.length > 0) {
+                filtered = filtered.filter(r => {
+                    const fullAddress = `${r.type}.${r.identity}`;
+                    return args.some(addr => fullAddress.startsWith(addr) || r.identity.startsWith(addr));
+                });
+            }
+            return filtered;
+        };
+        if (action === 'list') {
+            const resources = filterResources(rawResources);
+            if (resources.length === 0 && args.length > 0) {
+                console.error((0, chalk_1.red)(`No instance found for the given address!`));
+                process.exit(1);
+            }
+            else if (resources.length === 0) {
+                console.log('No resources found in state.');
+            }
+            else {
+                for (const res of resources) {
+                    const prefix = res.tainted ? '[tainted] ' : '';
+                    console.log(`${prefix}${res.type}.${res.identity}`);
+                }
+            }
+        }
+        else if (action === 'identities') {
+            if (!isJson) {
+                console.error((0, chalk_1.red)(`The \`${const_1.TITLE_CLI} state identities\` command requires the \`-json\` flag.`));
+                process.exit(1);
+            }
+            const resources = filterResources(rawResources);
+            const identities = resources.map(r => r.identity);
+            console.log(JSON.stringify(identities, null, 2));
+        }
+        else if (action === 'show') {
+            if (args.length !== 1) {
+                console.error((0, chalk_1.red)(`Exactly one argument expected.\nUsage: ${const_1.TITLE_CLI} [global options] state show [options] ADDRESS`));
+                process.exit(1);
+            }
+            const address = args[0];
+            const identity = address.includes('.') ? address.split('.').slice(1).join('.') : address;
+            const res = rawResources.find(r => r.identity === identity || `${r.type}.${r.identity}` === identity);
+            if (!res) {
+                console.error((0, chalk_1.red)(`No instance found for the given address!`));
+                process.exit(1);
+            }
+            console.log((0, chalk_1.bold)(`# ${res.type}.${res.identity}:`));
+            console.log(`resource "${res.type}" "${res.identity}" {`);
+            const keys = Object.keys(res.attributes);
+            let maxKeyLen = 0;
+            for (const k of keys) {
+                if (k.length > maxKeyLen)
+                    maxKeyLen = k.length;
+            }
+            for (const key of keys) {
+                const padding = ' '.repeat(maxKeyLen - key.length);
+                const attrVal = Object.prototype.hasOwnProperty.call(res.attributes, key) ? res.attributes[key] : undefined;
+                console.log(`    ${key}${padding} = ${(0, utils_1.formatHclValue)(attrVal, 1)}`);
+            }
+            console.log(`}`);
+            if (res.tainted) {
+                console.log((0, chalk_1.red)(`\nThis resource is marked as tainted.`));
+            }
+        }
+        else if (action === 'rm') {
+            if (args.length === 0) {
+                console.error((0, chalk_1.red)(`At least one address is required.\n\nUsage: ${const_1.TITLE_CLI} [global options] state rm [options] ADDRESS...`));
+                process.exit(1);
+            }
+            let removedCount = 0;
+            for (const arg of args) {
+                const identity = arg.includes('.') ? arg.split('.').slice(1).join('.') : arg;
+                if (rawResources.find(r => r.identity === identity || `${r.type}.${r.identity}` === identity)) {
+                    if (dryRun) {
+                        console.log(`Would remove ${arg}`);
+                    }
+                    else {
+                        state.removeResource(identity);
+                        console.log(`Removed ${arg}`);
+                    }
+                    removedCount++;
+                }
+                else {
+                    console.error((0, chalk_1.red)(`Error: Resource ${arg} not found in state.`));
+                }
+            }
+            if (removedCount > 0 && !dryRun) {
+                await state.save();
+                console.log((0, chalk_1.green)(`\nSuccessfully removed ${removedCount} resource instance(s).`));
+            }
+        }
+        else if (action === 'mv') {
+            if (args.length !== 2) {
+                console.error((0, chalk_1.red)(`Exactly two arguments expected.\n\nUsage: ${const_1.TITLE_CLI} [global options] state mv [options] SOURCE DESTINATION`));
+                process.exit(1);
+            }
+            const source = args[0];
+            const dest = args[1];
+            const sourceIdentity = source.includes('.') ? source.split('.').slice(1).join('.') : source;
+            const destIdentity = dest.includes('.') ? dest.split('.').slice(1).join('.') : dest;
+            const res = rawResources.find(r => r.identity === sourceIdentity || `${r.type}.${r.identity}` === sourceIdentity);
+            if (!res) {
+                console.error((0, chalk_1.red)(`Error: Source resource ${source} not found in state.`));
+                process.exit(1);
+            }
+            if (dryRun) {
+                console.log(`Would move ${source} to ${dest}`);
+            }
+            else {
+                state.removeResource(res.identity);
+                res.identity = destIdentity;
+                if (dest.includes('.')) {
+                    res.type = dest.split('.')[0];
+                }
+                state.upsertResource(res);
+                await state.save();
+                console.log((0, chalk_1.green)(`Move ${source} to ${dest} successfully executed!`));
+            }
+        }
+        else {
+            console.error((0, chalk_1.red)(`Usage: ${const_1.TITLE_CLI} state <identities|list|mv|pull|push|rm|show> [options] [args]`));
+            process.exit(1);
+        }
+    }
+    finally {
+        await state.releaseLock();
+    }
+};
+exports.stateCmd = stateCmd;

package/dist/commands/taint.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taintCmd = void 0;
+const chalk_1 = require("chalk");
+const state_1 = require("../core/state");
+const taintCmd = async (options) => {
+    const { dir = '.', action, identityRaw, statePath, backupPath, allowMissing = false, lock = true, lockTimeout = '0s' } = options;
+    const state = new state_1.State(dir, statePath, backupPath);
+    await state.init();
+    await state.acquireLock(lock, lockTimeout);
+    try {
+        const identity = identityRaw.replace(/^github_testcase\./, '');
+        const res = state.getResources('github_testcase').find(r => r.identity === identity);
+        if (!res) {
+            if (allowMissing) {
+                console.log((0, chalk_1.green)(`Resource not found in state, but allow-missing is set. Exiting successfully.`));
+                process.exit(0);
+            }
+            console.error((0, chalk_1.red)(`Error: Resource not found in state.`));
+            process.exit(1);
+        }
+        if (action === 'taint') {
+            if (res.tainted) {
+                console.log(`Resource instance ${identityRaw} is already tainted`);
+            }
+            else {
+                res.tainted = true;
+                state.upsertResource(res);
+                await state.save();
+                console.log((0, chalk_1.green)(`Resource instance ${identityRaw} has been marked as tainted.`));
+            }
+        }
+        else {
+            if (!res.tainted) {
+                console.log(`Resource instance ${identityRaw} is not tainted`);
+            }
+            else {
+                delete res.tainted;
+                state.upsertResource(res);
+                await state.save();
+                console.log((0, chalk_1.green)(`Resource instance ${identityRaw} has been successfully untainted.`));
+            }
+        }
+    }
+    finally {
+        await state.releaseLock();
+    }
+};
+exports.taintCmd = taintCmd;

package/dist/commands/validate.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCmd = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = require("../core/config");
+const parser_1 = require("../core/parser");
+const policy_1 = require("../core/policy");
+const logger_1 = require("../logger");
+const validateCmd = async (options) => {
+    const { targetPath = '.', verbose = false, scope, variables, isJson = false, testDirectory, noTests = false, query } = options;
+    const logger = new logger_1.Logger(verbose);
+    if (isJson) {
+        // Suppress logger output when JSON is active
+        // But we just won't call it for the important parts
+    }
+    else {
+        logger.info('Validating configuration...', { bold: true });
+    }
+    let configDir = targetPath;
+    let parseDir = testDirectory ? (0, path_1.join)(targetPath, testDirectory) : targetPath;
+    try {
+        if ((0, fs_1.statSync)(parseDir).isFile()) {
+            configDir = (0, path_1.dirname)(parseDir);
+        }
+    }
+    catch (e) {
+        // Ignore, handled by next steps
+    }
+    // Parse feature files
+    const parser = new parser_1.Parser(parseDir, variables);
+    const documents = parser.content();
+    if (documents.length === 0) {
+        if (isJson) {
+            console.log(JSON.stringify({
+                valid: false,
+                error_count: 1,
+                warning_count: 0,
+                diagnostics: [{
+                        severity: 'error',
+                        summary: 'Failed to read module directory',
+                        detail: `Module directory ${targetPath} does not exist or cannot be read.`
+                    }]
+            }, null, 2));
+        }
+        else {
+            logger.error(`Failed to read module directory\n\nModule directory ${parseDir} does not exist or cannot be read.`);
+        }
+        return;
+    }
+    // Load and validate config (exits on error via notify)
+    const config = new config_1.Config(configDir);
+    logger.debug(`Configuration loaded: v${config.getConfig().version}`);
+    logger.debug(`Found ${documents.length} scenarios across feature files`);
+    // Filter by scope (only process files matching the requested scope)
+    const SCOPE_CONFIG = {
+        testcase: { tag: '@testcase', ext: '.case.feature' },
+        testrun: { tag: '@testrun', ext: '.run.feature' },
+        testplan: { tag: '@testplan', ext: '.plan.feature' },
+    };
+    const matchesScope = (s, scopeName) => {
+        if (!Object.prototype.hasOwnProperty.call(SCOPE_CONFIG, scopeName))
+            return false;
+        const cfg = SCOPE_CONFIG[scopeName];
+        return s.feature?.tags?.includes(cfg.tag) || s.uri.endsWith(cfg.ext);
+    };
+    const rawScenarios = documents.filter(s => matchesScope(s, scope));
+    if (rawScenarios.length === 0) {
+        if (!isJson)
+            logger.warn(`No scenarios found for scope "${scope}".`);
+        return;
+    }
+    if (!isJson)
+        logger.debug(`Found ${rawScenarios.length} scenarios matching scope "${scope}"`);
+    // Filter with DSL
+    const data = {
+        identity: config.getIdentity(scope),
+        fields: config.getFields(scope),
+    };
+    let filtered = parser.filter(rawScenarios, data, scope);
+    if (query) {
+        const lowerQuery = query.toLowerCase();
+        filtered = filtered.filter(s => (s.name && s.name.toLowerCase().includes(lowerQuery)) ||
+            (s.custom?.identity && s.custom.identity.toLowerCase().includes(lowerQuery)) ||
+            (s.tags && s.tags.some(t => t.toLowerCase().includes(lowerQuery))) ||
+            (s.uri && s.uri.toLowerCase().includes(lowerQuery)));
+        if (!isJson) {
+            logger.info(`--- Query Results for "${query}" ---`, { bold: true });
+            if (filtered.length === 0) {
+                logger.info(`No scenarios matched the query.`);
+            }
+            else {
+                filtered.forEach(s => {
+                    logger.info(`- [${scope}] ${s.custom?.identity || s.name} (File: ${s.uri}:${s.location})`);
+                });
+            }
+            logger.blank();
+        }
+    }
+    // Run policy validation (will print violations via notify or JSON)
+    if (!noTests) {
+        const hasViolations = policy_1.policy.scanner(filtered, scope, isJson);
+        if (hasViolations) {
+            const err = new Error("Please fix them before continuing.");
+            err.name = "Policy violations found";
+            throw err;
+        }
+    }
+    else if (!isJson) {
+        logger.info(`Skipping policy validation (-no-tests).`);
+    }
+    // If we reach here, all validations passed
+    if (isJson) {
+        console.log(JSON.stringify({
+            valid: true,
+            error_count: 0,
+            warning_count: 0,
+            diagnostics: []
+        }, null, 2));
+    }
+    else {
+        logger.success('Success! The configuration is valid.', { bold: true });
+        logger.blank();
+        logger.info(`  Scenarios: ${filtered.length}`);
+        logger.info(`  Scope:     ${scope}`);
+    }
+};
+exports.validateCmd = validateCmd;

package/dist/commands/workspace.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.workspaceCmd = void 0;
+const chalk_1 = require("chalk");
+const logger_1 = require("../logger");
+const state_1 = require("../core/state");
+const const_1 = require("../const");
+const workspaceCmd = async (options) => {
+    const { dir, verbose, args } = options;
+    const logger = new logger_1.Logger(verbose);
+    const stateObj = new state_1.State(dir);
+    const subcommand = args[0];
+    const name = args[1];
+    if (!subcommand) {
+        logger.error(`Usage: ${const_1.TITLE_CLI} workspace [subcommand] [options] [args]`);
+        process.exit(1);
+    }
+    await stateObj.init();
+    const currentWorkspace = stateObj.getCurrentWorkspace();
+    switch (subcommand) {
+        case 'show':
+            console.log(currentWorkspace);
+            break;
+        case 'list':
+            const workspaces = await stateObj.listWorkspaces();
+            for (const ws of workspaces) {
+                if (ws === currentWorkspace) {
+                    console.log((0, chalk_1.green)(`* ${ws}`));
+                }
+                else {
+                    console.log(`  ${ws}`);
+                }
+            }
+            break;
+        case 'new':
+            if (!name) {
+                logger.error('Expected a workspace name');
+                process.exit(1);
+            }
+            const existingForNew = await stateObj.listWorkspaces();
+            if (existingForNew.includes(name)) {
+                logger.error(`Workspace "${name}" already exists`);
+                process.exit(1);
+            }
+            stateObj.setCurrentWorkspace(name);
+            // Re-instantiate state to bind backend to the new workspace
+            const newStateObj = new state_1.State(dir);
+            await newStateObj.init();
+            newStateObj.clearResources();
+            await newStateObj.save();
+            console.log((0, chalk_1.green)(`Created and switched to workspace "${name}"!`));
+            console.log('');
+            console.log(`You're now on a new, empty workspace. Workspaces isolate their state,`);
+            console.log(`so if you run "${const_1.TITLE_CLI} plan" ${const_1.TITLE_CLI} will not see any existing state`);
+            console.log(`for this configuration.`);
+            break;
+        case 'select':
+            if (!name) {
+                logger.error('Expected a workspace name');
+                process.exit(1);
+            }
+            const existingForSelect = await stateObj.listWorkspaces();
+            if (!existingForSelect.includes(name)) {
+                logger.error(`Workspace "${name}" doesn't exist.\n\nYou can create this workspace with the "new" subcommand.`);
+                process.exit(1);
+            }
+            stateObj.setCurrentWorkspace(name);
+            console.log((0, chalk_1.green)(`Switched to workspace "${name}".`));
+            break;
+        case 'delete':
+            if (!name) {
+                logger.error('Expected a workspace name');
+                process.exit(1);
+            }
+            if (name === 'default') {
+                logger.error(`Workspace "default" cannot be deleted.`);
+                process.exit(1);
+            }
+            if (name === currentWorkspace) {
+                logger.error(`Workspace "${name}" is your active workspace.\n\nYou cannot delete the currently active workspace. Please switch\nto another workspace and try again.`);
+                process.exit(1);
+            }
+            const existingForDelete = await stateObj.listWorkspaces();
+            if (!existingForDelete.includes(name)) {
+                logger.error(`Workspace "${name}" doesn't exist.`);
+                process.exit(1);
+            }
+            const deleted = await stateObj.deleteWorkspace(name);
+            if (deleted) {
+                console.log((0, chalk_1.green)(`Deleted workspace "${name}"!`));
+            }
+            else {
+                logger.error(`Failed to delete workspace "${name}".`);
+                process.exit(1);
+            }
+            break;
+        default:
+            logger.error(`Invalid workspace subcommand: ${subcommand}`);
+            process.exit(1);
+    }
+};
+exports.workspaceCmd = workspaceCmd;

package/dist/const.js

@@ -0,0 +1,105 @@
+"use strict";
+/**
+ * @fileoverview Core constants for the testform CLI.
+ *
+ * Centralizes all string literals, maps, and enumerations used across
+ * the application to avoid duplication and provide a single source of truth.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MSG_APPROVE_ONLY_YES = exports.MSG_ACQUIRING_LOCK = exports.ERR_NO_INPUT_ALLOWED = exports.ERR_GITHUB_CONFIG_NOT_FOUND = exports.SCOPE_CONFIG = exports.SCOPE_RESOURCE_MAP = exports.FILE_STATE = exports.FILE_CONFIG = exports.VERSION_STATE = exports.VERSION_CONFIG = exports.VERSION_CLI = exports.TITLE_CLI = exports.TITLE_APP = void 0;
+// ─── App Identity ─────────────────────────────────────────────────────────────
+/** Human-readable application name used in output messages. */
+exports.TITLE_APP = "Testform";
+/** CLI binary name used in usage strings. */
+exports.TITLE_CLI = "testform";
+/** Current CLI semver version. Keep in sync with package.json. */
+exports.VERSION_CLI = "1.0.0-beta";
+/** Version token written into testform.json config files. */
+exports.VERSION_CONFIG = "1.0";
+/** Version token written into testform.state files. */
+exports.VERSION_STATE = "1.0";
+// ─── File Names ───────────────────────────────────────────────────────────────
+/** Default configuration file name. */
+exports.FILE_CONFIG = "testform.json";
+/** Default state file name. */
+exports.FILE_STATE = "testform.state";
+// ─── Scope Maps ───────────────────────────────────────────────────────────────
+/**
+ * Maps each scope name to its corresponding GitHub resource type string.
+ * Used to eliminate hardcoded resource type strings across commands.
+ */
+exports.SCOPE_RESOURCE_MAP = {
+    testcase: 'github_testcase',
+    testrun: 'github_testrun',
+    testplan: 'github_testplan',
+    testreport: 'github_testreport',
+};
+/**
+ * Maps each scope to the Gherkin tag used to identify feature files.
+ * A feature file with this tag (or the matching extension) belongs to the scope.
+ */
+const SCOPE_TAG_MAP = {
+    testcase: '@testcase',
+    testrun: '@testrun',
+    testplan: '@testplan',
+    testreport: '@testreport',
+};
+/**
+ * Maps each scope to the file extension convention used to identify feature files.
+ * A file ending in this extension automatically belongs to the scope.
+ */
+const SCOPE_EXT_MAP = {
+    testcase: '.case.feature',
+    testrun: '.run.feature',
+    testplan: '.plan.feature',
+    testreport: '.report.feature',
+};
+/**
+ * Full scope configuration map combining resource type, tag and extension.
+ * Exported for use in plan, parser and other modules that need all three values.
+ */
+exports.SCOPE_CONFIG = {
+    testcase: {
+        tag: SCOPE_TAG_MAP.testcase,
+        ext: SCOPE_EXT_MAP.testcase,
+        resource: exports.SCOPE_RESOURCE_MAP.testcase,
+    },
+    testrun: {
+        tag: SCOPE_TAG_MAP.testrun,
+        ext: SCOPE_EXT_MAP.testrun,
+        resource: exports.SCOPE_RESOURCE_MAP.testrun,
+    },
+    testplan: {
+        tag: SCOPE_TAG_MAP.testplan,
+        ext: SCOPE_EXT_MAP.testplan,
+        resource: exports.SCOPE_RESOURCE_MAP.testplan,
+    },
+};
+// ─── Testcase Execution Statuses ──────────────────────────────────────────────
+/**
+ * All valid execution statuses for a test case result comment.
+ * Aligned with Cucumber's built-in statuses plus common QA states.
+ */
+const TESTCASE_STATUSES = ['pending', 'passed', 'failed', 'blocked', 'skipped', 'undefined'];
+/**
+ * Emoji representation for each testcase execution status.
+ * Used when rendering the status table inside testrun issue comments.
+ */
+const TESTCASE_STATUS_EMOJI = {
+    pending: '⏳',
+    passed: '✅',
+    failed: '❌',
+    blocked: '⚠️',
+    skipped: '⏭️',
+    undefined: '❓',
+};
+// ─── Error Messages ───────────────────────────────────────────────────────────
+/** Error shown when testform.json has no "github" section. */
+exports.ERR_GITHUB_CONFIG_NOT_FOUND = `GitHub configuration not found. Add a "github" section to your ${exports.FILE_CONFIG} with owner, repository, and tokenEnv.`;
+/** Error shown when a command requires input but input is disabled. */
+exports.ERR_NO_INPUT_ALLOWED = `This command requires manual approval, but input is disabled. Use the -auto-approve flag to bypass approval.`;
+// ─── UI Messages ──────────────────────────────────────────────────────────────
+/** Message displayed while acquiring the state lock before remote operations. */
+exports.MSG_ACQUIRING_LOCK = 'Acquiring state lock. This may take a few moments...';
+/** Approval prompt instructions shown to the user before applying changes. */
+exports.MSG_APPROVE_ONLY_YES = `Only 'yes' will be accepted to approve.`;