Pipeline de Conteúdo Automatizado com IA: do Prompt ao Publish com TypeScript

[Briefing Queue] → [Geração via LLM] → [Validação Programática] → [Revisão Humana] → [Publicação]
       ↑                                        |
       └── Rejeição com feedback ───────────────┘

// src/types/briefing.ts
export interface ContentBriefing {
  id: string;
  topic: string;
  targetKeyword: string;
  contentType: "tutorial" | "comparison" | "deep-dive" | "opinion";
  targetWordCount: number;
  categorySlug: string;
  // Contexto extra que o LLM recebe como system prompt
  additionalContext?: string;
  // Controle de retry
  attempt: number;
  maxAttempts: number;
  previousFeedback?: string;
}
 
export interface PipelineItem {
  briefing: ContentBriefing;
  generatedContent?: string;
  validationResult?: ValidationResult;
  status: "queued" | "generating" | "validating" | "reviewing" | "approved" | "rejected" | "published";
  createdAt: Date;
  updatedAt: Date;
}

// src/queue/setup.ts
import { Queue, Worker } from "bullmq";
import IORedis from "ioredis";
 
// Conexão separada para queue e worker evita bloqueio
// no subscriber do Redis quando a queue publica eventos
const connection = new IORedis({
  host: process.env.REDIS_HOST ?? "localhost",
  port: Number(process.env.REDIS_PORT ?? 6379),
  maxRetriesPerRequest: null,
});
 
export const generationQueue = new Queue("content-generation", {
  connection,
  defaultJobOptions: {
    attempts: 3,
    backoff: { type: "exponential", delay: 5000 },
    removeOnComplete: { count: 100 },
  },
});
 
export const validationQueue = new Queue("content-validation", {
  connection,
});
 
export const publishQueue = new Queue("content-publish", {
  connection,
});

// src/workers/generation.worker.ts
import { Worker, Job } from "bullmq";
import OpenAI from "openai";
import { ContentBriefing, PipelineItem } from "../types/briefing.js";
import { validationQueue } from "../queue/setup.js";
import { buildSystemPrompt, buildUserPrompt } from "../prompts/builder.js";
 
const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
 
// Limite de tokens calculado a partir do wordCount alvo
// GPT-4o produz ~0.75 palavras por token em português
function estimateMaxTokens(targetWords: number): number {
  return Math.ceil(targetWords / 0.75) + 200;
}
 
async function generateContent(job: Job<ContentBriefing>): Promise<void> {
  const briefing = job.data;
 
  const systemPrompt = buildSystemPrompt(briefing);
  const userPrompt = buildUserPrompt(briefing);
 
  const response = await openai.chat.completions.create({
    model: "gpt-4o",
    messages: [
      { role: "system", content: systemPrompt },
      { role: "user", content: userPrompt },
    ],
    max_tokens: estimateMaxTokens(briefing.targetWordCount),
    temperature: 0.7,
  });
 
  const content = response.choices[0]?.message?.content;
 
  if (!content || content.length < 500) {
    throw new Error(`Resposta curta demais: ${content?.length ?? 0} chars`);
  }
 
  // Passa para a fila de validação com o conteúdo gerado
  await validationQueue.add("validate", {
    briefing,
    generatedContent: content,
    status: "validating",
    createdAt: new Date(),
    updatedAt: new Date(),
  } satisfies PipelineItem);
}
 
const worker = new Worker("content-generation", generateContent, {
  connection: {
    host: process.env.REDIS_HOST ?? "localhost",
    port: Number(process.env.REDIS_PORT ?? 6379),
  },
  concurrency: 3, // 3 chamadas paralelas à API
  limiter: {
    max: 10,
    duration: 60_000, // Max 10 jobs por minuto (respeita rate limit)
  },
});
 
worker.on("failed", (job, err) => {
  console.error(`Job ${job?.id} falhou: ${err.message}`);
});

// src/prompts/builder.ts
import { ContentBriefing } from "../types/briefing.js";
 
