fastscript 2.0.0 → 3.0.1

package/src/diagnostics.mjs

@@ -0,0 +1,100 @@
+import { mkdirSync, readdirSync, readFileSync, statSync, writeFileSync, existsSync } from "node:fs";
+import { dirname, join, relative, resolve } from "node:path";
+import { analyzeFastScript } from "./fs-diagnostics.mjs";
+
+function walk(dir) {
+  const out = [];
+  if (!existsSync(dir)) return out;
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const full = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (["node_modules", ".git", "dist", ".fastscript"].includes(entry.name)) continue;
+      out.push(...walk(full));
+    } else if (entry.isFile()) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function parseArgs(args = []) {
+  const options = {
+    path: resolve("app"),
+    mode: "report",
+    out: resolve(".fastscript", "diagnostics-report.json"),
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--path") {
+      options.path = resolve(args[i + 1] || options.path);
+      i += 1;
+      continue;
+    }
+    if (arg === "--out") {
+      options.out = resolve(args[i + 1] || options.out);
+      i += 1;
+      continue;
+    }
+    if (arg === "--mode") {
+      const next = (args[i + 1] || "report").toLowerCase();
+      options.mode = next === "fail" ? "fail" : "report";
+      i += 1;
+    }
+  }
+
+  return options;
+}
+
+export async function runDiagnostics(args = []) {
+  const options = parseArgs(args);
+  const files = walk(options.path).filter((file) => file.endsWith(".fs"));
+  const diagnostics = [];
+
+  for (const file of files) {
+    const source = readFileSync(file, "utf8");
+    const issues = analyzeFastScript(source, { file, mode: "lenient" });
+    for (const issue of issues) {
+      diagnostics.push({
+        file: normalizePath(file),
+        code: issue.code,
+        severity: issue.severity,
+        message: issue.message,
+        line: issue.line,
+        column: issue.column,
+      });
+    }
+  }
+
+  const summary = diagnostics.reduce(
+    (acc, item) => {
+      if (item.severity === "warning") acc.warnings += 1;
+      else acc.errors += 1;
+      acc.byCode[item.code] = (acc.byCode[item.code] || 0) + 1;
+      return acc;
+    },
+    { errors: 0, warnings: 0, byCode: {} },
+  );
+
+  const report = {
+    generatedAt: new Date().toISOString(),
+    root: normalizePath(options.path),
+    filesScanned: files.length,
+    summary,
+    diagnostics,
+  };
+
+  mkdirSync(dirname(options.out), { recursive: true });
+  writeFileSync(options.out, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+
+  if (options.mode === "fail" && summary.errors > 0) {
+    throw new Error(`diagnostics failed: ${summary.errors} blocking issue(s)`);
+  }
+
+  console.log(`diagnostics complete: files=${files.length}, errors=${summary.errors}, warnings=${summary.warnings}`);
+  console.log(`diagnostics report: ${normalizePath(relative(resolve("."), options.out))}`);
+}
+
+function normalizePath(path) {
+  return String(path || "").replace(/\\/g, "/");
+}

package/src/fs-error-codes.mjs

@@ -16,8 +16,8 @@ export const FS_ERROR_CODES = Object.freeze({
   },
   FS1004: {
     severity: "error",
-    message: "Type declarations are not valid runtime FastScript syntax.",
-    hint: "Move `type`, `interface`, and `enum` definitions to `.d.ts` files or remove them from `.fs` files.",
+    message: "Legacy compatibility frontend conflict.",
+    hint: "Ordinary TS type-only syntax in `.fs` should parse. If this appears, treat it as a FastScript compatibility bug.",
   },
   FS1005: {
     severity: "error",

package/src/fs-normalize.mjs

@@ -1,7 +1,8 @@
 import { compileFastScript } from "./fs-parser.mjs";
 
 export function normalizeFastScript(source, options = {}) {
-  const { code } = compileFastScript(source, {
+  const prepared = stripTypeScriptHints(String(source ?? ""));
+  const { code } = compileFastScript(prepared, {
     file: options.file || "",
     mode: options.mode || "lenient",
     recover: options.recover !== false,
@@ -11,7 +12,8 @@ export function normalizeFastScript(source, options = {}) {
 }
 
 export function normalizeFastScriptWithMetadata(source, options = {}) {
-  return compileFastScript(source, {
+  const prepared = stripTypeScriptHints(String(source ?? ""));
+  return compileFastScript(prepared, {
     file: options.file || "",
     mode: options.mode || "lenient",
     recover: options.recover !== false,
@@ -40,7 +42,7 @@ export function stripTypeScriptHints(source) {
       continue;
     }
 
-    if (/^\s*interface\s+[A-Za-z_$][\w$]*\s*[{]/.test(next) || /^\s*enum\s+[A-Za-z_$][\w$]*\s*[{]/.test(next)) {
+    if (/^\s*interface\s+[A-Za-z_$][\w$]*(?:\s*<[^>]+>)?\s*[{]/.test(next) || /^\s*enum\s+[A-Za-z_$][\w$]*\s*[{]/.test(next)) {
       out.push(`// ${next.trim()} (removed by fastscript migrate)`);
       skippingBlock = true;
       const opens = (next.match(/{/g) || []).length;
@@ -49,7 +51,7 @@ export function stripTypeScriptHints(source) {
       continue;
     }
 
-    if (/^\s*type\s+[A-Za-z_$][\w$]*\s*=/.test(next)) {
+    if (/^\s*type\s+[A-Za-z_$][\w$]*(?:\s*<[^>]+>)?\s*=/.test(next)) {
       out.push(`// ${next.trim()} (removed by fastscript migrate)`);
       if (!next.includes(";") && next.includes("{")) {
         skippingBlock = true;
@@ -60,28 +62,58 @@ export function stripTypeScriptHints(source) {
       continue;
     }
 
+    if (/^\s*declare\s+(global|module|namespace)\b/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      if (next.includes("{")) {
+        skippingBlock = true;
+        const opens = (next.match(/{/g) || []).length;
+        const closes = (next.match(/}/g) || []).length;
+        blockDepth = Math.max(1, opens - closes);
+      }
+      continue;
+    }
+
+    if (/^\s*declare\s+/.test(next)) {
+      out.push(`// ${next.trim()} (removed by fastscript migrate)`);
+      continue;
+    }
+
     next = next.replace(/\bimport\s+type\b/g, "import");
     next = next.replace(/\bexport\s+type\b/g, "export");
+    next = next.replace(/\btype\s+([A-Za-z_$][\w$]*)\s+as\s+/g, "$1 as ");
+    next = next.replace(/\b(?:public|private|protected|readonly|declare|override|abstract)\s+/g, "");
+    next = next.replace(/\s+implements\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]+/g, "");
+    next = next.replace(/([A-Za-z_$][\w$]*)!([?:;=,\)])/g, "$1$2");
 
     next = next.replace(
       /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*:\s*([^=;]+)([=;].*)$/,
       "$1$2 $3 $5",
     );
+    next = next.replace(
+      /^(\s*)(const|let|var)\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*=\s*/,
+      "$1$2 $3 = ",
+    );
 
-    if (/\bfunction\b/.test(next) || /\)\s*=>/.test(next)) {
+    if (/\bfunction\b/.test(next) || /\bfn\b/.test(next) || /\)\s*=>/.test(next)) {
       next = next.replace(/\(([^)]*)\)/, (_, params) => {
         const cleaned = params.replace(
-          /([A-Za-z_$][\w$]*)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.]*)/g,
+          /([A-Za-z_$][\w$]*)(\?)?\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)/g,
           "$1",
         );
         return `(${cleaned})`;
       });
-      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.]*)\s*\{/g, ") {");
+      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)\s*\{/g, ") {");
+      next = next.replace(/\)\s*:\s*([A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*)\s*=>/g, ") =>");
       next = next.replace(/\bfunction\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "function $1(");
+      next = next.replace(/\bfn\s+([A-Za-z_$][\w$]*)\s*<[^>]+>\s*\(/g, "fn $1(");
+      next = next.replace(/=\s*async\s*<[^>]+>\s*\(/g, "= async (");
+      next = next.replace(/=\s*<[^>]+>\s*\(/g, "= (");
     }
 
     next = next.replace(/^\s*<([A-Za-z_$][\w$,\s]*)>\s*\(/, "(");
     next = next.replace(/\)\s*=>\s*<[A-Za-z_$][\w$<>\[\]\|&, ?.]*>/g, ") =>");
+    next = next.replace(/\s+as\s+const\b/g, "");
+    next = next.replace(/\s+as\s+[A-Za-z_$][\w$<>\[\]\|&, ?.:{}=]*/g, "");
     next = next.replace(/\sas\s+const\b/g, "");
     next = next.replace(/\s+satisfies\s+[A-Za-z_$][\w$<>\[\]\|&, ?.]*/g, "");
     out.push(next);