@activate-core/test-forge 0.8.1 → 0.9.0

package/dist/cli/index.js

@@ -16,6 +16,7 @@
  */
 import { VERSION } from '../core/index.js';
 import { runGenerate } from '../core/run-generate.js';
+import { runTests } from '../core/run-tests.js';
 import { runDiscover } from '../core/discover.js';
 import { runMap } from '../core/map.js';
 import { runInit } from '../core/init.js';
@@ -75,6 +76,7 @@ function printUsage() {
     console.log('  testforge init              Inspect project and write config');
     console.log('  testforge update            Re-check and update only what changed');
     console.log('  testforge env               Write .env.testing.example from docs');
+    console.log('  testforge run [--area a] [--journey j]  Run the generated tests (Jest/Playwright)');
 }
 async function main() {
     if (command === 'update') {
@@ -107,6 +109,13 @@ async function main() {
     else if (command === 'env') {
         runEnvTemplate('docs', '.env.testing.example', '.', generatedScanDirs());
     }
+    else if (command === 'run') {
+        const code = runTests({
+            area: flagValue('--area'),
+            journey: flagValue('--journey'),
+        });
+        process.exitCode = code;
+    }
     else if (command === 'generate') {
         const useAI = !useBasic;
         console.log(useAI

package/dist/core/env-template.js

@@ -100,6 +100,76 @@ function scanSourceEnvVars(srcDir, opts = {}) {
         walk(srcDir);
     return vars;
 }
+/**
+ * Find which of the repo's EXISTING .env* files already declare each var
+ * NAME (values are never read). Lets the template say "reuse from X" so a
+ * developer copies a real value instead of hunting for it.
+ */
+function scanExistingEnvFiles(root = '.', maxFiles = 3000) {
+    const found = new Map(); // var -> first file that has it
+    let seen = 0;
+    const walk = (dir) => {
+        if (seen >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (seen >= maxFiles)
+                return;
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                if (SKIP_DIRS.has(entry.name) || entry.name === 'node_modules')
+                    continue;
+                walk(full);
+            }
+            else if (entry.name.startsWith('.env') &&
+                !entry.name.endsWith('.example') &&
+                !entry.name.endsWith('.sample')) {
+                seen++;
+                try {
+                    for (const line of readFileSync(full, 'utf-8').split('\n')) {
+                        const m = line.match(/^\s*([A-Z][A-Z0-9_]*)\s*=/);
+                        if (m && !found.has(m[1]))
+                            found.set(m[1], full.replace(/^\.\//, ''));
+                    }
+                }
+                catch {
+                    // unreadable — ignore
+                }
+            }
+        }
+    };
+    walk(root);
+    return found;
+}
+/** A short "where do I get this" hint for one env var. */
+function sourceHint(name, foundIn) {
+    const file = foundIn.get(name);
+    if (file)
+        return `reuse from ${file}`;
+    if (/DB_URL|MONGO|DATABASE|_URI/.test(name))
+        return 'test DB connection string (NOT prod)';
+    if (/STRIPE/.test(name))
+        return 'Stripe test-mode dashboard';
+    if (/TWILIO/.test(name))
+        return 'Twilio console';
+    if (/AWS_/.test(name))
+        return 'AWS IAM (test account)';
+    if (/REFRESH_TOKEN|LOGIN_(EMAIL|PASSWORD)/.test(name))
+        return 'ONE seed login for the qa- user';
+    if (/_TOKEN|_SECRET|_KEY|AUTH/.test(name))
+        return 'secret — service dashboard / team vault';
+    if (/_ID$/.test(name))
+        return 'a seeded/pre-created id';
+    if (/URL|HOST|PORT|BASE|DOMAIN/.test(name))
+        return 'service URL (local when running, or the env endpoint)';
+    return 'fill from your test environment';
+}
 /** Derive "area" and "journey" from a doc file name like web-payments.md */
 function areaAndJourney(file) {
     // file is a relative path like "api/payments.md" (folder = area).
@@ -174,6 +244,9 @@ export function runEnvTemplate(docsDir, outPath, srcDir = '.', testDirs = []) {
         console.log('No environment variables found in the docs or source.');
         return;
     }
+    // Where each var can be sourced from (existing .env files win).
+    const foundIn = scanExistingEnvFiles();
+    const line = (v, used) => `${v}=    # ${sourceHint(v, foundIn)}  |  used by: ${used}`;
     // Build the file.
     const lines = [
         '# .env.testing.example',
@@ -189,7 +262,7 @@ export function runEnvTemplate(docsDir, outPath, srcDir = '.', testDirs = []) {
         lines.push('# GENERATED SUITE (env the generated tests/testkit read)');
         lines.push(`# ${'='.repeat(40)}`);
         for (const v of suiteVars) {
-            lines.push(`${v}=            # used by: generated tests`);
+            lines.push(line(v, 'generated tests'));
         }
         lines.push('');
     }
@@ -198,7 +271,7 @@ export function runEnvTemplate(docsDir, outPath, srcDir = '.', testDirs = []) {
         lines.push('# APP (read directly from source — REQUIRED to boot)');
         lines.push(`# ${'='.repeat(40)}`);
         for (const v of bootVars) {
-            lines.push(`${v}=            # used by: app source`);
+            lines.push(line(v, 'app source'));
         }
         lines.push('');
     }
@@ -209,7 +282,7 @@ export function runEnvTemplate(docsDir, outPath, srcDir = '.', testDirs = []) {
         const areaMap = byArea.get(area);
         for (const v of [...areaMap.keys()].sort()) {
             const journeys = [...areaMap.get(v)].sort().join(', ');
-            lines.push(`${v}=            # used by: ${journeys}`);
+            lines.push(line(v, journeys));
         }
         lines.push('');
     }

package/dist/core/run-tests.js

@@ -0,0 +1,83 @@
+/**
+ * testforge — run the generated tests.
+ *
+ * One command to actually EXECUTE what testforge generated, per area,
+ * with the right runner auto-detected (Jest for api/lambda, Playwright
+ * for web/ops) and the test env file loaded first. Saves the developer
+ * from remembering per-area commands, cwds, and env wiring.
+ *
+ * Precedence for the command run in each area:
+ *   1. config.testCommand[area]  (explicit — wins)
+ *   2. a sensible default for the area's framework
+ * It runs from the area's nearest package root (where package.json /
+ * playwright.config live), with config.envFile merged into the env.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join, dirname, resolve, relative } from 'node:path';
+import { loadConfig, loadEnvFile, testDirForType, resolveFramework, } from './config.js';
+/** Nearest ancestor dir containing a package.json (the runner's cwd). */
+function packageRoot(dir) {
+    let d = resolve(dir);
+    for (;;) {
+        if (existsSync(join(d, 'package.json')))
+            return d;
+        const parent = dirname(d);
+        if (parent === d)
+            return resolve(dir); // no package.json found — use dir
+        d = parent;
+    }
+}
+export function runTests(opts = {}) {
+    const config = loadConfig();
+    const envFile = config.envFile ?? '.env.testing';
+    const envVars = loadEnvFile(envFile);
+    if (Object.keys(envVars).length > 0) {
+        console.log(`Loaded env from ${envFile} (${Object.keys(envVars).length} vars).`);
+    }
+    else {
+        console.log(`No env loaded from "${envFile}" — copy .env.testing.example to it and fill values.`);
+    }
+    const env = { ...process.env, ...envVars };
+    const areas = Object.keys(config.testOutput ?? {}).filter((a) => !opts.area || a === opts.area);
+    if (areas.length === 0) {
+        console.log('No areas configured (testOutput is empty). Run `testforge init`.');
+        return 1;
+    }
+    let anyFail = false;
+    let ranAnything = false;
+    for (const area of areas) {
+        const testDir = testDirForType(config, area);
+        if (!existsSync(testDir)) {
+            console.log(`[skip] ${area}: no tests at ${testDir}`);
+            continue;
+        }
+        const framework = resolveFramework(config, area, area);
+        const root = packageRoot(testDir);
+        const rel = relative(root, testDir) || '.';
+        let cmd = config.testCommand?.[area];
+        if (!cmd) {
+            if (framework === 'playwright') {
+                const target = opts.journey ? `${rel}/${opts.journey}` : rel;
+                cmd = `npx playwright test ${target}`;
+            }
+            else {
+                cmd = opts.journey
+                    ? `npx jest --testPathPattern "${opts.journey}"`
+                    : `npx jest ${rel}`;
+            }
+        }
+        ranAnything = true;
+        console.log(`\n=== ${area} (${framework}) ===`);
+        console.log(`$ ${cmd}   [cwd: ${root}]`);
+        const res = spawnSync(cmd, { shell: true, cwd: root, env, stdio: 'inherit' });
+        if (res.status !== 0)
+            anyFail = true;
+    }
+    if (!ranAnything) {
+        console.log('\nNothing to run — generate tests first (`testforge generate`).');
+        return 1;
+    }
+    console.log(anyFail ? '\nSome tests failed.' : '\nAll test runs passed.');
+    return anyFail ? 1 : 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@activate-core/test-forge",
-  "version": "0.8.1",
+  "version": "0.9.0",
   "description": "AI-powered QA automation. Scans a project, drafts journey docs, and generates seeded Jest/Playwright tests. Works in any project, with any AI CLI.",
   "type": "module",
   "bin": {