Skip to content

The agent that grows with you

6.5 KB
Raw Blame
"""Every goal surface applies the same commands to real persisted state."""
import asyncio
import os
import queue
from types import SimpleNamespace

import pytest

from hermes_cli import goals


def _surface(surface, mgr, monkeypatch, prompts=None):
    prompts = prompts if prompts is not None else []
    if surface == "cli":
        from hermes_cli.cli_commands_mixin import CLICommandsMixin
        cli = object.__new__(CLICommandsMixin)
        cli._get_goal_manager = lambda: mgr
        cli._pending_input = queue.Queue()
        cli.conversation_history = []
        def execute(arg):
            cli._handle_goal_command('/goal ' + arg)
            while not cli._pending_input.empty():
                prompts.append(cli._pending_input.get_nowait())
        return execute
    if surface == "gateway":
        from gateway.run_busy import GatewayBusySessionMixin
        from gateway.slash_commands_goals import GatewayGoalCommandsMixin

        class Runner(GatewayBusySessionMixin, GatewayGoalCommandsMixin):
            pass

        runner = object.__new__(Runner)
        async def manager(event):
            return mgr, None
        async def execute(fn, *args):
            return fn(*args)
        runner._get_goal_manager_for_event = manager
        runner._run_in_executor_with_context = execute
        runner._adapter_and_key_for = lambda event: (None, None)
        runner._enqueue_goal_turn = lambda event, text, **kwargs: prompts.append(text)
        runner._resume_caller_is_admin = lambda source: True
        def execute(arg):
            event = SimpleNamespace(get_command_args=lambda: arg, source=None)
            if arg == 'show':
                return asyncio.run(runner._busy_goal_command(event, mgr.session_id, None))
            return asyncio.run(runner._handle_goal_command(event))
        return execute
    from tui_gateway import server
    server._sessions[mgr.session_id] = {'session_key': mgr.session_id}
    def execute(arg):
        result = server._methods['command.dispatch'](1, {
            'session_id': mgr.session_id, 'name': 'goal', 'arg': arg})
        if result.get('result', {}).get('type') == 'send':
            prompts.append(result['result']['message'])
        return result
    return execute


@pytest.mark.parametrize('surface', ['cli', 'gateway', 'tui'])
@pytest.mark.parametrize('command', [
    'show', 'draft', 'draft build it', 'drafting docs', 'wait', 'wait nope',
    'wait {pid} build', 'unwait', 'gate add true', 'gate remove 1',
    'gate clear', 'gate list', 'pause', 'resume', 'clear', 'stop', 'done',
    'build it\nverify: test passes', 'status', '',
])
def test_surface_goal_state_matches_cli(surface, command, monkeypatch):
    monkeypatch.setattr(goals, 'draft_contract', lambda objective: goals.GoalContract())
    goals._DB_CACHE.clear()
    command = command.format(pid=os.getpid())
    snapshots = []
    for name in ('cli', surface):
        mgr = goals.GoalManager(session_id=name + '-parity-' + surface)
        mgr.set('original objective')
        mgr.add_gate('original gate')
        mgr.wait_on(os.getpid(), reason='existing barrier')
        result = _surface(name, mgr, monkeypatch)(command)
        if name == 'gateway' and command == 'show':
            assert mgr.state.goal in result
        state = goals.load_goal(mgr.session_id)
        if state:
            from dataclasses import asdict
            state = asdict(state)
            for key in ('created_at', 'updated_at', 'waiting_since'):
                state.pop(key, None)
        snapshots.append(state)
    assert snapshots[0] == snapshots[1]


@pytest.mark.parametrize('surface', ['cli', 'gateway', 'tui'])
@pytest.mark.parametrize('draft_result', ['contract', 'unavailable', 'error'])
def test_drafts_start_work_but_inspection_and_literal_prefixes_do_not_draft(
    surface, draft_result, monkeypatch,
):
    calls = []
    def draft(objective):
        calls.append(objective)
        if draft_result == 'error':
            raise RuntimeError('aux offline')
        return goals.GoalContract(verification='tests pass') if draft_result == 'contract' else None
    monkeypatch.setattr(goals, 'draft_contract', draft)
    goals._DB_CACHE.clear()
    mgr = goals.GoalManager(session_id='draft-' + surface)
    prompts = []
    execute = _surface(surface, mgr, monkeypatch, prompts)
    execute('draft build it')
    state = goals.load_goal(mgr.session_id)
    assert state.goal == 'build it'
    assert state.has_contract() == (draft_result == 'contract')
    assert calls == ['build it']
    assert prompts == ['build it']
    execute('show')
    execute('draft')
    execute('wait invalid')
    assert goals.load_goal(mgr.session_id).goal == 'build it'
    assert prompts == ['build it']
    execute('drafting docs')
    assert goals.load_goal(mgr.session_id).goal == 'drafting docs'
    assert calls == ['build it']
    assert prompts[-1] == 'drafting docs'


def _dispatch(mgr, arg):
    from hermes_cli.goal_command import dispatch_goal_command
    return dispatch_goal_command(mgr, arg, authorize_gate=lambda: None)


@pytest.mark.parametrize('command, paused, status', [
    ('resume last goal', False, 'active'), ('continue the work', True, 'active'),
    ('pause for now', False, 'paused'), ('status please', False, 'active'),
])
def test_control_verb_with_trailing_words_never_replaces_the_goal(command, paused, status):
    goals._DB_CACHE.clear()
    mgr = goals.GoalManager(session_id='verb-wins-' + command.replace(' ', '-'))
    mgr.set('original objective')
    if paused:
        mgr.pause(reason='user-paused')
    from hermes_cli.goal_command import is_goal_control
    assert is_goal_control(command)  # gateway busy path dispatches instead of rejecting
    result = _dispatch(mgr, command)
    state = goals.load_goal(mgr.session_id)
    assert (state.goal, state.status) == ('original objective', status)
    assert f"(ignored {command.split(' ', 1)[1]!r}" in result.output



def test_double_dash_sets_control_word_goal_and_announces_the_replace():
    goals._DB_CACHE.clear()
    mgr = goals.GoalManager(session_id='verb-escape')
    mgr.set('original objective')
    result = _dispatch(mgr, '-- pause the nightly cron')
    assert goals.load_goal(mgr.session_id).goal == 'pause the nightly cron'
    assert 'was: original objective' in result.output
    mgr.clear()
    fresh = goals.GoalManager(session_id=mgr.session_id)  # gateway/TUI reload per command
    assert 'replaced' not in _dispatch(fresh, 'fresh objective').output
    _dispatch(fresh, '--dry-run the migration')
    assert goals.load_goal(mgr.session_id).goal == '--dry-run the migration'