agentrules 3.4.2__tar.gz → 3.5.0__tar.gz

{agentrules-3.4.2/src/agentrules.egg-info → agentrules-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agentrules
-Version: 3.4.2
+Version: 3.5.0
 Summary: AGENTS.md/CLAUDE.md generator and ExecPlan harness for coding agents
 Author: trevor-nichols
 License-Expression: MIT

{agentrules-3.4.2 → agentrules-3.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agentrules"
-version = "3.4.2"
+version = "3.5.0"
 description = "AGENTS.md/CLAUDE.md generator and ExecPlan harness for coding agents"
 readme = "README.md"
 authors = [{name = "trevor-nichols"}]

{agentrules-3.4.2 → agentrules-3.5.0}/src/agentrules/config/prompts/phase_1_prompts.py

@@ -8,6 +8,9 @@ modifying the core logic of the agents.
 
 from __future__ import annotations
 
+from collections.abc import Mapping
+from typing import Any
+
 from agentrules.core.utils.system_prompt import normalize_responsibilities
 
 # Phase 1 system prompt template (agent behavior/persona guidance).
@@ -111,6 +114,30 @@ RESEARCHER_AGENT_PROMPT = {
     ]
 }
 
+FRONTEND_DESIGN_AGENT_PROMPT = {
+    "name": "Frontend Design Agent",
+    "role": "analyzing UI styling architecture and design system surface",
+    "responsibilities": [
+        "Identify the primary styling approach used by the frontend (Tailwind, CSS modules, global CSS, CSS-in-JS)",
+        "Locate likely design-token and variant definitions from configuration files and project layout",
+        "Summarize frontend architecture patterns that influence UI composition and onboarding",
+        "Call out uncertainty explicitly when styling evidence is incomplete or mixed"
+    ],
+    "profile_key": "frontend",
+}
+
+PYTHON_TOOLING_AGENT_PROMPT = {
+    "name": "Python Tooling Agent",
+    "role": "analyzing Python packaging, tooling, and local developer workflow surfaces",
+    "responsibilities": [
+        "Summarize Python packaging and dependency-management conventions across pyproject, requirements, and setup files",
+        "Identify task runner entrypoints such as Makefile or justfile and their likely onboarding relevance",
+        "Capture tooling surfaces such as tox or nox that shape local development workflows",
+        "Highlight mixed or redundant Python tooling conventions that may confuse onboarding"
+    ],
+    "profile_key": "python",
+}
+
 # Function to format a prompt for a specific agent
 def format_agent_prompt(agent_config, context):
     """
@@ -145,10 +172,46 @@ def get_dependency_agent_prompt(researcher_enabled: bool) -> dict:
     }
 
 
+def get_specialized_phase1_agent_prompts(
+    project_profile: Mapping[str, Any] | None,
+) -> list[dict[str, Any]]:
+    """
+    Return specialized Phase 1 agent configs based on deterministic profile signals.
+
+    Specialized agents are optional and should run only when the profile indicates
+    a relevant project surface.
+    """
+
+    prompts: list[dict[str, Any]] = []
+    profile = project_profile if isinstance(project_profile, Mapping) else {}
+
+    if _profile_slice_detected(profile, "frontend"):
+        prompts.append(_clone_prompt(FRONTEND_DESIGN_AGENT_PROMPT))
+    if _profile_slice_detected(profile, "python"):
+        prompts.append(_clone_prompt(PYTHON_TOOLING_AGENT_PROMPT))
+    return prompts
+
+
+def _profile_slice_detected(project_profile: Mapping[str, Any], key: str) -> bool:
+    section = project_profile.get(key)
+    return bool(isinstance(section, Mapping) and section.get("detected"))
+
+
+def _clone_prompt(prompt: Mapping[str, Any]) -> dict[str, Any]:
+    return {
+        "name": str(prompt["name"]),
+        "role": str(prompt["role"]),
+        "responsibilities": list(prompt.get("responsibilities", [])),
+        "profile_key": prompt.get("profile_key"),
+    }
+
+
 # List of all Phase 1 agent configurations (default order assumes researcher enabled)
 PHASE_1_AGENTS = [
     DEPENDENCY_KNOWLEDGE_GAP_PROMPT,
     STRUCTURE_AGENT_PROMPT,
     TECH_STACK_AGENT_PROMPT,
-    RESEARCHER_AGENT_PROMPT
+    RESEARCHER_AGENT_PROMPT,
+    FRONTEND_DESIGN_AGENT_PROMPT,
+    PYTHON_TOOLING_AGENT_PROMPT,
 ]

{agentrules-3.4.2 → agentrules-3.5.0}/src/agentrules/core/analysis/phase_1.py

@@ -23,11 +23,13 @@ from agentrules.config.prompts.phase_1_prompts import (  # Prompts used for conf
     TECH_STACK_AGENT_PROMPT,
     format_phase1_system_prompt,
     get_dependency_agent_prompt,
+    get_specialized_phase1_agent_prompts,
 )
 from agentrules.config.tools import TOOL_SETS
 from agentrules.core.agents.factory.factory import get_architect_for_phase, get_researcher_architect
 from agentrules.core.types.tool_config import Tool
 from agentrules.core.utils.provider_capabilities import requires_external_research_tool_loop
+from agentrules.core.utils.system_prompt import normalize_responsibilities
 
 try:
     from agentrules.core.agent_tools.web_search.tavily import run_tavily_search as _run_tavily_search
@@ -61,41 +63,20 @@ class Phase1Analysis:
         self.researcher_enabled = researcher_enabled
 
         dependency_prompt = get_dependency_agent_prompt(self.researcher_enabled)
-        self.dependency_architect = get_architect_for_phase(
-            "phase1",
+        self.dependency_architect = self._create_phase1_architect(
             name=dependency_prompt["name"],
             role=dependency_prompt["role"],
             responsibilities=dependency_prompt["responsibilities"],
-            prompt_template=PHASE_1_BASE_PROMPT,
-            system_prompt=format_phase1_system_prompt(
-                agent_name=dependency_prompt["name"],
-                agent_role=dependency_prompt["role"],
-                responsibilities=dependency_prompt["responsibilities"],
-            ),
         )
-        self.structure_architect = get_architect_for_phase(
-            "phase1",
+        self.structure_architect = self._create_phase1_architect(
             name=STRUCTURE_AGENT_PROMPT["name"],
             role=STRUCTURE_AGENT_PROMPT["role"],
             responsibilities=STRUCTURE_AGENT_PROMPT["responsibilities"],
-            prompt_template=PHASE_1_BASE_PROMPT,
-            system_prompt=format_phase1_system_prompt(
-                agent_name=STRUCTURE_AGENT_PROMPT["name"],
-                agent_role=STRUCTURE_AGENT_PROMPT["role"],
-                responsibilities=STRUCTURE_AGENT_PROMPT["responsibilities"],
-            ),
         )
-        self.tech_stack_architect = get_architect_for_phase(
-            "phase1",
+        self.tech_stack_architect = self._create_phase1_architect(
             name=TECH_STACK_AGENT_PROMPT["name"],
             role=TECH_STACK_AGENT_PROMPT["role"],
             responsibilities=TECH_STACK_AGENT_PROMPT["responsibilities"],
-            prompt_template=PHASE_1_BASE_PROMPT,
-            system_prompt=format_phase1_system_prompt(
-                agent_name=TECH_STACK_AGENT_PROMPT["name"],
-                agent_role=TECH_STACK_AGENT_PROMPT["role"],
-                responsibilities=TECH_STACK_AGENT_PROMPT["responsibilities"],
-            ),
         )
         self.initial_architects = [
             self.dependency_architect,
@@ -110,18 +91,45 @@ class Phase1Analysis:
                 role=RESEARCHER_AGENT_PROMPT["role"],
                 responsibilities=RESEARCHER_AGENT_PROMPT["responsibilities"],
                 prompt_template=PHASE_1_BASE_PROMPT,
-                system_prompt=format_phase1_system_prompt(
-                    agent_name=RESEARCHER_AGENT_PROMPT["name"],
-                    agent_role=RESEARCHER_AGENT_PROMPT["role"],
+                system_prompt=self._build_phase1_system_prompt(
+                    name=RESEARCHER_AGENT_PROMPT["name"],
+                    role=RESEARCHER_AGENT_PROMPT["role"],
                     responsibilities=RESEARCHER_AGENT_PROMPT["responsibilities"],
                 ),
             )
 
+    def _build_phase1_system_prompt(self, *, name: str, role: str, responsibilities: object) -> str:
+        return format_phase1_system_prompt(
+            agent_name=name,
+            agent_role=role,
+            responsibilities=responsibilities,
+        )
+
+    def _create_phase1_architect(self, *, name: str, role: str, responsibilities: object) -> Any:
+        normalized_responsibilities = normalize_responsibilities(responsibilities)
+        return get_architect_for_phase(
+            "phase1",
+            name=name,
+            role=role,
+            responsibilities=normalized_responsibilities,
+            prompt_template=PHASE_1_BASE_PROMPT,
+            system_prompt=self._build_phase1_system_prompt(
+                name=name,
+                role=role,
+                responsibilities=normalized_responsibilities,
+            ),
+        )
+
     # ----------------------------------------------------
     # Run Method
     # Executes the Initial Discovery phase.
     # ----------------------------------------------------
-    async def run(self, tree: list[str], package_info: dict) -> dict:
+    async def run(
+        self,
+        tree: list[str],
+        package_info: dict,
+        project_profile: dict[str, Any] | None = None,
+    ) -> dict:
         """
         Run the Initial Discovery Phase.
 
@@ -132,12 +140,15 @@ class Phase1Analysis:
         Returns:
             Dictionary containing the results of the phase
         """
+        profile_context = project_profile if isinstance(project_profile, dict) else {}
+
         logging.info("[bold]Phase 1, Part 1:[/bold] Starting dependency analysis")
 
         dependency_context = {
             "dependency_manifests": package_info.get("manifests", []),
             "dependency_summary": package_info.get("summary", {}),
             "researcher_expected": self.researcher_enabled,
+            "project_profile": profile_context,
         }
         dependency_result = await self.dependency_architect.analyze(dependency_context)
 
@@ -166,6 +177,7 @@ class Phase1Analysis:
                 "dependency_summary": package_info.get("summary", {}),
                 "dependency_manifests": package_info.get("manifests", []),
                 "tree_structure": tree,
+                "project_profile": profile_context,
             }
 
             if requires_external_research_tool_loop(self.researcher_architect):
@@ -188,6 +200,7 @@ class Phase1Analysis:
             "research_findings": research_findings.get("findings"),
             "research_agent_error": research_findings.get("error"),
             "research_status": research_findings.get("status"),
+            "project_profile": profile_context,
         }
         tech_stack_context = dict(structure_context)
 
@@ -205,14 +218,59 @@ class Phase1Analysis:
             tech_stack_result,
         ]
 
+        specialized_results = await self._run_specialized_profile_agents(
+            project_profile=profile_context,
+            base_context=structure_context,
+        )
+        if specialized_results:
+            initial_results.extend(specialized_results)
+
         # Return the combined results.
         return {
             "phase": "Initial Discovery",
             "initial_findings": initial_results,
             "documentation_research": research_findings,
             "package_info": package_info,
+            "project_profile": profile_context,
         }
 
+    async def _run_specialized_profile_agents(
+        self,
+        *,
+        project_profile: dict[str, Any],
+        base_context: dict[str, Any],
+    ) -> list[dict[str, Any]]:
+        """
+        Run optional specialized Phase 1 agents selected from profile signals.
+        """
+
+        prompt_configs = get_specialized_phase1_agent_prompts(project_profile)
+        if not prompt_configs:
+            return []
+
+        logging.info(
+            "[bold]Phase 1, Part 4:[/bold] Running %d profile-specialized discovery agent(s)",
+            len(prompt_configs),
+        )
+
+        tasks = []
+        for prompt_config in prompt_configs:
+            architect = self._create_phase1_architect(
+                name=str(prompt_config["name"]),
+                role=str(prompt_config["role"]),
+                responsibilities=prompt_config.get("responsibilities", []),
+            )
+            context = dict(base_context)
+            context["project_profile"] = project_profile
+            profile_key = prompt_config.get("profile_key")
+            if isinstance(profile_key, str):
+                context[f"{profile_key}_profile"] = project_profile.get(profile_key, {})
+            tasks.append(architect.analyze(context))
+
+        results = await asyncio.gather(*tasks)
+        logging.info("[bold green]Phase 1, Part 4:[/bold green] Specialized profile agents completed")
+        return [result for result in results if isinstance(result, dict)]
+
     async def _run_researcher_with_tools(
         self,
         research_context: dict[str, Any],

{agentrules-3.4.2 → agentrules-3.5.0}/src/agentrules/core/pipeline/__init__.py

@@ -11,6 +11,7 @@ from .config import (
 from .factory import create_default_pipeline
 from .orchestrator import AnalysisPipeline
 from .output import PipelineOutputOptions, PipelineOutputSummary, PipelineOutputWriter
+from .project_profile import build_project_profile
 from .snapshot import build_project_snapshot
 
 __all__ = [
@@ -24,6 +25,7 @@ __all__ = [
     "PipelineResult",
     "PipelineSettings",
     "ProjectSnapshot",
+    "build_project_profile",
     "create_default_pipeline",
     "build_project_snapshot",
 ]

{agentrules-3.4.2 → agentrules-3.5.0}/src/agentrules/core/pipeline/config.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from collections.abc import Mapping
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 
 from pathspec import PathSpec
@@ -48,6 +48,7 @@ class ProjectSnapshot:
     tree: tuple[str, ...]
     dependency_info: Mapping[str, object]
     gitignore: GitignoreSnapshot
+    project_profile: Mapping[str, object] = field(default_factory=dict)
 
 
 @dataclass(frozen=True)

{agentrules-3.4.2 → agentrules-3.5.0}/src/agentrules/core/pipeline/orchestrator.py

@@ -3,15 +3,10 @@
 from __future__ import annotations
 
 import time
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Protocol, runtime_checkable
 
-from agentrules.core.analysis import (
-    FinalAnalysis,
-    Phase1Analysis,
-    Phase2Analysis,
-    Phase3Analysis,
-    Phase4Analysis,
-    Phase5Analysis,
-)
 from agentrules.core.analysis.events import AnalysisEventSink
 from agentrules.core.pipeline.config import (
     PipelineMetrics,
@@ -21,18 +16,59 @@ from agentrules.core.pipeline.config import (
 )
 
 
+class Phase1Runner(Protocol):
+    async def run(
+        self,
+        tree: list[str],
+        package_info: dict,
+        project_profile: dict | None = None,
+        /,
+    ) -> dict: ...
+
+
+class Phase2Runner(Protocol):
+    async def run(self, phase1_results: dict, tree: Sequence[str] | None = None, /) -> dict: ...
+
+
+class Phase3Runner(Protocol):
+    async def run(self, phase2_results: dict, tree: list[str], directory: Path, /) -> dict: ...
+
+
+class Phase4Runner(Protocol):
+    async def run(self, phase3_results: dict, /) -> dict: ...
+
+
+class Phase5Runner(Protocol):
+    async def run(self, all_results: dict, /) -> dict: ...
+
+
+class FinalRunner(Protocol):
+    async def run(
+        self,
+        consolidated_report: dict,
+        project_structure: Sequence[str] | None = None,
+        /,
+        rules_filename: str | None = None,
+    ) -> dict: ...
+
+
+@runtime_checkable
+class SupportsEventSink(Protocol):
+    def set_event_sink(self, sink: AnalysisEventSink | None) -> None: ...
+
+
 class AnalysisPipeline:
     """Run the configured analysis phases and collect their outputs."""
 
     def __init__(
         self,
         *,
-        phase1: Phase1Analysis,
-        phase2: Phase2Analysis,
-        phase3: Phase3Analysis,
-        phase4: Phase4Analysis,
-        phase5: Phase5Analysis,
-        final: FinalAnalysis,
+        phase1: Phase1Runner,
+        phase2: Phase2Runner,
+        phase3: Phase3Runner,
+        phase4: Phase4Runner,
+        phase5: Phase5Runner,
+        final: FinalRunner,
         event_sink: AnalysisEventSink | None = None,
     ) -> None:
         self._phase1 = phase1
@@ -48,15 +84,16 @@ class AnalysisPipeline:
         """Attach an event sink to phases that emit progress notifications."""
 
         self._event_sink = sink
-        if hasattr(self._phase2, "set_event_sink"):
+        if isinstance(self._phase2, SupportsEventSink):
             self._phase2.set_event_sink(sink)
-        if hasattr(self._phase3, "set_event_sink"):
+        if isinstance(self._phase3, SupportsEventSink):
             self._phase3.set_event_sink(sink)
 
     async def run_phase1(self, snapshot: ProjectSnapshot) -> dict[str, object]:
         tree = list(snapshot.tree)
         dependency_info = dict(snapshot.dependency_info)
-        phase1_raw = await self._phase1.run(tree, dependency_info)
+        project_profile = dict(snapshot.project_profile)
+        phase1_raw = await self._phase1.run(tree, dependency_info, project_profile)
         return dict(phase1_raw)
 
     async def run_phase2(