dandy 2.2.0__tar.gz → 3.0.0a2__tar.gz

{dandy-2.2.0 → dandy-3.0.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dandy
-Version: 2.2.0
+Version: 3.0.0a2
 Summary: Python Artificial Intelligence Framework
 Author-email: Nathan Johnson <nathanj@stratusadv.com>
 License-Expression: MIT
@@ -20,30 +20,26 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
-Requires-Dist: blessed==1.29.0
-Requires-Dist: requests==2.32.5
-Requires-Dist: pydantic==2.12.5
-Requires-Dist: python-dotenv==1.2.1
+Requires-Dist: blessed==1.52.0
+Requires-Dist: requests==2.34.2
+Requires-Dist: pydantic==2.14.2
+Requires-Dist: python-dotenv==1.2.4
+Provides-Extra: documentation
+Requires-Dist: mkdocs; extra == "documentation"
+Requires-Dist: mkdocs-material; extra == "documentation"
+Requires-Dist: mkdocstrings[python]; extra == "documentation"
 Provides-Extra: development
 Requires-Dist: build; extra == "development"
 Requires-Dist: Faker; extra == "development"
+Requires-Dist: hypothesis; extra == "development"
+Requires-Dist: import-linter; extra == "development"
 Requires-Dist: pytest; extra == "development"
+Requires-Dist: pytest-cov; extra == "development"
 Requires-Dist: ruff; extra == "development"
 Requires-Dist: setuptools; extra == "development"
 Requires-Dist: twine; extra == "development"
 Requires-Dist: ty; extra == "development"
 Requires-Dist: wheel; extra == "development"
-Provides-Extra: documentation
-Requires-Dist: mkdocs; extra == "documentation"
-Requires-Dist: markdown-exec[ansi]; extra == "documentation"
-Requires-Dist: mkdocstrings-python; extra == "documentation"
-Requires-Dist: mkdocs-gen-files; extra == "documentation"
-Requires-Dist: mkdocs-include-markdown-plugin; extra == "documentation"
-Requires-Dist: mkdocs-literate-nav; extra == "documentation"
-Requires-Dist: mkdocs-material; extra == "documentation"
-Requires-Dist: mkdocs-section-index; extra == "documentation"
-Requires-Dist: mkdocs-table-reader-plugin; extra == "documentation"
-Requires-Dist: openpyxl; extra == "documentation"
 Dynamic: license-file
 
 <div align="center">
@@ -69,3 +65,32 @@ Start by installing with `pip install dandy` and then checking out our [quick st
 
 Check out the [Dandy Website](https://dandysoftware.com) for documentation including tutorials and more.
 
+### Command Line
+
+The `dandy` command runs the coding assistant against the current project. Run it from your project root (where `dandy_settings.py` lives). If no `dandy_settings.py` exists, dandy will instead load settings from a `dandy.json` file found in `.dandy/dandy.json` in the current directory, or `~/.config/dandy/dandy.json` as a last resort before creating a settings file for you.
+
+```bash
+dandy                          # start an interactive agentic loop
+dandy "fix the failing tests"  # run one request, then exit
+dandy -h                       # show usage
+```
+
+Inside the interactive session every message goes to the coding agent. `/clear` resets the conversation, and pressing `escape` twice (or `/quit`) exits the loop. Use the one-shot form when you only want a single answer without entering the REPL.
+
+The CLI's model is set with `CLI_CONFIG` in `dandy_settings.py`, e.g. `CLI_CONFIG = {'CODING': 'DEFAULT'}` points the coding agent at the `DEFAULT` entry in `LLM_CONFIGS`.
+
+The same settings can be expressed as JSON when you don't want a Python module. Keys are case-insensitive at the top level (`llm_configs` === `LLM_CONFIGS`), so a minimal `.dandy/dandy.json` looks like:
+
+```json
+{
+  "llm_configs": {
+    "default": {
+      "host": "api.example.com",
+      "api_key": "your-key",
+      "model": "your-model"
+    }
+  },
+  "cli_config": {"coding": "default"}
+}
+```
+

dandy-3.0.0a2/README.md

@@ -0,0 +1,52 @@
+<div align="center">
+    <a href="https://dandysoftware.com">
+        <img alt="Dandy Logo" src="https://dandysoftware.com/static/img/dandy_icon_128.png"/>
+    </a>
+</div>
+
+# Dandy
+
+![Build](https://img.shields.io/github/actions/workflow/status/stratusadv/dandy/run_tests.yml)
+![Python Versions](https://img.shields.io/pypi/pyversions/dandy)
+![PyPI Version](https://img.shields.io/pypi/v/dandy)
+![Downloads](https://img.shields.io/pypi/dm/dandy)
+
+A powerful open-source Python framework that simplifies the development of artificial intelligence software.
+
+### Get Started
+
+Start by installing with `pip install dandy` and then checking out our [quick start guide](https://dandysoftware.com/getting_started/quick_start/) for more steps.
+
+### Documentation
+
+Check out the [Dandy Website](https://dandysoftware.com) for documentation including tutorials and more.
+
+### Command Line
+
+The `dandy` command runs the coding assistant against the current project. Run it from your project root (where `dandy_settings.py` lives). If no `dandy_settings.py` exists, dandy will instead load settings from a `dandy.json` file found in `.dandy/dandy.json` in the current directory, or `~/.config/dandy/dandy.json` as a last resort before creating a settings file for you.
+
+```bash
+dandy                          # start an interactive agentic loop
+dandy "fix the failing tests"  # run one request, then exit
+dandy -h                       # show usage
+```
+
+Inside the interactive session every message goes to the coding agent. `/clear` resets the conversation, and pressing `escape` twice (or `/quit`) exits the loop. Use the one-shot form when you only want a single answer without entering the REPL.
+
+The CLI's model is set with `CLI_CONFIG` in `dandy_settings.py`, e.g. `CLI_CONFIG = {'CODING': 'DEFAULT'}` points the coding agent at the `DEFAULT` entry in `LLM_CONFIGS`.
+
+The same settings can be expressed as JSON when you don't want a Python module. Keys are case-insensitive at the top level (`llm_configs` === `LLM_CONFIGS`), so a minimal `.dandy/dandy.json` looks like:
+
+```json
+{
+  "llm_configs": {
+    "default": {
+      "host": "api.example.com",
+      "api_key": "your-key",
+      "model": "your-model"
+    }
+  },
+  "cli_config": {"coding": "default"}
+}
+```
+

dandy-3.0.0a2/dandy/__init__.py

@@ -0,0 +1,86 @@
+from dandy.application.agent.agent import Agent
+from dandy.application.bot.bot import Bot
+from dandy.application.decision.decision import Decision
+from dandy.infrastructure.cache.memory.cache import MemoryCache
+from dandy.infrastructure.cache.memory.decorators import cache_to_memory
+from dandy.infrastructure.cache.sqlite.cache import SqliteCache
+from dandy.infrastructure.cache.sqlite.decorators import cache_to_sqlite
+from dandy.infrastructure.cache.key import generate_cache_key
+from dandy.shared.exceptions import DandyCriticalError, DandyError, DandyRecoverableError
+from dandy.infrastructure.future.process import process_to_future
+from dandy.domain.intel.intel import BaseIntel, BaseListIntel, DefaultIntel
+from dandy.domain.message.message import MessageHistory
+from dandy.domain.prompt.prompt import Prompt
+from dandy.domain.request.options import LlmOptions
+from dandy.infrastructure.recorder.decorators import (
+    recorder_to_html_file,
+    recorder_to_json_file,
+    recorder_to_markdown_file,
+)
+from dandy.infrastructure.recorder.recorder import Recorder
+from dandy.domain.tool.tool import BaseTool
+from dandy.domain.skill.skill import BaseSkill
+
+__all__ = [
+    'Agent',
+    'BaseIntel',
+    'BaseListIntel',
+    'BaseSkill',
+    'BaseTool',
+    'Bot',
+    'Dandy',
+    'DandyCriticalError',
+    'DandyError',
+    'DandyRecoverableError',
+    'Decision',
+    'DefaultIntel',
+    'LlmOptions',
+    'MemoryCache',
+    'MessageHistory',
+    'Prompt',
+    'Recorder',
+    'SqliteCache',
+    'cache_to_memory',
+    'cache_to_sqlite',
+    'generate_cache_key',
+    'process_to_future',
+    'recorder_to_html_file',
+    'recorder_to_json_file',
+    'recorder_to_markdown_file',
+]
+
+
+class Dandy:
+    """The public Dandy API as a single namespace.
+
+    Every public object is reachable as an attribute of this class, and it is
+    the identical object the flat import gives (``Dandy.Bot`` is
+    ``dandy.Bot`` — nothing is wrapped or re-created). ``from dandy import
+    Dandy`` is a one-import entry point with full discoverability:
+    ``Dandy.<tab>`` lists the whole API.
+    """
+
+    Agent = Agent
+    BaseIntel = BaseIntel
+    BaseListIntel = BaseListIntel
+    BaseSkill = BaseSkill
+    BaseTool = BaseTool
+    Bot = Bot
+    DandyCriticalError = DandyCriticalError
+    DandyError = DandyError
+    DandyRecoverableError = DandyRecoverableError
+    Decision = Decision
+    DefaultIntel = DefaultIntel
+    LlmOptions = LlmOptions
+    MemoryCache = MemoryCache
+    MessageHistory = MessageHistory
+    Prompt = Prompt
+    Recorder = Recorder
+    SqliteCache = SqliteCache
+    cache_to_memory = cache_to_memory
+    cache_to_sqlite = cache_to_sqlite
+    generate_cache_key = generate_cache_key
+    process_to_future = process_to_future
+    recorder_to_html_file = recorder_to_html_file
+    recorder_to_json_file = recorder_to_json_file
+    recorder_to_markdown_file = recorder_to_markdown_file

dandy-3.0.0a2/dandy/application/agent/agent.py

@@ -0,0 +1,294 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+from pydantic import ValidationError
+
+from dandy.application.agent.exceptions import AgentCriticalError, AgentRecoverableError
+from dandy.application.agent.intel import AgentSession, AgentTurnIntel
+from dandy.application.agent.prompts import continuation_prompt
+from dandy.shared.cancellation import stop_signal
+from dandy.shared.exceptions import RUN_STOPPED_MESSAGE, RunStoppedError
+from dandy.domain.message.compaction import (
+    COMPACTION_TARGET_RATIO,
+    COMPACTION_TRIGGER_RATIO,
+    DEFAULT_CONTEXT_WINDOW,
+    compact_message_history,
+    drop_incomplete_tool_round,
+)
+from dandy.domain.message.message import MessageHistory
+from dandy.domain.prompt.prompt import Prompt
+from dandy.domain.skill.skill import to_skill_instances
+from dandy.domain.tokens.estimate import get_estimated_token_count_for_string
+from dandy.domain.tool.beat import StoryBeat
+
+if TYPE_CHECKING:
+    from dandy.application.bot.bot import Bot
+    from dandy.domain.intel.typing import IntelType
+    from dandy.domain.skill.skill import SkillType
+    from dandy.domain.tool.tool import ToolType
+
+# A turn is capped at this many tool rounds by default: a model that keeps
+# requesting tools without ever giving a final answer must not burn the API
+# budget indefinitely. Two hundred rounds covers a thorough
+# reproduce-then-fix-then-verify workflow while still bounding a model stuck
+# in a degenerate tool-call loop. Pass max_tool_rounds=None to a specific
+# Agent to disable the cap.
+AGENT_MAX_TOOL_ROUNDS_DEFAULT = 200
+
+
+class Agent:
+    """A stateful agent built around a Bot, designed to be looped.
+
+    A turn is one exchange: a message goes in, the agent works (possibly across
+    many tool rounds), and a final answer comes out; the conversation
+    accumulates in the agent's history. run drives turns until the agent's
+    result signals the request is done or the turn budget is exhausted.
+    """
+
+    def __init__(
+        self,
+        bot: Bot,
+        tools: list[ToolType] | None = None,
+        skills: list[SkillType] | None = None,
+        max_turns: int | None = None,
+        max_tool_rounds: int | None = AGENT_MAX_TOOL_ROUNDS_DEFAULT,
+        intel_class: type[IntelType] | None = None,
+    ) -> None:
+        self.bot = bot
+        self.tools = tools
+        self.skills = to_skill_instances(skills)
+        self.max_turns = max_turns
+        self.max_tool_rounds = max_tool_rounds
+        self.intel_class = intel_class or AgentTurnIntel
+        self.history = MessageHistory()
+        self.max_context_tokens = self._resolve_context_size()
+        self.last_request: str | None = None
+
+        if self.skills:
+            self.bot.llm.skills.register(self.skills)
+            self.bot.llm.append_system_prompt(self.bot.llm.skills.system_prompt_section())
+
+    def _resolve_context_size(self) -> int:
+        """The bot's LLM config ``CONTEXT_SIZE``, or a safe default."""
+        context_size = self.bot.llm.config.context_size
+        return context_size if context_size > 0 else DEFAULT_CONTEXT_WINDOW
+
+    def turn(
+        self,
+        message: Prompt | str | None = None,
+        progress_callback: Callable[[StoryBeat], None] | None = None,
+        verbose_callback: Callable[[str], None] | None = None,
+        tool_call_callback: Callable[[str, dict[str, object]], None] | None = None,
+    ) -> IntelType:
+        """Run one exchange: prepare, compact, work through any tool rounds, return the answer.
+
+        The conversation accumulates in ``self.history`` across turns. When
+        ``tool_call_callback`` is given, it is called once per executed tool
+        call with the tool name and its validated keyword arguments.
+        """
+        if stop_signal.is_set():
+            raise RunStoppedError(RUN_STOPPED_MESSAGE)
+
+        self.last_request = self._message_as_str(message)
+        message = self._prepare_message(message, progress_callback, verbose_callback)
+        self._compact_history_for_next_message(message, progress_callback)
+        self._ensure_history_fits(message)
+
+        return self.bot.llm.tools.prompt_to_intel(
+            prompt=message,
+            tools=self.tools,
+            intel_class=self.intel_class,
+            message_history=self.history,
+            replace_message_history=True,
+            progress_callback=progress_callback,
+            verbose_callback=verbose_callback,
+            tool_call_callback=tool_call_callback,
+            max_tool_iterations=self.max_tool_rounds,
+        )
+
+    def _prepare_message(
+        self,
+        message: Prompt | str | None,
+        _progress_callback: Callable[[StoryBeat], None] | None = None,
+        _verbose_callback: Callable[[str], None] | None = None,
+    ) -> Prompt | str | None:
+        """Subclass hook to shape the incoming message before it goes to the bot."""
+        return message
+
+    def _ensure_history_fits(self, message: Prompt | str | None) -> None:
+        """Fail clearly when compaction could not bring the conversation under the window.
+
+        Compaction drops everything it can drop and then gives up without
+        raising; when what remains still exceeds the whole context window no
+        valid request can be built, so callers see this instead of an opaque
+        provider 400.
+        """
+        total_token_count = self.history.estimated_token_count + self._incoming_token_count(message)
+
+        if total_token_count <= self.max_context_tokens:
+            return
+
+        error_message = (
+            f'The conversation ({self.history.estimated_token_count} tokens) plus your '
+            f'message still exceeds the {self.max_context_tokens} token context window '
+            'after dropping everything droppable. Clear the conversation and retry, '
+            'with a shorter message if possible.'
+        )
+        raise AgentRecoverableError(error_message)
+
+    def run(
+        self,
+        request: Prompt | str,
+        is_done: Callable[[IntelType], bool] | None = None,
+        progress_callback: Callable[[StoryBeat], None] | None = None,
+        verbose_callback: Callable[[str], None] | None = None,
+        tool_call_callback: Callable[[str, dict[str, object]], None] | None = None,
+    ) -> IntelType:
+        """Drive turns until the request is complete or the turn budget is exhausted.
+
+        The first turn receives the request; later turns receive a
+        continuation nudge. Completion comes from ``is_done(result)`` when
+        given, otherwise from a ``done`` field on the turn result.
+        """
+        if is_done is None and not self._has_done_field():
+            message = (
+                f'Agent.run cannot tell when the request is complete: '
+                f'{self.intel_class.__name__} has no `done` field and no `is_done` '
+                f'callback was given.'
+            )
+            raise AgentCriticalError(message)
+
+        result = self.turn(
+            request,
+            progress_callback=progress_callback,
+            verbose_callback=verbose_callback,
+            tool_call_callback=tool_call_callback,
+        )
+        turn_count = 1
+
+        while not self._is_done(result, is_done):
+            if stop_signal.is_set():
+                raise RunStoppedError(RUN_STOPPED_MESSAGE)
+
+            if self.max_turns is not None and turn_count >= self.max_turns:
+                message = (
+                    f'Agent gave up after {self.max_turns} turns without the request '
+                    f'being complete.'
+                )
+                raise AgentRecoverableError(message)
+
+            result = self.turn(
+                continuation_prompt(),
+                progress_callback=progress_callback,
+                verbose_callback=verbose_callback,
+                tool_call_callback=tool_call_callback,
+            )
+            turn_count += 1
+
+        return result
+
+    def clear(self) -> None:
+        """Reset the conversation history and the bot."""
+        self.history = MessageHistory()
+        self.last_request = None
+        self.bot.reset()
+
+    def save_session(self) -> AgentSession:
+        """Snapshot the conversation and LLM context for later loading.
+
+        A crash mid tool round can leave the history ending on a tool-call
+        declaration whose results never arrived; that round is invalid on
+        the wire, so it is dropped from the live history before the snapshot
+        and the next turn continues from a well-formed conversation.
+        """
+        drop_incomplete_tool_round(self.history)
+
+        return AgentSession(
+            messages=list(self.history.messages),
+            last_request=self.last_request,
+            model=self.bot.llm.config.model,
+            config=self.bot.llm.config.name,
+            token_count=self.history.estimated_token_count,
+        )
+
+    def load_session(self, session: AgentSession) -> None:
+        """Replace the conversation with a saved snapshot and reset the bot."""
+        self.history = MessageHistory(messages=list(session.messages))
+        self.last_request = session.last_request
+        self.bot.reset()
+
+    def save_session_json(self) -> str:
+        """The conversation snapshot as a JSON string for external storage."""
+        return self.save_session().model_dump_json()
+
+    def load_session_json(self, session_json: str) -> None:
+        """Replace the conversation with a snapshot from save_session_json."""
+        try:
+            session = AgentSession.model_validate_json(session_json)
+        except ValidationError:
+            message = 'The session JSON is not a valid agent session snapshot.'
+            raise AgentRecoverableError(message) from None
+
+        self.load_session(session)
+
+    def _has_done_field(self) -> bool:
+        return 'done' in getattr(self.intel_class, 'model_fields', {})
+
+    def _is_done(self, result: IntelType, is_done: Callable[[IntelType], bool] | None) -> bool:
+        if is_done is not None:
+            return bool(is_done(result))
+
+        return bool(getattr(result, 'done', False))
+
+    def _message_as_str(self, message: Prompt | str | None) -> str | None:
+        if message is None:
+            return None
+
+        if isinstance(message, Prompt):
+            return message.to_str()
+
+        return message
+
+    def _incoming_token_count(self, message: Prompt | str | None) -> int:
+        if message is None:
+            return 0
+
+        if isinstance(message, Prompt):
+            return message.estimated_token_count
+
+        return get_estimated_token_count_for_string(message)
+
+    def _compaction_target_token_count(self) -> int:
+        """A fraction of the max context, reserving headroom for output."""
+        return max(1, int(self.max_context_tokens * COMPACTION_TARGET_RATIO))
+
+    def _compaction_trigger_token_count(self) -> int:
+        """The higher fraction at which compaction kicks in, above the target."""
+        return max(
+            self._compaction_target_token_count() + 1,
+            int(self.max_context_tokens * COMPACTION_TRIGGER_RATIO),
+        )
+
+    def _compact_history_for_next_message(
+        self,
+        message: Prompt | str | None,
+        progress_callback: Callable[[StoryBeat], None] | None = None,
+    ) -> None:
+        incoming_token_count = self._incoming_token_count(message)
+        target_token_count = max(1, self._compaction_target_token_count() - incoming_token_count)
+        trigger_token_count = self._compaction_trigger_token_count() - incoming_token_count
+        current_token_count = self.history.estimated_token_count
+
+        if current_token_count <= trigger_token_count:
+            return
+
+        if progress_callback is not None:
+            progress_callback(
+                StoryBeat(
+                    description='Compacting my thoughts into a more manageable size',
+                    kind='compaction',
+                )
+            )
+
+        compact_message_history(history=self.history, max_context_tokens=target_token_count)

dandy-3.0.0a2/dandy/application/agent/cli/agents_md.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+
+from dandy.shared.files import file_exists, read_from_file
+from dandy.domain.prompt.prompt import Prompt
+
+
+def read_agents_md(agents_md_path: Path) -> str | None:
+    """The project's AGENTS.md content, or None when the file is missing or blank."""
+    if not file_exists(agents_md_path):
+        return None
+
+    agents_md = read_from_file(agents_md_path).strip()
+
+    return agents_md or None
+
+
+def agents_md_section(agents_md: str) -> Prompt:
+    """The AGENTS.md content as a Project Instructions section for agent guidelines."""
+    return (
+        Prompt()
+        .sub_heading('Project Instructions')
+        .text(
+            'The project provides the following instructions for AI coding agents. '
+            'Follow them whenever they apply to your work.'
+        )
+        .text(agents_md)
+    )

dandy-3.0.0a2/dandy/application/agent/cli/cli_agent.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Callable
+
+from dandy.application.agent.agent import AGENT_MAX_TOOL_ROUNDS_DEFAULT, Agent
+from dandy.application.agent.cli.agents_md import read_agents_md
+from dandy.application.agent.cli.intelligence.bots.coding_bot import CodingBot
+from dandy.application.agent.cli.intelligence.bots.init_bot import InitBot
+from dandy.application.agent.cli.intelligence.prompts import init_prompt
+from dandy.application.agent.session import session
+from dandy.application.agent.intelligence.tools import AGENT_TOOLS
+from dandy.application.agent.intelligence.tools.question import QuestionHandler, QuestionTool
+from dandy.domain.intel.intel import DefaultIntel
+from dandy.domain.message.message import MessageContent
+
+if TYPE_CHECKING:
+    from dandy.domain.tool.beat import StoryBeat
+
+
+class CliAgent(Agent):
+    """Multi-turn coding agent that keeps the conversation across turns."""
+
+    def __init__(self, ask_user: QuestionHandler | None = None) -> None:
+        super().__init__(
+            bot=CodingBot(),
+            tools=[*AGENT_TOOLS, QuestionTool(ask_user=ask_user)],
+            intel_class=DefaultIntel,
+        )
+
+    def reload_agents_md(self) -> str:
+        """Re-read the project AGENTS.md and sync it into the system prompt.
+
+        Rebuilds the bot's guidelines, the connector's system message, and the
+        running conversation's system message (when one exists), so a
+        regenerated AGENTS.md applies to the next turn without a /new.
+        Returns the refreshed system prompt text.
+        """
+        self.bot.guidelines = self.bot.build_guidelines()
+        system_prompt = self.bot.llm.rebuild_system_prompt()
+
+        if self.history.has_system_message:
+            self.history.messages[0].content = [MessageContent(type='text', text=system_prompt)]
+
+        return system_prompt
+
+    def run_init_pass(
+        self,
+        progress_callback: Callable[[StoryBeat], None] | None = None,
+        verbose_callback: Callable[[str], None] | None = None,
+    ) -> str | None:
+        """Run the AGENTS.md generation pass in a fresh InitBot conversation.
+
+        The bot explores the project and writes (or refreshes) AGENTS.md at
+        the project root, reading the existing file from the prompt when one
+        exists. On success the coding agent's system prompt is reloaded from
+        the file. Returns the bot's summary text, or None when the file was
+        not written.
+        """
+        init_bot = InitBot()
+
+        result_intel: DefaultIntel = init_bot.llm.tools.prompt_to_intel(
+            prompt=init_prompt(read_agents_md(session.agents_md_path)),
+            tools=AGENT_TOOLS,
+            intel_class=DefaultIntel,
+            progress_callback=progress_callback,
+            verbose_callback=verbose_callback,
+            max_tool_iterations=AGENT_MAX_TOOL_ROUNDS_DEFAULT,
+        )
+
+        if not session.agents_md_path.is_file():
+            return None
+
+        self.reload_agents_md()
+
+        return result_intel.text
+
+    def clear(self) -> None:
+        super().clear()

dandy-3.0.0a2/dandy/application/agent/cli/intelligence/bots/coding_bot.py

@@ -0,0 +1,35 @@
+from dandy.application.agent.cli.agents_md import agents_md_section, read_agents_md
+from dandy.application.agent.cli.intelligence.prompts import coding_guidelines_prompt
+from dandy.application.agent.session import session
+from dandy.application.agent.intelligence.tools import AGENT_TOOLS
+from dandy.application.bot.bot import Bot
+from dandy.shared.settings.load import get_cli_llm_config
+from dandy.domain.intel.intel import DefaultIntel
+from dandy.domain.prompt.prompt import Prompt
+
+
+class CodingBot(Bot):
+    role = 'Senior Software Engineer'
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.llm_config = get_cli_llm_config('CODING')
+        self.guidelines = self.build_guidelines()
+
+    def build_guidelines(self) -> Prompt:
+        guidelines = coding_guidelines_prompt()
+        agents_md = read_agents_md(session.agents_md_path)
+
+        if agents_md is not None:
+            guidelines = guidelines.prompt(agents_md_section(agents_md))
+
+        return guidelines
+
+    task = (
+        'Implement the user coding request by editing the project. '
+        'Use the available tools to explore and modify the code, '
+        'then give a short summary of what you changed and why.'
+    )
+
+    def process(self, user_input: Prompt | str) -> DefaultIntel:
+        return self.llm.tools.prompt_to_intel(prompt=user_input, tools=AGENT_TOOLS)

dandy-3.0.0a2/dandy/application/agent/cli/intelligence/bots/init_bot.py

@@ -0,0 +1,23 @@
+from dandy.application.agent.cli.intelligence.prompts import init_guidelines_prompt
+from dandy.application.agent.intelligence.tools import AGENT_TOOLS
+from dandy.application.bot.bot import Bot
+from dandy.shared.settings.load import get_cli_llm_config
+from dandy.domain.intel.intel import DefaultIntel
+from dandy.domain.prompt.prompt import Prompt
+
+
+class InitBot(Bot):
+    role = 'Project Documentation Engineer'
+
+    def __post_init__(self) -> None:
+        super().__post_init__()
+        self.llm_config = get_cli_llm_config('CODING')
+        self.guidelines = init_guidelines_prompt()
+
+    task = (
+        'Create or refresh the project AGENTS.md file: concise, factual guidance '
+        'for AI coding agents working in this repository.'
+    )
+
+    def process(self, user_input: Prompt | str) -> DefaultIntel:
+        return self.llm.tools.prompt_to_intel(prompt=user_input, tools=AGENT_TOOLS)