Implementation Guide: Draft Federal Register Notices, Regulatory Preambles & Public Comment Responses

# comment_analyzer.py
# Bulk retrieves and analyzes public comments from Regulations.gov

import requests
import json
import os
import time
from openai import AzureOpenAI

REGS_API_KEY = os.environ["REGULATIONS_GOV_API_KEY"]
REGS_BASE_URL = "https://api.regulations.gov/v4"

aoai_client = AzureOpenAI(
    azure_endpoint=os.environ["AZURE_OPENAI_ENDPOINT"],
    api_key=os.environ["AZURE_OPENAI_KEY"],
    api_version="2024-08-01-preview"
)

def get_comments_for_docket(docket_id: str, page_size: int = 250) -> list:
    """Retrieve all public comments for a docket from Regulations.gov."""
    headers = {"X-Api-Key": REGS_API_KEY}
    comments = []
    page = 1

    while True:
        params = {
            "filter[docketId]": docket_id,
            "filter[commentOn.documentId]": docket_id,
            "page[size]": page_size,
            "page[number]": page,
            "sort": "postedDate"
        }
        resp = requests.get(f"{REGS_BASE_URL}/comments",
                           headers=headers, params=params)
        resp.raise_for_status()
        data = resp.json()

        batch = data.get("data", [])
        if not batch:
            break

        for comment in batch:
            comment_id = comment["id"]
            detail_resp = requests.get(
                f"{REGS_BASE_URL}/comments/{comment_id}",
                headers=headers
            )
            if detail_resp.status_code == 200:
                detail = detail_resp.json().get("data", {})
                attrs = detail.get("attributes", {})
                comments.append({
                    "id": comment_id,
                    "commenter": attrs.get("submitterName", "Anonymous"),
                    "organization": attrs.get("organization", ""),
                    "date": attrs.get("postedDate", ""),
                    "text": attrs.get("comment", "")[:5000]  # Truncate long comments
                })

            time.sleep(0.1)  # Respect rate limits

        if len(batch) < page_size:
            break
        page += 1

    print(f"Retrieved {len(comments)} comments for docket {docket_id}")
    return comments


def classify_comments_batch(comments: list, rule_summary: str, issues: list) -> list:
    """Classify a batch of comments by topic, position, and key arguments."""

    issues_formatted = "\n".join([f"- {i}" for i in issues])
    comments_formatted = "\n\n".join([
        f"COMMENT {c['id']} | {c['commenter']} ({c['organization']}):\n{c['text']}"
        for c in comments
    ])

    classify_prompt = f"""You are analyzing public comments submitted to a federal agency
during a notice-and-comment rulemaking period.

PROPOSED RULE SUMMARY:
{rule_summary}

KEY ISSUES IN THE PROPOSED RULE:
{issues_formatted}

For each comment below, provide a JSON object with:
- comment_id: the comment ID
- commenter_type: Individual / Organization / Industry / NGO / Government / Academic / Anonymous
- overall_position: Support / Oppose / Mixed / Neutral / Unclear
- primary_topic: which key issue this comment primarily addresses (use exact issue text from list)
- secondary_topics: list of other issues addressed
- key_arguments: list of 2-3 specific arguments made (1 sentence each)
- data_or_evidence_cited: true/false — does the comment cite specific data or studies?
- novel_issue: true/false — does the comment raise an issue not in the key issues list?
- novel_issue_description: if novel_issue is true, briefly describe
- response_priority: High (novel, well-reasoned, with evidence) / Medium / Low (form letter or duplicate)

Return a JSON array of classification objects.

COMMENTS TO ANALYZE:
{comments_formatted}"""

    response = aoai_client.chat.completions.create(
        model=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        messages=[{"role": "user", "content": classify_prompt}],
        temperature=0.0,
        max_tokens=4000,
        response_format={"type": "json_object"}
    )

    # Parse response
    result = json.loads(response.choices[0].message.content)
    return result.get("comments", result) if isinstance(result, dict) else result


