@activate-core/test-forge 0.1.0

package/dist/core/run-generate.js

@@ -0,0 +1,90 @@
+/**
+ * testforge — generate runner.
+ *
+ * For each journey markdown file in docsDir:
+ *   - skips it if unchanged (hash cache), unless force = true
+ *   - generates a TEST file (Jest for api, Playwright for web) via AI,
+ *     falling back to the basic generator if AI fails
+ *   - generates a SEED file for the journey's test data via AI
+ *
+ * Output locations come from config (testOutput per type, seedOutput),
+ * so tests/seeds land where the project expects them. Defaults to
+ * generated-tests/ when not configured.
+ */
+import { readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { join, dirname } from 'node:path';
+import { parseJourney } from './parser.js';
+import { generateTestCases } from './generator.js';
+import { writePlaywrightFile } from './playwright-writer.js';
+import { generateWithAI } from './ai-generator.js';
+import { generateSeed } from './seed-generator.js';
+import { hashContent, loadCache, saveCache } from './cache.js';
+import { findMarkdownFiles } from './find-files.js';
+import { loadConfig, testDirForType } from './config.js';
+const CACHE_PATH = '.testforge/cache.json';
+/** Produce the test file content for one journey. */
+function buildTest(markdown, useAI) {
+    const journey = parseJourney(markdown);
+    if (useAI) {
+        try {
+            return { content: generateWithAI(journey), status: 'ai' };
+        }
+        catch {
+            // fall through to basic
+        }
+    }
+    const cases = generateTestCases(journey);
+    return { content: writePlaywrightFile(journey, cases), status: 'basic' };
+}
+export function runGenerate(docsDir, useAI = true, force = false) {
+    const files = findMarkdownFiles(docsDir);
+    if (files.length === 0) {
+        return [];
+    }
+    const config = loadConfig();
+    const ext = config.testExtension ?? '.test.ts';
+    const seedDir = config.seedOutput ?? 'generated-tests/seed';
+    const cache = loadCache(CACHE_PATH);
+    const results = [];
+    for (const file of files) {
+        const markdown = readFileSync(join(docsDir, file), 'utf-8');
+        const hash = hashContent(markdown);
+        const journey = parseJourney(markdown);
+        // Where this journey's test and seed go.
+        const testDir = testDirForType(config, journey.type);
+        const testPath = join(testDir, `${journey.id}${ext}`);
+        const seedExt = (config.testExtension ?? '.test.ts').endsWith('.js')
+            ? '.seed.js'
+            : '.seed.ts';
+        const seedPath = join(seedDir, `${journey.id}${seedExt}`);
+        // Skip if unchanged.
+        if (!force && cache[file] === hash) {
+            results.push({
+                journeyName: journey.name,
+                testPath,
+                seedPath,
+                status: 'skipped',
+            });
+            continue;
+        }
+        // 1. Test file.
+        const { content, status } = buildTest(markdown, useAI);
+        mkdirSync(dirname(testPath), { recursive: true });
+        writeFileSync(testPath, content, 'utf-8');
+        // 2. Seed file (only when using AI — basic mode has no seed concept).
+        if (useAI) {
+            try {
+                const seed = generateSeed(markdown);
+                mkdirSync(dirname(seedPath), { recursive: true });
+                writeFileSync(seedPath, seed, 'utf-8');
+            }
+            catch {
+                // seed generation failed — leave a note but don't fail the run
+            }
+        }
+        cache[file] = hash;
+        results.push({ journeyName: journey.name, testPath, seedPath, status });
+    }
+    saveCache(CACHE_PATH, cache);
+    return results;
+}

package/dist/core/security-payloads.js

@@ -0,0 +1,24 @@
+/**
+ * testforge — security attack payloads.
+ *
+ * A small, curated list of common attack strings that a QA engineer
+ * would try against text-like input fields. Each entry has a name
+ * (what kind of attack) and a payload (the actual malicious input).
+ *
+ * Keeping these in one place makes it easy to add more later
+ * without touching the generator logic.
+ */
+export const SECURITY_PAYLOADS = [
+    {
+        name: 'XSS script tag',
+        payload: `<script>alert(1)</script>`,
+    },
+    {
+        name: 'SQL injection',
+        payload: `' OR 1=1 --`,
+    },
+    {
+        name: 'HTML injection',
+        payload: `<img src=x onerror=alert(1)>`,
+    },
+];

package/dist/core/seed-generator.js

@@ -0,0 +1,80 @@
+/**
+ * testforge — seed file generator (proof stage).
+ *
+ * Generates a test-data seed file for ONE journey. It feeds the AI:
+ *   - the journey doc (what the feature does, its Data section)
+ *   - the project map (testforge.md), which holds the data layer:
+ *     database type, models/collections, key fields, enum values
+ *
+ * The AI writes a seed that inserts valid test records into the
+ * project's database, using the real schema it learned from the map.
+ * Nothing about a specific database is hardcoded here — the AI adapts
+ * to whatever the project uses (Mongo, SQL, etc.).
+ *
+ * Secrets are never embedded: the connection comes from the env var
+ * named in the map (e.g. process.env.DB_URL), not a literal string.
+ */
+import { execFileSync } from 'node:child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { loadConfig, splitCommand } from './config.js';
+const MAP_PATH = 'testforge.md';
+/** Build the seed-generation prompt for one journey. */
+export function buildSeedPrompt(journeyDoc) {
+    const map = existsSync(MAP_PATH) ? readFileSync(MAP_PATH, 'utf-8') : '';
+    const ext = loadConfig().testExtension ?? '.test.ts';
+    const isJs = ext.endsWith('.js');
+    const language = isJs
+        ? 'plain JavaScript (CommonJS: use require/module.exports, NO TypeScript type annotations)'
+        : 'TypeScript';
+    return [
+        `You are a senior SDET writing a TEST DATA SEED for one feature,`,
+        `so its tests have a known, valid starting state in the database.`,
+        ``,
+        `Use the project map below to understand the data layer — the`,
+        `database type, the models/collections, their key fields, and the`,
+        `allowed enum values. Build records that are VALID against that`,
+        `schema (right collection/table, right fields, right enum values,`,
+        `correct relationships between records).`,
+        ``,
+        `Requirements for the seed you write:`,
+        `- Connect using the env var named in the map (e.g.`,
+        `  process.env.DB_URL). NEVER hardcode a connection string or any`,
+        `  secret.`,
+        `- Make it IDEMPOTENT: use upsert by a stable, well-known test id so`,
+        `  running it repeatedly (fresh DB or already-seeded) is safe.`,
+        `- Prefix test data clearly (e.g. names/ids starting with "qa-" or`,
+        `  "QA-TEST") so it is obvious and easy to clean up.`,
+        `- Insert only what THIS feature's tests need as a precondition,`,
+        `  honoring relationships (e.g. if an order references a user, seed`,
+        `  the user too).`,
+        `- Use the database driver/ORM the project already uses (infer from`,
+        `  the map / schema style).`,
+        ``,
+        `Write the seed in ${language}.`,
+        `Output ONLY the seed code. No explanation, no markdown code fences.`,
+        `The very first characters must be code (a comment or import/require).`,
+        `Add a brief comment block at the top describing what it seeds.`,
+        `Where you must assume something not certain from the inputs,`,
+        `add a "// TODO:" note rather than inventing it confidently.`,
+        `--- PROJECT MAP (data layer) ---`,
+        map,
+        ``,
+        `--- JOURNEY DOC ---`,
+        journeyDoc,
+    ].join('\n');
+}
+/** Generate a seed file's content for one journey doc, via the AI. */
+export function generateSeed(journeyDoc) {
+    const prompt = buildSeedPrompt(journeyDoc);
+    const { program, args } = splitCommand(loadConfig().aiCommand);
+    const output = execFileSync(program, args, {
+        input: prompt,
+        encoding: 'utf-8',
+        maxBuffer: 10 * 1024 * 1024,
+    });
+    // Strip code fences if the AI added them despite instructions.
+    return output
+        .replace(/^```[a-zA-Z]*\n/, '')
+        .replace(/\n```\s*$/, '')
+        .trim();
+}

package/dist/core/setup.js

@@ -0,0 +1,68 @@
+/**
+ * testforge — setup command.
+ *
+ * Runs the one-time project preparation in order, with progress so the
+ * user can see what is happening at each stage:
+ *   1. init     — inspect the project, write testforge.config.json
+ *   2. map      — map journeys + data layer into testforge.md
+ *   3. discover — draft a doc per journey into docs/
+ *
+ * Each step is also available as its own command for re-running a
+ * single stage; setup just chains them for a smooth first run.
+ */
+import { existsSync } from 'node:fs';
+import { hashProjectSource, loadCache, saveCache } from './cache.js';
+import { runInit } from './init.js';
+import { runMap } from './map.js';
+import { runDiscover } from './discover.js';
+import { runEnvTemplate } from './env-template.js';
+export function runSetup(srcDir) {
+    // If the project already looks set up, don't redo it — point the user
+    // to `update` instead, which only refreshes what actually changed.
+    const alreadySetUp = existsSync('testforge.config.json') &&
+        existsSync('testforge.md') &&
+        existsSync('docs');
+    if (alreadySetUp) {
+        console.log('This project is already set up for testforge.');
+        console.log('  - testforge.config.json, testforge.md and docs/ exist.\n');
+        console.log("You don't need to run setup again. Instead:");
+        console.log('  testforge update     refresh only what changed');
+        console.log('  testforge generate   (re)generate tests from docs/');
+        return;
+    }
+    console.log('Setting up testforge for this project.\n');
+    // Step 1 — config.
+    console.log('Step 1/3: Inspecting the project and writing config...');
+    runInit();
+    if (existsSync('testforge.config.json')) {
+        console.log('  done — testforge.config.json\n');
+    }
+    else {
+        console.log('  warning: testforge.config.json was not created\n');
+    }
+    // Step 2 — map.
+    console.log('Step 2/3: Mapping journeys and the data layer...');
+    runMap(srcDir);
+    if (existsSync('testforge.md')) {
+        console.log('  done — testforge.md\n');
+    }
+    else {
+        console.log('  warning: testforge.md was not created\n');
+    }
+    // Step 3 — discover.
+    console.log('Step 3/3: Drafting a doc for each journey...');
+    runDiscover(srcDir, 'docs');
+    console.log('  done — docs/\n');
+    // Remember the source state so the first `update` can detect "no change".
+    const cache = loadCache('.testforge/cache.json');
+    cache['__source__'] = hashProjectSource(srcDir);
+    saveCache('.testforge/cache.json', cache);
+    // Build an env template so the developer knows which credentials each
+    // area/journey needs for running the tests.
+    console.log('Building env template...');
+    runEnvTemplate('docs', '.env.testing.example');
+    console.log('');
+    console.log('Setup complete.');
+    console.log('Review the drafts in docs/, fix anything the AI got wrong,');
+    console.log('then run `testforge generate` to create tests and seed files.');
+}

package/dist/core/update.js

@@ -0,0 +1,52 @@
+/**
+ * testforge — update command.
+ *
+ * Refreshes a project that is already set up, doing only the work that
+ * is actually needed. It decides whether anything changed by hashing
+ * the project's SOURCE CODE (not the AI-generated map, which isn't
+ * deterministic). If the code is unchanged, it does nothing — no AI
+ * calls at all. If the code changed, it re-maps, re-discovers, and
+ * regenerates (generate still skips individual docs that didn't change).
+ */
+import { existsSync } from 'node:fs';
+import { runMap } from './map.js';
+import { runDiscover } from './discover.js';
+import { runGenerate } from './run-generate.js';
+import { hashProjectSource, loadCache, saveCache } from './cache.js';
+import { runEnvTemplate } from './env-template.js';
+const CACHE_PATH = '.testforge/cache.json';
+const SOURCE_KEY = '__source__';
+export function runUpdate(srcDir) {
+    if (!existsSync('testforge.md') || !existsSync('testforge.config.json')) {
+        console.log("This project isn't set up yet.");
+        console.log('Run `testforge setup` first.');
+        return;
+    }
+    console.log('Checking for changes in the source code...\n');
+    const cache = loadCache(CACHE_PATH);
+    const oldHash = cache[SOURCE_KEY];
+    const newHash = hashProjectSource(srcDir);
+    if (oldHash === newHash) {
+        console.log('No source changes detected. Everything is up to date.');
+        console.log('(Nothing regenerated — no AI calls made.)');
+        return;
+    }
+    console.log('Source code changed — updating the project.\n');
+    console.log('Re-mapping the project...');
+    runMap(srcDir);
+    console.log('  done — testforge.md\n');
+    console.log('Updating journey docs...');
+    runDiscover(srcDir, 'docs');
+    console.log('  done — docs/\n');
+    console.log('Regenerating tests for changed journeys...');
+    const results = runGenerate('docs', true, false);
+    const made = results.filter((r) => r.status !== 'skipped').length;
+    const skipped = results.filter((r) => r.status === 'skipped').length;
+    console.log(`  done — ${made} updated, ${skipped} unchanged.\n`);
+    cache[SOURCE_KEY] = newHash;
+    saveCache(CACHE_PATH, cache);
+    console.log('Refreshing env template...');
+    runEnvTemplate('docs', '.env.testing.example');
+    console.log('');
+    console.log('Update complete.');
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@activate-core/test-forge",
+  "version": "0.1.0",
+  "description": "Markdown se automated tests banane wala QA tool. Kisi bhi project mein use ho sakta hai.",
+  "type": "module",
+  "bin": {
+    "testforge": "dist/cli/index.js"
+  },
+  "main": "./dist/core/index.js",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsx": "^4.22.4",
+    "typescript": "^5.4.0"
+  }
+}