Function checkSyntaxForWrite

src/tools/ast/syntax-check.ts:134–184

(
  absPath: string,
  beforeContent: string | null,
  afterContent: string,
)

 * uncheckable), or a ready [SYNTAX_REJECTED] message when it must be refused.
 */
export async function checkSyntaxForWrite(
  absPath: string,
  beforeContent: string | null,
  afterContent: string,
): Promise<string | null> {
  if (!gateEnabled) return null;
  if (afterContent.length > MAX_GATED_BYTES) return null;

  const lower = absPath.toLowerCase();
  if (lower.endsWith('.json')) {
    const after = checkJsonSyntax(afterContent);
    if (after.length === 0) return null;
    const beforeHad = beforeContent === null ? null : checkJsonSyntax(beforeContent).length > 0;
    return shouldReject(beforeHad, true) ? buildSyntaxRejectMessage(absPath, 'JSON', after) : null;
  }

  try {
    const { detectLanguage, getParser } = await import('./parser.js');
    const lang = detectLanguage(absPath);
    if (!lang) return null;                 // unknown extension → fail-open
    const p = await getParser(lang);
    if (!p) return null;                    // grammar unavailable → fail-open

    const parseIssues = (text: string): SyntaxIssue[] | null => {
      let tree: any = null;
      try {
        tree = p.parser.parse(text);
        if (!tree?.rootNode) return null;
        return findIssuesInTree(tree.rootNode as TSNodeLike, text);
      } catch (e: any) {
        // Fail-open (never block the write), but surface that the parser could
        // not run so a silently-broken parser isn't mistaken for "clean file".
        console.warn(`[syntax-check] parser could not run for ${absPath}; skipping syntax gate: ${e?.message ?? String(e)}`);
        return null;                        // parser hiccup → fail-open
      } finally {
        try { tree?.delete?.(); } catch { /* wasm cleanup best-effort */ }
      }
    };

    const after = parseIssues(afterContent);
    if (after === null || after.length === 0) return null;
    // Lazy baseline: only parse the original when the candidate is broken.
    const beforeIssues = beforeContent === null ? null : parseIssues(beforeContent);
    const beforeHad = beforeIssues === null ? (beforeContent === null ? null : true) : beforeIssues.length > 0;
    return shouldReject(beforeHad, true) ? buildSyntaxRejectMessage(absPath, lang, after) : null;
  } catch (e: any) {
    // Fail-open, but log so an unexpectedly-broken gate isn't read as "clean".
    console.warn(`[syntax-check] gate could not run for ${absPath}; skipping syntax check: ${e?.message ?? String(e)}`);
    return null;                            // anything unexpected → fail-open
  }
}