export function buildSystemPrompt(briefing: ContentBriefing): string {
  const baseRules = [
    "Você é um redator técnico para um blog de engenharia de software.",
    "Escreva em português brasileiro com acentuação correta.",
    "Use MDX com frontmatter YAML no topo.",
    "Inclua blocos de código com linguagem declarada.",
    "Não use emojis no corpo do texto.",
    `Categoria: ${briefing.categorySlug}`,
  ];
 
  // Feedback de tentativa anterior entra como regra adicional
  // para que o modelo corrija erros específicos
  if (briefing.previousFeedback) {
    baseRules.push(
      `CORREÇÃO OBRIGATÓRIA: ${briefing.previousFeedback}`
    );
  }
 
  return baseRules.join("\n");
}
 
export function buildUserPrompt(briefing: ContentBriefing): string {
  return [
    `Escreva um post do tipo "${briefing.contentType}" sobre: ${briefing.topic}`,
    `Palavra-chave alvo: ${briefing.targetKeyword}`,
    `Tamanho alvo: ${briefing.targetWordCount} palavras`,
    briefing.additionalContext ?? "",
  ]
    .filter(Boolean)
    .join("\n");
}

// src/validators/content.validator.ts
import matter from "gray-matter";
 
export interface ValidationResult {
  valid: boolean;
  errors: string[];
  warnings: string[];
  metrics: {
    wordCount: number;
    codeBlockCount: number;
    headingCount: number;
    hasTable: boolean;
  };
}
 
