Function validateTypeScriptString

src/compiled/cognition/validate.ts:248–427

(value: string)

}

async function validateTypeScriptString(value: string): Promise<ValidationReport> {
  // Models often emit multi-file artifacts as one block with `// path:`
  // headers between sections. tsc parses that as a single source file and
  // chokes on the file-path comments. Rather than fail the whole call we
  // pick the LARGEST contiguous section between such headers and validate
  // just that — the model can return a multi-file plan as long as at least
  // one section is internally consistent.
  //
  // Models also commonly wrap their output in markdown code fences. We
  // extract the fenced block first when present so the surrounding prose
  // (which is never valid TS) doesn't drag down the validator. If multiple
  // fences exist, we pick the largest typescript-tagged one.
  const candidate = pickLargestTsSection(extractFencedTypeScript(value));
  let ts: typeof import("typescript") | null = null;
  try {
    // eslint-disable-next-line @typescript-eslint/no-require-imports
    ts = require("typescript") as typeof import("typescript");
  } catch {
    counter("cognition.validate.skipped", { mode: "ast_compiles" });
    return { ok: true, issues: ["typescript module not installed — ast_compiles skipped"] };
  }

  const sf = ts.createSourceFile("__model_output.ts", candidate, ts.ScriptTarget.Latest, true);
  const issues: string[] = [];

  // Parse diagnostics — unrecoverable syntax errors. tsc's API is loose
  // with naming; cast for the diagnostic array we care about.
  const parseDiags = (sf as unknown as { parseDiagnostics?: ReadonlyArray<import("typescript").Diagnostic> }).parseDiagnostics ?? [];
  for (const d of parseDiags) {
    issues.push(ts.flattenDiagnosticMessageText(d.messageText, "\n"));
  }

  if (issues.length === 0) {
    // Run a real program over the source so we get semantic diagnostics
    // (undeclared names, type-only-as-value, duplicate identifiers, etc.).
    // We keep noResolve:true so missing-module errors are recoverable; we
    // filter those out below and only fail on real bugs in the user's code.
    try {
      const compilerOptions: import("typescript").CompilerOptions = {
        target: ts.ScriptTarget.ES2022,
        module: ts.ModuleKind.CommonJS,
        strict: false,
        noResolve: true,
        skipLibCheck: true,
        skipDefaultLibCheck: true,
        noEmit: true,
        allowJs: true,
        // Don't trip on incidental noise from one-pass model output:
        noUnusedLocals: false,
        noUnusedParameters: false,
        noImplicitAny: false,
      };
      // Synthesise a tiny lib.d.ts so global names like `console`, `Promise`,
      // `process`, `Map`, `Array`, etc. resolve cleanly. Without this every
      // builtin reference becomes a TS2304 false positive.
      const stubLib = [
        // Common globals as values.
        "declare var console: { log(...a: unknown[]): void; warn(...a: unknown[]): void; error(...a: unknown[]): void; info(...a: unknown[]): void; debug(...a: unknown[]): void };",