def generate_comment_summary_report(
    docket_id: str,
    classified_comments: list,
    rule_title: str
) -> str:
    """Generate an executive summary of the comment record for agency leadership."""

    # Aggregate statistics
    total = len(classified_comments)
    positions = {}
    types = {}
    topics = {}
    high_priority = []

    for c in classified_comments:
        pos = c.get("overall_position", "Unknown")
        positions[pos] = positions.get(pos, 0) + 1

        ct = c.get("commenter_type", "Unknown")
        types[ct] = types.get(ct, 0) + 1

        topic = c.get("primary_topic", "Unknown")
        topics[topic] = topics.get(topic, 0) + 1

        if c.get("response_priority") == "High":
            high_priority.append(c)

    report = f"# Public Comment Analysis Report\n\n"
    report += f"**Docket:** {docket_id}\n"
    report += f"**Rule:** {rule_title}\n"
    report += f"**Total Comments Analyzed:** {total}\n\n"

    report += "## Comment Summary Statistics\n\n"
    report += "### By Position\n"
    for pos, count in sorted(positions.items(), key=lambda x: -x[1]):
        pct = round(count/total*100, 1)
        report += f"- {pos}: {count} ({pct}%)\n"

    report += "\n### By Commenter Type\n"
    for ct, count in sorted(types.items(), key=lambda x: -x[1]):
        report += f"- {ct}: {count}\n"

    report += "\n### By Primary Topic\n"
    for topic, count in sorted(topics.items(), key=lambda x: -x[1]):
        pct = round(count/total*100, 1)
        report += f"- {topic}: {count} ({pct}%)\n"

    report += f"\n## High Priority Comments ({len(high_priority)})\n"
    report += "These comments are novel, well-reasoned, and/or cite specific evidence. "
    report += "They require individual substantive responses in the final rule preamble.\n\n"
    for c in high_priority[:20]:  # Top 20 for report
        report += f"- **{c['comment_id']}** ({c['commenter_type']}, {c['overall_position']}): "
        report += f"{'; '.join(c.get('key_arguments', ['No arguments extracted']))}\n"

    report += "\n---\n[DRAFT — REQUIRES REGULATORY AFFAIRS STAFF REVIEW BEFORE DISTRIBUTION]\n"
    return report

# Public comment response and NPRM preamble draft generation

# comment_response_generator.py

def generate_comment_responses(
    comment_group: list,
    rule_section: str,
    agency_position: str,
    supporting_data: str,
    regulatory_history: str
) -> str:
    """Generate draft responses to a group of related comments."""

    comments_formatted = "\n\n".join([
        f"Comment {c['id']} ({c['commenter_type']}): {c['text'][:1000]}"
        for c in comment_group
    ])

    response_prompt = f"""You are drafting the agency's response to public comments
for inclusion in a Final Rule preamble published in the Federal Register.

RULE SECTION AT ISSUE: {rule_section}
AGENCY'S POSITION: {agency_position}
SUPPORTING DATA/ANALYSIS: {supporting_data}
RELEVANT REGULATORY HISTORY: {regulatory_history}

COMMENTS TO RESPOND TO:
{comments_formatted}

Draft the agency's response following these requirements:
1. Acknowledge the comment(s) factually and fairly — do not mischaracterize opposing views
2. Provide a clear, direct statement of the agency's position
3. Give specific reasoning and cite supporting data where available
4. If the comment raises a valid point that caused the agency to modify the rule, acknowledge it
5. If the comment is outside the scope of this rulemaking, explain why
6. Use plain language (Plain Writing Act compliance)
7. Do not use adversarial or dismissive language
8. If multiple comments make the same point, group them: "Several commenters argued that..."

OUTPUT FORMAT:
**Comment Summary:** [1-2 sentence summary of the comment(s)]
**Response:** [Agency response, 150-400 words depending on complexity]
**Rule Change (if any):** [Yes — [describe change] / No]

IMPORTANT:
- Mark any legal conclusions with [COUNSEL REVIEW REQUIRED]
- Mark any factual claims needing verification with [VERIFY DATA]
- Do not make commitments about future rulemaking actions
- This is a DRAFT — agency counsel must review all responses before publication"""

    response = aoai_client.chat.completions.create(
        model=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        messages=[
            {"role": "system", "content": "You are a federal regulatory affairs specialist drafting APA-compliant public comment responses for a federal agency Final Rule preamble."},
            {"role": "user", "content": response_prompt}
        ],
        temperature=0.2,
        max_tokens=2000
    )

    return response.choices[0].message.content


def generate_nprm_preamble_section(
    section_title: str,
    section_purpose: str,
    regulatory_text: str,
    background_data: str,
    omb_a4_analysis: str = None
) -> str:
    """Generate a draft NPRM preamble section."""

    preamble_prompt = f"""Draft the {section_title} section of an NPRM preamble
for publication in the Federal Register.

SECTION PURPOSE: {section_purpose}
PROPOSED REGULATORY TEXT: {regulatory_text}
BACKGROUND AND DATA: {background_data}
{f'OMB CIRCULAR A-4 ANALYSIS INPUTS: {omb_a4_analysis}' if omb_a4_analysis else ''}

REQUIREMENTS:
- Follow Federal Register preamble conventions (declaratory tone, "The Agency proposes...")
- Use plain language per the Plain Writing Act of 2010
- Include: Background, Purpose, Description of Proposed Rule, Regulatory Analysis summary
- For economically significant rules (>$100M annual impact), include summary of costs and benefits
- Invite public comment with specific questions for commenters to address
- Include Section 508 accessibility language if the rule affects information technology
- Mark [LEGAL REVIEW REQUIRED] for any legal authority citations or APA compliance statements
- Mark [DATA VERIFY] for any quantitative claims

Length: {section_purpose.count(' ') // 10 + 5} paragraphs approximately.
Format as Federal Register prose (no bullet points in main preamble text)."""

    response = aoai_client.chat.completions.create(
        model=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        messages=[
            {"role": "system", "content": "You are a federal regulatory drafting specialist. Draft precise, legally defensible, plain-language Federal Register preamble sections."},
            {"role": "user", "content": preamble_prompt}
        ],
        temperature=0.15,
        max_tokens=3000
    )

    return f"[DRAFT — REQUIRES AGENCY COUNSEL AND POLICY REVIEW — NOT FOR PUBLICATION]\n\n{response.choices[0].message.content}"

