@activate-core/test-forge 0.1.1 → 0.2.0

package/dist/core/validate.js

@@ -0,0 +1,82 @@
+/**
+ * testforge — generated-code syntax gate.
+ *
+ * Before any generated test/seed is written to disk, its content is
+ * parse-checked here. This is what stops malformed output (prose that
+ * leaked past cleaning, a half-written file, an unbalanced brace) from
+ * ever reaching the project — the single gate that would have prevented
+ * the broken-seed defects.
+ *
+ * We stay dependency-free:
+ *   - JavaScript (.js/.cjs/.mjs): checked EXACTLY with Node's built-in
+ *     `node --check`, which parses without executing.
+ *   - TypeScript (.ts/.tsx): no exact parser is guaranteed at runtime
+ *     (the project we run inside may not have `typescript` installed),
+ *     so we fall back to a structural sanity check that still catches
+ *     the common failure — prose leaking into the file — without
+ *     false-rejecting valid TypeScript.
+ */
+import { execFileSync } from 'node:child_process';
+import { writeFileSync, mkdtempSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+/** True if `content` parses (or, for TS, passes a structural check). */
+export function isSyntaxValid(content, ext) {
+    if (!content.trim())
+        return false;
+    const isJs = /\.(c|m)?js$/i.test(ext);
+    if (isJs) {
+        return nodeCheck(content, ext);
+    }
+    return looksStructurallyClean(content);
+}
+/** Write to a temp file and run `node --check` on it. */
+function nodeCheck(content, ext) {
+    const dir = mkdtempSync(join(tmpdir(), 'testforge-check-'));
+    // `.mjs` gets ES-module parsing; anything else checks fine as `.js`
+    // (CommonJS), and `node --check` accepts both `import` and `require`
+    // there depending on extension — so preserve an explicit `.mjs`.
+    const fileExt = /\.mjs$/i.test(ext) ? '.mjs' : '.js';
+    const file = join(dir, `check${fileExt}`);
+    try {
+        writeFileSync(file, content, 'utf-8');
+        execFileSync(process.execPath, ['--check', file], { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        rmSync(dir, { recursive: true, force: true });
+    }
+}
+/**
+ * Best-effort TypeScript check: the file must START with code (not a
+ * sentence) and have balanced braces/parens. This catches leaked prose
+ * — the actual failure mode we saw — without a real TS parser.
+ */
+function looksStructurallyClean(content) {
+    const firstLine = content
+        .trim()
+        .split('\n')
+        .find((l) => l.trim() !== '') ?? '';
+    const t = firstLine.trim();
+    const startsWithCode = t.startsWith('//') ||
+        t.startsWith('/*') ||
+        t.startsWith('import ') ||
+        t.startsWith('export ') ||
+        t.startsWith('const ') ||
+        t.startsWith('let ') ||
+        t.startsWith('var ') ||
+        t.startsWith('function ') ||
+        t.startsWith('async ') ||
+        t.startsWith('require(') ||
+        t.startsWith("'use strict'") ||
+        t.startsWith('"use strict"');
+    if (!startsWithCode)
+        return false;
+    const count = (s, ch) => s.split(ch).length - 1;
+    const balanced = count(content, '{') === count(content, '}') &&
+        count(content, '(') === count(content, ')');
+    return balanced;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@activate-core/test-forge",
-  "version": "0.1.1",
+  "version": "0.2.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": {