Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
from __future__ import annotations
import argparse
import contextlib
import io
import json
import re
import shlex
from pathlib import Path
import pytest
import pytest
from config import paths
from core.system_prompt_injection import build_system_prompt_injection
from modules.im.base import MessageContext
from storage.background import SQLiteBackgroundTaskStore
from vibe import cli
ROOT = Path(__file__).resolve().parents[1]
def _command_parser(path: tuple[str, ...]):
parser = cli.build_parser()
for segment in path:
subparsers = next(
action for action in parser._actions if isinstance(action, argparse._SubParsersAction)
)
parser = subparsers.choices[segment]
return parser
def _parser_flags(parser) -> set[str]:
return {flag for action in parser._actions for flag in action.option_strings}
def _iter_command_parsers(parser, path=()):
for action in parser._actions:
if not isinstance(action, argparse._SubParsersAction):
continue
for name, child in action.choices.items():
child_path = (*path, name)
yield child_path, child
yield from _iter_command_parsers(child, child_path)
def _prompt_command_parser(command: str):
tokens = shlex.split(command)
assert tokens[0] == "vibe"
parser = cli.build_parser()
path: list[str] = []
for token in tokens[1:]:
subparsers = next(
(
action
for action in parser._actions
if isinstance(action, argparse._SubParsersAction)
),
None,
)
if subparsers is None or token not in subparsers.choices:
break
parser = subparsers.choices[token]
path.append(token)
return parser, tuple(path)
def test_all_collection_commands_share_bounded_pagination_contract() -> None:
collection_commands = {
("agent", "list"),
("agent", "models"),
("bot", "list"),
("runs", "list"),
("session", "list"),
("session", "queue", "list"),
("vault", "list"),
("vault", "find"),
("vault", "tags"),
("show", "list"),
("show", "marks"),
("data", "query"),
("task", "list"),
("watch", "list"),
("model-requests", "list"),
}
fixed_page_commands = {("skill", "list")}
parser = cli.build_parser()
discovered_list_commands = {
path
for path, _ in _iter_command_parsers(parser)
if path[-1] == "list" and path[-1] != "ls"
}
assert discovered_list_commands <= collection_commands | fixed_page_commands
for path in collection_commands:
flags = _parser_flags(_command_parser(path))
assert "--page" in flags, path
assert "--limit" in flags, path
assert "--all" not in flags, path
for path in fixed_page_commands:
flags = _parser_flags(_command_parser(path))
assert "--page" in flags, path
assert "--limit" not in flags, path
assert "--all" not in flags, path
def test_injected_and_builtin_skill_commands_only_use_parser_supported_flags() -> None:
context = MessageContext(
user_id="user",
channel_id="channel",
platform="avibe",
platform_specific={"agent_session_id": "ses-test"},
)
prompt = build_system_prompt_injection(context=context)
guidance = [prompt] + [
(ROOT / "skills" / name / "SKILL.md").read_text()
for name in ("use-avibe", "use-avibe-harness", "use-avibe-vault", "use-show-pages")
]
commands = re.findall(r"`(vibe [^`\n]+)`", "\n".join(guidance))
checked_commands = 0
for command in commands:
mentioned_flags = set(re.findall(r"(?<![\w-])--[a-z][a-z0-9-]*", command))
if not mentioned_flags:
continue
parser, path = _prompt_command_parser(command)
unsupported_flags = mentioned_flags - _parser_flags(parser)
assert not unsupported_flags, (
f"Injected command {command!r} uses flags unsupported by "
f"{' '.join(('vibe', *path))}: {sorted(unsupported_flags)}"
)
checked_commands += 1
assert checked_commands >= 20
def test_session_examples_in_guidance_parse_against_the_cli() -> None:
"""Every `vibe session ...` call the prompt or a built-in Skill teaches must parse.
The flag check above cannot see a Session named positionally: `vibe session
get <id>` mentions no flag. The session group names its Session only with
`--session-id`, so an example that still passes it positionally fails here.
"""
context = MessageContext(
user_id="user",
channel_id="channel",
platform="avibe",
platform_specific={"agent_session_id": "ses-test"},
)
guidance = [build_system_prompt_injection(context=context)] + [
path.read_text() for path in sorted((ROOT / "skills").rglob("*.md"))
]
examples = sorted(set(re.findall(r"`(vibe session [^`\n]+)`", "\n".join(guidance))))
assert any("queue remove" in example for example in examples), examples
parser = cli.build_parser()
for example in examples:
argv = shlex.split(re.sub(r"<[^>]+>|\.\.\.", "x", example))[1:]
try:
parser.parse_args(argv)
except SystemExit as exc:
raise AssertionError(f"guidance teaches an unparseable session command: {example!r}") from exc
@pytest.mark.parametrize(
("argv", "expected_limit", "error_code"),
[
(["--limit", "500"], 100, None),
(["--limit", "100"], 100, None),
(["--limit", "0"], None, "invalid_pagination"),
(["--page", "0"], None, "invalid_pagination"),
],
)
def test_cli_limit_above_the_maximum_is_served_at_the_maximum(
monkeypatch, tmp_path, capsys, argv, expected_limit, error_code
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
args = cli.build_parser().parse_args(["session", "list", *argv])
result = cli.cmd_session_list(args)
captured = capsys.readouterr()
if error_code is None:
assert result == 0
assert json.loads(captured.out)["pagination"]["limit"] == expected_limit
else:
assert result == 1
assert json.loads(captured.err)["code"] == error_code
@pytest.mark.parametrize(
("argv", "accepted"),
[
(["task", "show", "t1", "--brief"], True),
(["watch", "show", "w1", "--brief"], True),
(["runs", "show", "r1", "--brief"], True),
(["session", "get", "--brief"], True),
(["agent", "show", "worker", "--brief"], True),
(["task", "list", "--brief"], False),
(["watch", "list", "--brief"], False),
(["runs", "list", "--brief"], False),
(["agent", "list", "--brief"], False),
],
)
def test_brief_selects_the_list_row_on_show_and_is_not_a_list_flag(argv, accepted) -> None:
"""``--brief`` means "print this record's list row"; a list is already rows."""
parser = cli.build_parser()
if accepted:
assert parser.parse_args(argv).brief is True
return
with pytest.raises(SystemExit), contextlib.redirect_stderr(io.StringIO()):
parser.parse_args(argv)
def test_runs_list_cli_defaults_to_first_page(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
try:
for index in range(25):
store.enqueue_run(
{
"id": f"run-{index:02d}",
"request_type": "agent_run",
"status": "succeeded",
"agent_name": "helper",
"agent_backend": "codex",
"session_id": "ses-alpha",
"message": f"message {index}",
"created_at": f"2026-05-25T00:{index:02d}:00+00:00",
"updated_at": f"2026-05-25T00:{index:02d}:00+00:00",
}
)
finally:
store.close()
args = cli.build_parser().parse_args(["runs", "list", "--global"])
assert cli.cmd_runs_list(args) == 0
payload = json.loads(capsys.readouterr().out)
assert payload["kind"] == "agent_runs"
assert len(payload["runs"]) == 20
assert payload["runs"][0]["id"] == "run-24"
assert payload["pagination"]["has_more"] is True
assert payload["pagination"]["next_command"] == "vibe runs list --global --page 2 --limit 20"
# The continuation is next_command alone: no prose repeats it.
assert "message" not in payload
def test_runs_list_cli_filters_status_and_query(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
try:
store.enqueue_run(
{
"id": "run-success",
"request_type": "agent_run",
"status": "succeeded",
"agent_name": "helper",
"agent_backend": "codex",
"session_id": "ses-alpha",
"message": "weekly report",
"created_at": "2026-05-25T00:00:00+00:00",
"updated_at": "2026-05-25T00:00:00+00:00",
}
)
store.enqueue_run(
{
"id": "run-failed",
"request_type": "agent_run",
"status": "failed",
"agent_name": "helper",
"agent_backend": "codex",
"session_id": "ses-alpha",
"message": "weekly report",
"created_at": "2026-05-25T00:01:00+00:00",
"updated_at": "2026-05-25T00:01:00+00:00",
}
)
finally:
store.close()
args = cli.build_parser().parse_args(["runs", "list", "--global", "--status", "succeeded", "--q", "weekly"])
assert cli.cmd_runs_list(args) == 0
payload = json.loads(capsys.readouterr().out)
assert [item["id"] for item in payload["runs"]] == ["run-success"]
assert payload["pagination"]["has_more"] is False
def test_runs_list_cli_normalizes_offset_time_filters(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
try:
store.enqueue_run(
{
"id": "run-before",
"request_type": "agent_run",
"status": "succeeded",
"created_at": "2026-05-25T01:59:59+00:00",
"updated_at": "2026-05-25T01:59:59+00:00",
}
)
store.enqueue_run(
{
"id": "run-after",
"request_type": "agent_run",
"status": "succeeded",
"created_at": "2026-05-25T02:00:00+00:00",
"updated_at": "2026-05-25T02:00:00+00:00",
}
)
finally:
store.close()
args = cli.build_parser().parse_args(["runs", "list", "--global", "--created-after", "2026-05-25T10:00:00+08:00"])
assert cli.cmd_runs_list(args) == 0
payload = json.loads(capsys.readouterr().out)
assert [item["id"] for item in payload["runs"]] == ["run-after"]
def test_runs_list_cli_next_command_uses_absolute_time_filters(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
try:
for index in range(25):
store.enqueue_run(
{
"id": f"run-{index:02d}",
"request_type": "agent_run",
"status": "succeeded",
"created_at": f"2026-05-25T00:{index:02d}:00+00:00",
"updated_at": f"2026-05-25T00:{index:02d}:00+00:00",
}
)
finally:
store.close()
args = cli.build_parser().parse_args(["runs", "list", "--global", "--created-after", "2026-05-25T08:00:00+08:00", "--limit", "10"])
assert cli.cmd_runs_list(args) == 0
payload = json.loads(capsys.readouterr().out)
assert "--created-after 2026-05-25T00:00:00+00:00" in payload["pagination"]["next_command"]
assert "--created-after 2026-05-25T08:00:00+08:00" not in payload["pagination"]["next_command"]
assert payload["pagination"]["next_command"].endswith("--page 2 --limit 10")
assert "message" not in payload["runs"][0]
def test_runs_show_defaults_to_caller_run(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
monkeypatch.setenv("AVIBE_SESSION_ID", "ses-alpha")
monkeypatch.setenv("AVIBE_RUN_ID", "run-current")
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
try:
store.enqueue_run(
{
"id": "run-current",
"request_type": "agent_run",
"status": "succeeded",
"agent_name": "helper",
"agent_backend": "codex",
"session_id": "ses-alpha",
"message": "current run",
"created_at": "2026-05-25T00:00:00+00:00",
"updated_at": "2026-05-25T00:00:00+00:00",
}
)
finally:
store.close()
args = cli.build_parser().parse_args(["runs", "show"])
assert cli.cmd_runs_show(args) == 0
payload = json.loads(capsys.readouterr().out)
assert payload["run"]["id"] == "run-current"
assert payload["run_default_notice"] == {
"code": "run_defaulted_to_caller",
"message": "Run defaulted to the caller Run from AVIBE_RUN_ID.",
"run_id": "run-current",
}
def test_runs_show_prints_the_run_text_once_and_brief_prints_the_list_row(monkeypatch, tmp_path, capsys) -> None:
"""#2425: a long delegation brief appears once, as `message`; `--brief` is the status row `runs list` prints."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
delegation_brief = "Review PR #1 and report every finding. " * 100
store = SQLiteBackgroundTaskStore()
try:
store.enqueue_run(
{
"id": "run-done",
"request_type": "agent_run",
"status": "succeeded",
"agent_name": "helper",
"agent_backend": "codex",
"session_id": "ses-alpha",
"message": delegation_brief,
"result_text": "No findings.",
"created_at": "2026-05-25T00:00:00+00:00",
"updated_at": "2026-05-25T00:00:00+00:00",
}
)
finally:
store.close()
assert cli.cmd_runs_show(cli.build_parser().parse_args(["runs", "show", "run-done"])) == 0
run = json.loads(capsys.readouterr().out)["run"]
assert "prompt" not in run
assert (run["message"], run["result_text"]) == (delegation_brief, "No findings.")
assert cli.cmd_runs_show(cli.build_parser().parse_args(["runs", "show", "run-done", "--brief"])) == 0
brief = json.loads(capsys.readouterr().out)["run"]
assert cli.cmd_runs_list(cli.build_parser().parse_args(["runs", "list", "--global"])) == 0
assert brief == json.loads(capsys.readouterr().out)["runs"][0]
assert (brief["status"], "message" in brief) == ("succeeded", False)
def test_runs_show_prints_each_fact_once_without_delivery_bookkeeping(monkeypatch, tmp_path, capsys) -> None:
"""The full record keeps what an Agent acts on and drops the reply's ledger and internals."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
provenance = {"turn_id": "trn_1", "run_id": "run-delegate", "detached": False}
store = SQLiteBackgroundTaskStore()
try:
store.enqueue_run(
{
"id": "run-delegate",
"request_type": "agent_run",
"status": "succeeded",
"agent_name": "helper",
"agent_id": "agent-internal-id",
"agent_backend": "codex",
"session_id": "ses-delegate",
"source_kind": "agent",
"source_actor": "ses-caller",
"message": "Review PR #1.",
"result_text": "No findings.",
"result_payload": {
"outputs": [
{"id": "msg_1", "text": "Reviewing now.", "provenance": provenance},
{"id": "terminal", "text": "No findings.", "provenance": provenance},
]
},
"message_ids": ["msg_1"],
"pid": 4242,
"created_at": "2026-05-25T00:00:00+00:00",
"completed_at": "2026-05-25T00:05:00+00:00",
"updated_at": "2026-05-25T00:05:00+00:00",
"metadata": {
"caller_context": {"session_id": "ses-caller", "channel_id": "ses-caller"},
"delivery_intent": "steer",
"delivery_outcome": {"intent": "steer", "status": "claimed"},
"last_activity_at": "2026-05-25T00:04:00+00:00",
"turn_id": "trn_1",
"close_after": True,
},
}
)
# A callback names the Session its result came from only in metadata.
store.enqueue_run(
{
"id": "run-callback",
"request_type": "agent_run",
"status": "queued",
"session_id": "ses-caller",
"source_kind": "callback",
"source_actor": "run-delegate",
"parent_run_id": "run-delegate",
"message": "No findings.",
"created_at": "2026-05-25T00:05:00+00:00",
"metadata": {"source_session_id": "ses-delegate", "callback_parent_run_id": "run-delegate"},
}
)
finally:
store.close()
assert cli.cmd_runs_show(cli.build_parser().parse_args(["runs", "show", "run-delegate"])) == 0
out = capsys.readouterr().out
run = json.loads(out)["run"]
assert out.count("No findings.") == 1
assert (run["result_text"], run["other_outputs"]) == ("No findings.", ["Reviewing now."])
assert run["source_session_id"] == "ses-caller"
assert run["last_activity_at"] == "2026-05-25T00:04:00+00:00"
assert run["metadata"] == {"close_after": True}
for omitted in (
"result_payload", "message_ids", "pid", "ok", "cancel_requested",
"agent_id", "updated_at", "source_actor",
):
assert omitted not in run
monkeypatch.setattr(cli, "_live_session_runtime_for_run", lambda run: None)
assert cli.cmd_runs_show(cli.build_parser().parse_args(["runs", "show", "run-callback"])) == 0
callback = json.loads(capsys.readouterr().out)["run"]
assert (callback["source_session_id"], callback["parent_run_id"]) == ("ses-delegate", "run-delegate")
assert "source_actor" not in callback and "metadata" not in callback
def test_runs_show_attaches_live_session_owner_for_queued_run(monkeypatch, tmp_path, capsys) -> None:
"""HFR-002: CLI diagnosis names the authoritative live Session owner."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
try:
store.enqueue_run(
{
"id": "run-queued",
"request_type": "agent_run",
"status": "queued",
"agent_name": "helper",
"agent_backend": "codex",
"session_id": "ses-alpha",
"message": "queued successor",
"created_at": "2026-07-18T04:31:27+00:00",
"updated_at": "2026-07-18T04:31:27+00:00",
}
)
finally:
store.close()
async def _turn_state(session_id):
assert session_id == "ses-alpha"
return {
"status_code": 200,
"body": {
"ok": True,
"session_id": session_id,
"in_flight": True,
"owner": {
"source": "agent_run",
"run_id": "run-owner",
"acquired_at": "2026-07-18T04:31:26+00:00",
"native_turn_started": True,
"backend_alive": True,
},
},
}
monkeypatch.setattr("vibe.internal_client.turn_state", _turn_state)
args = cli.build_parser().parse_args(["runs", "show", "run-queued"])
assert cli.cmd_runs_show(args) == 0
payload = json.loads(capsys.readouterr().out)
runtime = payload["run"]["session_runtime"]
assert runtime["available"] is True
assert runtime["owner"]["run_id"] == "run-owner"
assert runtime["owner"]["backend_alive"] is True
def test_runs_show_requires_run_without_caller(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
monkeypatch.delenv("AVIBE_SESSION_ID", raising=False)
monkeypatch.delenv("AVIBE_RUN_ID", raising=False)
paths.ensure_data_dirs()
args = cli.build_parser().parse_args(["runs", "show"])
assert cli.cmd_runs_show(args) == 1
payload = json.loads(capsys.readouterr().err)
assert payload["code"] == "missing_run_target"
assert payload["help_command"] == "vibe runs show --help"
def test_data_query_cli_runs_read_only_sql(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
try:
store.enqueue_run(
{
"id": "run-1",
"request_type": "agent_run",
"status": "succeeded",
"created_at": "2026-05-25T00:00:00+00:00",
"updated_at": "2026-05-25T00:00:00+00:00",
}
)
finally:
store.close()
args = cli.build_parser().parse_args(["data", "query", "--sql", "select id, status from agent_runs"])
assert cli.cmd_data_query(args) == 0
payload = json.loads(capsys.readouterr().out)
assert payload["kind"] == "data_query"
assert payload["columns"] == ["id", "status"]
assert payload["rows"] == [{"id": "run-1", "status": "succeeded"}]
def test_data_cache_cli_passes_filters_to_read_only_report(monkeypatch, capsys) -> None:
from core.handlers import cache_metrics
seen = {}
def fake_report(**kwargs):
seen.update(kwargs)
return {"since": "x", "until": "y", "routes": []}
monkeypatch.setattr(cache_metrics, "report", fake_report)
args = cli.build_parser().parse_args([
"data", "cache", "--since", "2026-10-01T00:00:00Z", "--until", "2026-10-02T00:00:00Z",
"--session-id", "ses-cache", "--model", "claude-test",
])
assert cli.cmd_data_cache(args) == 0
payload = json.loads(capsys.readouterr().out)
assert payload["kind"] == "data_cache"
assert payload["routes"] == []
assert seen["session_id"] == "ses-cache"
assert seen["model"] == "claude-test"
assert seen["since"].isoformat() == "2026-10-01T00:00:00+00:00"
assert seen["until"].isoformat() == "2026-10-02T00:00:00+00:00"
def test_data_query_cli_omits_next_command_for_stdin_sql(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
try:
for index in range(25):
store.enqueue_run(
{
"id": f"run-{index:02d}",
"request_type": "agent_run",
"status": "succeeded",
"created_at": f"2026-05-25T00:{index:02d}:00+00:00",
"updated_at": f"2026-05-25T00:{index:02d}:00+00:00",
}
)
finally:
store.close()
monkeypatch.setattr("sys.stdin", type("FakeStdin", (), {"read": lambda self: "select id from agent_runs order by id"})())
args = cli.build_parser().parse_args(["data", "query", "--sql-file", "-", "--limit", "10"])
assert cli.cmd_data_query(args) == 0
payload = json.loads(capsys.readouterr().out)
assert payload["pagination"]["has_more"] is True
assert "next_command" not in payload["pagination"]
assert payload["message"] == "More records are available. Add --page to continue."
def test_data_query_text_prints_records_with_values_verbatim_and_pages(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
SQLiteBackgroundTaskStore().close()
sql = (
"select 'Line one' || char(10) || 'He said \"hi\"' as body, null as gone, 7 as n "
"union all select 'second', '', 8 union all select 'third', 'x', 9"
)
args = cli.build_parser().parse_args(["data", "query", "--sql", sql, "--limit", "2", "--format", "text"])
assert cli.cmd_data_query(args) == 0
*records, next_line = capsys.readouterr().out.splitlines()
assert records == [
"-[ RECORD 1 ]",
"body:",
" Line one",
' He said "hi"',
"gone: (null)",
"n: 7",
"-[ RECORD 2 ]",
"body: second",
"gone:",
"n: 8",
]
label, next_command = next_line.split(": ", 1)
assert label == "next_command"
args = cli.build_parser().parse_args(shlex.split(next_command)[1:])
assert cli.cmd_data_query(args) == 0
assert capsys.readouterr().out.splitlines() == ["-[ RECORD 3 ]", "body: third", "gone: x", "n: 9"]
def test_data_query_cuts_long_values_and_says_how_to_read_them_whole(monkeypatch, tmp_path, capsys) -> None:
"""One message body can be hundreds of thousands of characters; a page of them must not fill a context."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
SQLiteBackgroundTaskStore().close()
sql = "select 'short' as a, printf('%.3000c', 'x') as b union all select 'two', 'y'"
args = cli.build_parser().parse_args(["data", "query", "--sql", sql])
assert cli.cmd_data_query(args) == 0
payload = json.loads(capsys.readouterr().out)
assert payload["rows"][0] == {"a": "short", "b": "x" * 2000 + "…[+1000 chars]"}
assert payload["rows"][1] == {"a": "two", "b": "y"}
assert payload["truncated_values"] == 1
assert "--max-chars 0" in payload["truncation"]
args = cli.build_parser().parse_args(["data", "query", "--sql", sql, "--max-chars", "0"])
assert cli.cmd_data_query(args) == 0
payload = json.loads(capsys.readouterr().out)
assert payload["rows"][0]["b"] == "x" * 3000
assert "truncated_values" not in payload
args = cli.build_parser().parse_args(
["data", "query", "--sql", sql, "--max-chars", "10", "--limit", "1", "--format", "text"]
)
assert cli.cmd_data_query(args) == 0
lines = capsys.readouterr().out.splitlines()
assert "b: xxxxxxxxxx…[+2990 chars]" in lines
assert lines[-2].startswith("1 value(s) cut at 10 characters")
# The next page is read the same way.
assert lines[-1].endswith("--format text --max-chars 10 --page 2 --limit 1")
@pytest.mark.parametrize(
("sql", "fragments"),
[
("select * from session", ["Did you mean sessions, agent_sessions", "Tables: ", "run_definitions"]),
("select * from watches", ["Did you mean run_definitions"]),
(
"select m.turn_id from messages m join agent_sessions s on s.id = m.session_id",
["No column 'turn_id' on messages.", "is a column of transcript, turns, agent_events", "messages columns: id,"],
),
(
"select content from agent_events",
["Did you mean content_text, content_json?", "agent_events columns: id,"],
),
],
)
def test_data_query_cli_explains_unknown_tables_and_columns(
monkeypatch, tmp_path, capsys, sql, fragments
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
SQLiteBackgroundTaskStore().close()
args = cli.build_parser().parse_args(["data", "query", "--sql", sql])
assert cli.cmd_data_query(args) == 1
payload = json.loads(capsys.readouterr().err)
assert payload["code"] == "query_failed"
for fragment in fragments:
assert fragment in payload["hint"]
def test_data_query_cli_rejects_writes(monkeypatch, tmp_path, capsys) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
paths.ensure_data_dirs()
store = SQLiteBackgroundTaskStore()
store.close()
args = cli.build_parser().parse_args(["data", "query", "--sql", "delete from agent_runs"])
assert cli.cmd_data_query(args) == 1
payload = json.loads(capsys.readouterr().err)
assert payload["ok"] is False
assert payload["help_command"] == "vibe data query --help"