briefloop 0.11.12__py3-none-any.whl

multi_agent_brief/analysis_modules/policy_regulatory/schemas.py

@@ -0,0 +1,129 @@
+"""Data structures for Policy & Regulatory Risk Module."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date
+from typing import Any
+
+
+@dataclass
+class PolicyEvent:
+    """A single policy or regulatory event."""
+
+    event_id: str
+    jurisdiction: str
+    authority: str
+    instrument_name: str
+    publication_date: str = ""
+    effective_date: str = ""
+    affected_entities: list[str] = field(default_factory=list)
+    core_change: str = ""
+    compliance_deadline: str = ""
+    source_refs: list[str] = field(default_factory=list)
+    limitations: list[str] = field(default_factory=list)
+    epistemic_type: str = "FACT"  # FACT, HYPOTHESIS, TO_VERIFY
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "event_id": self.event_id,
+            "jurisdiction": self.jurisdiction,
+            "authority": self.authority,
+            "instrument_name": self.instrument_name,
+            "publication_date": self.publication_date,
+            "effective_date": self.effective_date,
+            "affected_entities": self.affected_entities,
+            "core_change": self.core_change,
+            "compliance_deadline": self.compliance_deadline,
+            "source_refs": self.source_refs,
+            "limitations": self.limitations,
+            "epistemic_type": self.epistemic_type,
+        }
+
+
+@dataclass
+class RiskItem:
+    """A single risk item in the risk register."""
+
+    risk_id: str
+    event_id: str
+    risk_type: str  # compliance, operational, market_access, reputational
+    severity: str  # low, medium, high, critical
+    likelihood: str  # unlikely, possible, likely, certain
+    affected_entities: list[str] = field(default_factory=list)
+    mitigation_notes: str = ""
+    applicability_status: str = "TO_VERIFY"  # CONFIRMED, TO_VERIFY, HYPOTHESIS
+    source_refs: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "risk_id": self.risk_id,
+            "event_id": self.event_id,
+            "risk_type": self.risk_type,
+            "severity": self.severity,
+            "likelihood": self.likelihood,
+            "affected_entities": self.affected_entities,
+            "mitigation_notes": self.mitigation_notes,
+            "applicability_status": self.applicability_status,
+            "source_refs": self.source_refs,
+        }
+
+
+@dataclass
+class ApplicabilityQuestion:
+    """An open question about applicability of a policy event."""
+
+    question_id: str
+    event_id: str
+    question: str
+    context: str = ""
+    priority: str = "medium"  # low, medium, high
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "question_id": self.question_id,
+            "event_id": self.event_id,
+            "question": self.question,
+            "context": self.context,
+            "priority": self.priority,
+        }
+
+
+@dataclass
+class PolicyEvidencePack:
+    """Evidence pack for policy & regulatory analysis."""
+
+    events: list[PolicyEvent] = field(default_factory=list)
+    risks: list[RiskItem] = field(default_factory=list)
+    applicability_questions: list[ApplicabilityQuestion] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "events": [e.to_dict() for e in self.events],
+            "risks": [r.to_dict() for r in self.risks],
+            "applicability_questions": [q.to_dict() for q in self.applicability_questions],
+            "metadata": self.metadata,
+        }
+
+
+@dataclass
+class PolicyCoverageReport:
+    """Coverage report for policy & regulatory analysis."""
+
+    total_events: int = 0
+    jurisdictions_covered: list[str] = field(default_factory=list)
+    authorities_covered: list[str] = field(default_factory=list)
+    risk_types_covered: list[str] = field(default_factory=list)
+    coverage_gaps: list[str] = field(default_factory=list)
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "total_events": self.total_events,
+            "jurisdictions_covered": self.jurisdictions_covered,
+            "authorities_covered": self.authorities_covered,
+            "risk_types_covered": self.risk_types_covered,
+            "coverage_gaps": self.coverage_gaps,
+            "metadata": self.metadata,
+        }

multi_agent_brief/analysis_modules/registry.py

@@ -0,0 +1,73 @@
+"""Analysis Module Registry — discovers and loads pluggable analysis modules."""
+from __future__ import annotations
+
+from typing import Any
+
+from multi_agent_brief.analysis_modules.base import AnalysisModule
+
+# Global registry: maps module name → module class.
+MODULE_REGISTRY: dict[str, type[AnalysisModule]] = {}
+
+
+def register_module(name: str, cls: type[AnalysisModule]) -> None:
+    """Register an AnalysisModule class."""
+    MODULE_REGISTRY[name] = cls
+
+
+def load_enabled_modules(config: dict[str, Any] | None) -> list[AnalysisModule]:
+    """Instantiate analysis modules enabled in config.yaml's ``modules`` section.
+
+    Args:
+        config: Full parsed config.yaml (with optional ``modules`` key).
+
+    Returns:
+        A list of instantiated AnalysisModules, ordered by registration.
+        Returns an empty list when ``modules`` is missing or empty.
+    """
+    if config is None:
+        return []
+
+    modules_config = config.get("modules")
+    if not modules_config:
+        return []
+
+    if not isinstance(modules_config, dict):
+        return []
+
+    enabled_modules: list[AnalysisModule] = []
+    for module_name, cls in MODULE_REGISTRY.items():
+        module_cfg = modules_config.get(module_name, {})
+        if not isinstance(module_cfg, dict):
+            continue
+        if not module_cfg.get("enabled", False):
+            continue
+
+        instance = cls()
+        instance.name = getattr(cls, "name", "") or cls.__name__
+        enabled_modules.append(instance)
+
+    return enabled_modules
+
+
+# ── Auto-registration ───────────────────────────────────────────────────────
+
+def _auto_register() -> None:
+    """Register built-in analysis modules."""
+    try:
+        from multi_agent_brief.analysis_modules.market_competitor import (
+            MarketCompetitorModule,
+        )
+        register_module("market_competitor", MarketCompetitorModule)
+    except ImportError:
+        pass
+
+    try:
+        from multi_agent_brief.analysis_modules.policy_regulatory import (
+            PolicyRegulatoryModule,
+        )
+        register_module("policy_regulatory", PolicyRegulatoryModule)
+    except ImportError:
+        pass
+
+
+_auto_register()

multi_agent_brief/audience/__init__.py

@@ -0,0 +1,19 @@
+"""Audience Profiles — deterministic configuration for brief structure and quality thresholds.
+
+Each profile defines required sections, banned phrases, quality thresholds,
+and default DOCX template. Profiles are mapped conservatively from free-text
+onboarding input.
+"""
+from multi_agent_brief.audience.profiles import (
+    AudienceProfile,
+    get_profile,
+    map_audience_to_profile,
+    PROFILES,
+)
+
+__all__ = [
+    "AudienceProfile",
+    "get_profile",
+    "map_audience_to_profile",
+    "PROFILES",
+]

multi_agent_brief/audience/profiles.py

@@ -0,0 +1,246 @@
+"""Audience Profile definitions and mapping logic.
+
+Profiles are public-safe and industry-neutral. They define:
+- Required and optional sections
+- Banned phrases and required disclaimers
+- Quality thresholds (min chars, min sections, etc.)
+- Citation and summary bullet policies
+- Default DOCX template
+- Final quality and editorial governance thresholds
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+
+@dataclass
+class AudienceProfile:
+    """Deterministic configuration for a specific audience type."""
+
+    profile_id: str
+    display_name: str
+
+    # Section requirements
+    required_sections: list[str] = field(default_factory=list)
+    optional_sections: list[str] = field(default_factory=list)
+
+    # Content restrictions
+    banned_phrases: list[str] = field(default_factory=list)
+    required_disclaimers: list[str] = field(default_factory=list)
+
+    # Quality thresholds
+    min_markdown_chars: int = 8000
+    min_main_sections: int = 3
+    min_zh_chars: int = 0  # 0 = not enforced
+    min_en_words: int = 0  # 0 = not enforced
+
+    # Policy settings
+    summary_bullet_policy: str = "required"  # required / optional / none
+    citation_policy: str = "required"  # required / optional / none
+
+    # DOCX template default
+    docx_template: str = "executive_brief"
+
+    # Threshold overrides for final quality gate
+    final_quality_thresholds: dict = field(default_factory=dict)
+
+    # Threshold overrides for editorial governance
+    editorial_governance_thresholds: dict = field(default_factory=dict)
+
+
+# ── Profile Registry ──────────────────────────────────────────────────────────
+
+PROFILES: dict[str, AudienceProfile] = {
+    "management": AudienceProfile(
+        profile_id="management",
+        display_name="Management / Executive",
+        required_sections=["Executive Summary", "Key Developments", "Outlook"],
+        optional_sections=["Risk Assessment", "Competitive Landscape"],
+        banned_phrases=[
+            "investment recommendation",
+            "buy",
+            "sell",
+            "target price",
+            "strong buy",
+            "strong sell",
+        ],
+        required_disclaimers=[],
+        min_markdown_chars=8000,
+        min_main_sections=3,
+        min_zh_chars=3000,
+        min_en_words=1800,
+        summary_bullet_policy="required",
+        citation_policy="required",
+        docx_template="executive_brief",
+        final_quality_thresholds={
+            "expected_summary_bullets": 5,
+            "min_selected_claims": 20,
+        },
+        editorial_governance_thresholds={
+            "min_factual_density": 0.3,
+        },
+    ),
+    "research": AudienceProfile(
+        profile_id="research",
+        display_name="Research / Analyst",
+        required_sections=["Executive Summary", "Methodology", "Findings", "Data Sources"],
+        optional_sections=["Limitations", "Appendix"],
+        banned_phrases=[],
+        required_disclaimers=[],
+        min_markdown_chars=12000,
+        min_main_sections=4,
+        min_zh_chars=4000,
+        min_en_words=2500,
+        summary_bullet_policy="required",
+        citation_policy="required",
+        docx_template="research_note",
+        final_quality_thresholds={
+            "expected_summary_bullets": 7,
+            "min_selected_claims": 30,
+        },
+        editorial_governance_thresholds={
+            "min_factual_density": 0.4,
+        },
+    ),
+    "ir": AudienceProfile(
+        profile_id="ir",
+        display_name="Investor Relations / Disclosure",
+        required_sections=["Executive Summary", "Key Metrics", "Outlook"],
+        optional_sections=["Risk Factors", "Regulatory Considerations"],
+        banned_phrases=[
+            "investment recommendation",
+            "buy",
+            "sell",
+            "target price",
+        ],
+        required_disclaimers=[
+            "This document is for informational purposes only and does not constitute investment advice.",
+        ],
+        min_markdown_chars=8000,
+        min_main_sections=3,
+        min_zh_chars=3000,
+        min_en_words=1800,
+        summary_bullet_policy="required",
+        citation_policy="required",
+        docx_template="formal_internal_report",
+        final_quality_thresholds={
+            "expected_summary_bullets": 5,
+            "min_selected_claims": 20,
+        },
+        editorial_governance_thresholds={
+            "min_factual_density": 0.35,
+        },
+    ),
+    "legal_compliance": AudienceProfile(
+        profile_id="legal_compliance",
+        display_name="Legal / Compliance / Regulatory",
+        required_sections=["Executive Summary", "Regulatory Changes", "Compliance Impact"],
+        optional_sections=["Risk Assessment", "Action Items"],
+        banned_phrases=[
+            "investment recommendation",
+            "buy",
+            "sell",
+            "target price",
+        ],
+        required_disclaimers=[
+            "This document is for informational purposes only and does not constitute legal advice.",
+        ],
+        min_markdown_chars=10000,
+        min_main_sections=3,
+        min_zh_chars=3500,
+        min_en_words=2000,
+        summary_bullet_policy="required",
+        citation_policy="required",
+        docx_template="formal_internal_report",
+        final_quality_thresholds={
+            "expected_summary_bullets": 5,
+            "min_selected_claims": 25,
+        },
+        editorial_governance_thresholds={
+            "min_factual_density": 0.4,
+        },
+    ),
+    "default": AudienceProfile(
+        profile_id="default",
+        display_name="General / Default",
+        required_sections=["Executive Summary", "Key Developments"],
+        optional_sections=["Outlook", "Risk Assessment"],
+        banned_phrases=[],
+        required_disclaimers=[],
+        min_markdown_chars=8000,
+        min_main_sections=3,
+        min_zh_chars=3000,
+        min_en_words=1800,
+        summary_bullet_policy="required",
+        citation_policy="required",
+        docx_template="executive_brief",
+        final_quality_thresholds={
+            "expected_summary_bullets": 5,
+            "min_selected_claims": 20,
+        },
+        editorial_governance_thresholds={
+            "min_factual_density": 0.3,
+        },
+    ),
+}
+
+
+def get_profile(profile_id: str) -> AudienceProfile:
+    """Get an AudienceProfile by ID.
+
+    Returns the 'default' profile if the ID is not found.
+    """
+    return PROFILES.get(profile_id, PROFILES["default"])
+
+
+def map_audience_to_profile(audience_text: str) -> str:
+    """Conservatively map free-text audience to a profile ID.
+
+    This mapping is intentionally conservative — unknown audience types
+    map to 'default' rather than guessing.
+
+    Args:
+        audience_text: Free-text audience description from onboarding.
+
+    Returns:
+        Profile ID string (management, research, ir, legal_compliance, or default).
+    """
+    t = audience_text.strip().lower()
+    if not t:
+        return "default"
+
+    # Management / Executive mappings
+    management_keywords = [
+        "management", "executive", "ceo", "cfo", "cto", "board",
+        "leadership", "c-suite", "management team", "executive team",
+        "管理层", "总裁办", "董事会", "高管", "领导层", "boss",
+    ]
+    if any(kw in t for kw in management_keywords):
+        return "management"
+
+    # Research / Analyst mappings
+    research_keywords = [
+        "research", "analyst", "industry research", "research analyst",
+        "研究员", "分析员", "行业研究", "研究团队",
+    ]
+    if any(kw in t for kw in research_keywords):
+        return "research"
+
+    # Investor Relations mappings
+    ir_keywords = [
+        "investor relations", "ir", "disclosure", "investor",
+        "投关", "披露", "投资者关系", "ir部门",
+    ]
+    if any(kw in t for kw in ir_keywords):
+        return "ir"
+
+    # Legal / Compliance mappings
+    legal_keywords = [
+        "legal", "compliance", "regulatory", "law", "legal compliance",
+        "法务", "合规", "监管", "法律", "法规",
+    ]
+    if any(kw in t for kw in legal_keywords):
+        return "legal_compliance"
+
+    # Unknown audience → default
+    return "default"

multi_agent_brief/audience_memory/__init__.py

@@ -0,0 +1,23 @@
+"""Workspace-local audience taste memory runtime surface."""
+
+from multi_agent_brief.audience_memory.profile import (
+    AUDIENCE_MEMORY_FILES,
+    AudienceProfileResult,
+    AudienceSnapshotResult,
+    build_default_audience_profile,
+    create_audience_profile_snapshot,
+    ensure_audience_profile,
+    profile_data_from_object,
+    profile_data_from_workspace_config,
+)
+
+__all__ = [
+    "AUDIENCE_MEMORY_FILES",
+    "AudienceProfileResult",
+    "AudienceSnapshotResult",
+    "build_default_audience_profile",
+    "create_audience_profile_snapshot",
+    "ensure_audience_profile",
+    "profile_data_from_object",
+    "profile_data_from_workspace_config",
+]