# fr_research_assistant.py

FR_BASE_URL = "https://www.federalregister.gov/api/v1"

def search_prior_rulemakings(topic: str, agency: str = None, years: int = 10) -> list:
    """Search Federal Register for prior rulemakings on a topic."""
    params = {
        "conditions[term]": topic,
        "conditions[type][]": ["RULE", "PRORULE"],
        "conditions[publication_date][gte]": f"{2025 - years}-01-01",
        "per_page": 20,
        "order": "relevance",
        "fields[]": ["title", "abstract", "publication_date", "document_number",
                     "agencies", "action", "docket_ids"]
    }
    if agency:
        params["conditions[agency_ids][]"] = agency

    resp = requests.get(f"{FR_BASE_URL}/documents.json", params=params)
    resp.raise_for_status()
    return resp.json().get("results", [])


def generate_regulatory_context_brief(
    rule_topic: str,
    prior_rulemakings: list
) -> str:
    """Generate a regulatory history brief for agency staff."""

    rulemakings_formatted = "\n".join([
        f"- {r['publication_date']}: {r['title']} (Doc: {r['document_number']}) — {r.get('abstract','')[:200]}"
        for r in prior_rulemakings
    ])

    brief_prompt = f"""Based on the following prior Federal Register actions, generate
a Regulatory History section suitable for inclusion in an NPRM preamble.

TOPIC: {rule_topic}
PRIOR ACTIONS:
{rulemakings_formatted}

Generate a Regulatory History section that:
1. Summarizes the key prior actions in chronological order
2. Identifies the regulatory gap or need that this new rulemaking addresses
3. Notes any prior rulemakings that were withdrawn, litigated, or significantly modified
4. Provides appropriate citations in Federal Register citation format:
   [Volume] FR [Page] ([Month Day, Year]) — e.g., 89 FR 12345 (February 15, 2024)

Mark any citations that need verification with [VERIFY CITATION].
This is a DRAFT for agency staff review."""

    response = aoai_client.chat.completions.create(
        model=os.environ["AZURE_OPENAI_DEPLOYMENT"],
        messages=[{"role": "user", "content": brief_prompt}],
        temperature=0.1,
        max_tokens=2000
    )
    return response.choices[0].message.content

SYSTEM PROMPT:
You are a Plain Language Act compliance reviewer for federal agency documents.
Evaluate the following regulatory text against the Federal Plain Language Guidelines
(https://www.plainlanguage.gov/guidelines/).

CHECK FOR:
1. ACTIVE VOICE — flag passive constructions and suggest active alternatives
2. SHORT SENTENCES — flag sentences over 25 words
3. COMMON WORDS — flag unnecessary jargon, legalese, or technical terms without plain-language definitions
4. CLEAR ORGANIZATION — does each paragraph address one idea? Are headers helpful?
5. DIRECT ADDRESS — does the document address the regulated community directly ("you must" vs. "regulated entities shall")?
6. DEFINED TERMS — are all defined terms necessary? Are they defined on first use?

For each issue found, provide:
- Location (paragraph/sentence reference)
- Issue type
- Original text
- Suggested plain-language revision

Then provide an overall Plain Language Score (A/B/C/D/F) with brief justification.

REGULATORY TEXT:
{text}

SYSTEM PROMPT:
You are an administrative law compliance reviewer. Check the following draft Federal
Register document against the procedural requirements of the Administrative Procedure Act
(5 U.S.C. § 553 and related sections).

CHECK FOR:
□ Statutory authority cited for the rulemaking
□ Statement of basis and purpose (§ 553(c))
□ Adequate notice of proposed rule (§ 553(b))
□ Opportunity for public comment (≥30 days for non-significant rules; ≥60 days recommended for significant)
□ For final rules: response to significant comments in record
□ For direct final rules: justification for bypassing notice-and-comment
□ For economically significant rules: OMB OIRA review indicated
□ Effective date compliant (30-day minimum after publication, § 553(d))
□ RFA (Regulatory Flexibility Act) analysis or certification included
□ Paperwork Reduction Act analysis included if rule imposes information collection
□ NEPA analysis included or scoped out if rule may affect environment
□ EO 12866/13563/14094 compliance statement

For each item, indicate: PRESENT / MISSING / UNCLEAR
Flag any MISSING items as [APA DEFICIENCY — LEGAL REVIEW REQUIRED].

NOTE: This checklist is not a substitute for agency counsel review.
APA compliance is ultimately a legal determination.

DRAFT DOCUMENT:
{regulatory_text}