export function validateContent(
  raw: string,
  targetWordCount: number
): ValidationResult {
  const errors: string[] = [];
  const warnings: string[] = [];
 
  // Validação de frontmatter
  let frontmatter: Record<string, unknown> = {};
  try {
    const parsed = matter(raw);
    frontmatter = parsed.data;
  } catch {
    errors.push("Frontmatter YAML inválido ou ausente");
  }
 
  const requiredFields = ["title", "excerpt", "slug", "categorySlug"];
  for (const field of requiredFields) {
    if (!frontmatter[field]) {
      errors.push(`Campo obrigatório ausente no frontmatter: ${field}`);
    }
  }
 
  // Contagem de palavras (exclui código e frontmatter)
  const contentBody = raw
    .replace(/---[\s\S]*?---/, "")
    .replace(/```[\s\S]*?```/g, "")
    .trim();
  const wordCount = contentBody.split(/\s+/).filter(Boolean).length;
 
  const lowerBound = targetWordCount * 0.7;
  const upperBound = targetWordCount * 1.4;
  if (wordCount < lowerBound) {
    errors.push(`Conteúdo curto: ${wordCount} palavras (mínimo: ${lowerBound})`);
  }
  if (wordCount > upperBound) {
    warnings.push(`Conteúdo longo: ${wordCount} palavras (alvo: ${targetWordCount})`);
  }
 
  // Blocos de código
  const codeBlocks = raw.match(/```\w+/g) ?? [];
  const codeBlockCount = codeBlocks.length;
  if (codeBlockCount < 3) {
    warnings.push(`Poucos blocos de código: ${codeBlockCount}`);
  }
 
  // Blocos sem linguagem declarada
  const untyped = raw.match(/```\n/g) ?? [];
  if (untyped.length > 0) {
    errors.push(`${untyped.length} bloco(s) de código sem linguagem declarada`);
  }
 
  // Headings
  const headings = raw.match(/^#{2,3}\s+.+/gm) ?? [];
  const headingCount = headings.length;
  if (headingCount < 3) {
    errors.push(`Poucas seções: ${headingCount} headings (mínimo: 3)`);
  }
 
  const hasTable = raw.includes("| --- ") || raw.includes("|---");
 
  return {
    valid: errors.length === 0,
    errors,
    warnings,
    metrics: { wordCount, codeBlockCount, headingCount, hasTable },
  };
}

// src/workers/validation.worker.ts
import { Worker, Job } from "bullmq";
import { PipelineItem } from "../types/briefing.js";
import { validateContent } from "../validators/content.validator.js";
import { generationQueue, publishQueue } from "../queue/setup.js";
 
async function validateJob(job: Job<PipelineItem>): Promise<void> {
  const item = job.data;
  const result = validateContent(
    item.generatedContent!,
    item.briefing.targetWordCount
  );
 
  if (!result.valid) {
    // Volta para geração com feedback dos erros
    if (item.briefing.attempt < item.briefing.maxAttempts) {
      await generationQueue.add("regenerate", {
        ...item.briefing,
        attempt: item.briefing.attempt + 1,
        previousFeedback: result.errors.join("; "),
      });
      return;
    }
    // Esgotou tentativas: marca como rejeitado para revisão manual
    console.error(`Item ${item.briefing.id} esgotou tentativas: ${result.errors.join(", ")}`);
    return;
  }
 
  // Validação passou: envia para revisão/publicação
  await publishQueue.add("review", {
    ...item,
    validationResult: result,
    status: "reviewing",
    updatedAt: new Date(),
  });
}
 
const worker = new Worker("content-validation", validateJob, {
  connection: {
    host: process.env.REDIS_HOST ?? "localhost",
    port: Number(process.env.REDIS_PORT ?? 6379),
  },
});

// ERRADO: confia que o LLM gerou frontmatter correto
async function publishDirectly(content: string) {
  // Escreve direto no filesystem sem checar nada
  await fs.writeFile(`posts/${Date.now()}.mdx`, content);
}

// CORRETO: valida antes de gravar
async function publishWithValidation(content: string) {
  const result = validateContent(content, 2000);
  if (!result.valid) {
    throw new Error(`Validação falhou: ${result.errors.join(", ")}`);
  }
 
  const { data } = matter(content);
  const safeSlug = String(data.slug)
    .toLowerCase()
    .replace(/[^a-z0-9-]/g, "-")
    .replace(/-+/g, "-");
 
  await fs.writeFile(`posts/${safeSlug}.mdx`, content);
}

// ERRADO: loop infinito de regeneração
if (!result.valid) {
  await generationQueue.add("regenerate", briefing);
  // Se o prompt é fundamentalmente ruim, isso roda para sempre
  // e gasta créditos da API indefinidamente
}

// src/workers/publish.worker.ts
import { Worker, Job } from "bullmq";
import { execSync } from "node:child_process";
import { writeFileSync, mkdirSync } from "node:fs";
import { join } from "node:path";
import matter from "gray-matter";
import { PipelineItem } from "../types/briefing.js";
 
const CONTENT_DIR = process.env.CONTENT_DIR ?? "./content/posts";
 
async function publishJob(job: Job<PipelineItem>): Promise<void> {
  const { generatedContent, briefing } = job.data;
  if (!generatedContent) throw new Error("Conteúdo vazio");
 
  const { data } = matter(generatedContent);
  const slug = String(data.slug).replace(/[^a-z0-9-]/g, "-");
  const categoryDir = join(CONTENT_DIR, briefing.categorySlug);
 
  mkdirSync(categoryDir, { recursive: true });
  const filePath = join(categoryDir, `${slug}.mdx`);
  writeFileSync(filePath, generatedContent, "utf-8");
 
  // Commit e push automático
  // Em produção, use uma lib como simple-git em vez de execSync
  execSync(`git add "${filePath}"`, { cwd: CONTENT_DIR });
  execSync(
    `git commit -m "feat(content): add ${slug}"`,
    { cwd: CONTENT_DIR }
  );
  execSync("git push origin main", { cwd: CONTENT_DIR });
}
 
const worker = new Worker("content-publish", publishJob, {
  connection: {
    host: process.env.REDIS_HOST ?? "localhost",
    port: Number(process.env.REDIS_PORT ?? 6379),
  },
  concurrency: 1, // Serializa commits para evitar conflito de merge
});

// src/api/status.ts
import { generationQueue, validationQueue, publishQueue } from "../queue/setup.js";
 
export async function getPipelineStatus() {
  const [genCounts, valCounts, pubCounts] = await Promise.all([
    generationQueue.getJobCounts(),
    validationQueue.getJobCounts(),
    publishQueue.getJobCounts(),
  ]);
 
  return {
    generation: genCounts,
    validation: valCounts,
    publish: pubCounts,
    healthy:
      genCounts.failed === 0 &&
      valCounts.failed === 0 &&
      pubCounts.failed === 0,
  };
}