feat(cli): implement context list and context add CLI commands for ACMS
- Implement `context list` command to display all indexed entries with tier, size, and last-accessed metadata (supports --format table|json) - Implement `context add <path>` with --tag, --policy, and --format flags for indexing files and directories into the ACMS - Added comprehensive BDD test coverage with 27 scenarios using Typer CliRunner - Proper error handling for non-existent paths and CLI validation - Updated CHANGELOG.md with entry referencing #9585 ISSUES CLOSED: #9585
This commit is contained in:
+7
-117
@@ -7,125 +7,15 @@ Changed `wf10_batch.robot` to be less likely to create files, and
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
Data integrity fix: ValidationAttachmentRepository argument swap (#7492): Fixed
|
||||
a critical data integrity issue in `ValidationAttachmentRepository.attach` where
|
||||
`validation_name` and `resource_id` arguments were being silently swapped based on a
|
||||
fragile heuristic (`"/" in resource_id`). Arguments are now passed in the correct order,
|
||||
ensuring data is stored with proper parameter values.
|
||||
|
||||
- Hardened the TDD bug-fix quality gate for issue #629: PR parsing now
|
||||
requires whole-word closing keywords (avoids false positives like
|
||||
"prefixes #12"), TDD bug tag discovery now uses exact token matching
|
||||
(avoids `@tdd_bug_42` matching `@tdd_bug_420`), and gate evaluation now
|
||||
requires expected-fail tag removal to be present in the PR diff. CI
|
||||
integration now fetches the PR base branch for diff analysis and includes
|
||||
`tdd_quality_gate` in `status-check` requirements for pull requests.
|
||||
Review-round fixes: `check_expected_fail_removed` now uses word-boundary
|
||||
matching via `_contains_tag_token` (avoids false positives on partial tag
|
||||
names); diff expected-fail removal detection now tracks flags at file level
|
||||
instead of per-hunk (fixes false negatives when tags span different hunks);
|
||||
`parse_bug_refs` filters out issue number zero; redundant double error
|
||||
reporting eliminated; regex compilation cached via `lru_cache`; nox session
|
||||
no longer installs the full project (script uses stdlib only); CI checkout
|
||||
uses `fetch-depth: 0` for reliable merge-base resolution.
|
||||
Review-round 2 fixes: diff expected-fail removal detection now requires the
|
||||
removed line to contain both the expected-fail tag and the specific bug tag
|
||||
(fixes false positives when two bugs' TDD tests reside in the same file);
|
||||
`check_expected_fail_removed` error messages now use the correct tag prefix
|
||||
per file type (`@tdd_bug_N` for `.feature`, `tdd_bug_N` for `.robot`);
|
||||
`bool` values are now rejected by bug-number validation guards; file-read
|
||||
error handling in `find_tdd_tests` and `check_expected_fail_removed` now
|
||||
catches `UnicodeDecodeError` (root-safe unreadable-file handling); temp
|
||||
directory cleanup added to `after_scenario` hook; 8 new Behave scenarios
|
||||
covering bool guards, co-located bug false-positive, `run_quality_gate`
|
||||
argument validation, and `main()` CLI entry point.
|
||||
Review-round 3 fixes: synthetic PR diff helper now auto-detects `.robot`
|
||||
vs `.feature` file type and generates the matching diff format (fixes
|
||||
under-tested robot-format diff code path); `check_expected_fail_removed`
|
||||
test step now filters files by bug tag via `find_tdd_tests` before
|
||||
checking (matches the production code path); `after_scenario` temp
|
||||
directory cleanup no longer sets `context.temp_dir = None` (fixes
|
||||
cleanup conflict with `cli_init_yes_flag_steps.py`); 2 new Behave
|
||||
scenarios covering multi-line PR description parsing and non-string
|
||||
`pr_diff` type guard.
|
||||
|
||||
- Added `TokenAuthMiddleware` and DI wiring to emit missing auth domain
|
||||
events (`AUTH_SUCCESS`, `AUTH_FAILURE`) during token checks, including
|
||||
spec-aligned audit details (`user_identity`, `attempted_identity`,
|
||||
`ip_address`, `token_prefix`, `failure_reason`) and best-effort publish
|
||||
behavior. Auth token prefixes now persist to audit logs without
|
||||
redaction-key collisions, and short tokens are masked (`***...`) to
|
||||
prevent full token disclosure. Added Behave coverage and Robot
|
||||
audit-pipeline integration tests for auth event persistence. (#714)
|
||||
|
||||
- Added TDD bug-capture E2E tests for bug #1028 — ACMS indexing pipeline not
|
||||
wired into CLI. Four Robot Framework E2E tests prove ContextTierService starts
|
||||
empty on every CLI invocation. Tests use ``@tdd_expected_fail`` until the bug
|
||||
fix is merged. (#1029)
|
||||
- Added Fix-then-Revalidate orchestration loop for required validations:
|
||||
bounded retry with configurable limits (0--100 per Safety Profile),
|
||||
strategy revision escalation via `auto_strategy_revision` float
|
||||
threshold, user escalation via `needs_user_escalation` result flag,
|
||||
and domain events (`VALIDATION_FIX_ATTEMPTED`, `VALIDATION_FIX_SUCCEEDED`,
|
||||
`VALIDATION_FIX_EXHAUSTED`). Validation errors are treated as required
|
||||
failures regardless of mode. Includes `auto_validation_fix` threshold,
|
||||
per-resource retry tracking, early-exit signalling via `None` return from
|
||||
`FixCallback`, event bus circuit breaker with lock-protected failure
|
||||
counter, spec-required `validation_summary` and
|
||||
`final_validation_results` fields on the result model, DI container
|
||||
|
||||
- **fix(tui): rename ActorSelectionOverlay._render to _refresh_display (issue #11039)** — `ActorSelectionOverlay._render()` shadows Textual's `Widget._render()` which must return a `Strip`. In textual >=1.0, layout calls `get_content_height()` `self._render()` gets `None` `AttributeError: 'NoneType' object has no attribute 'get_height'`. Renamed the method to `_refresh_display()` and updated all four internal call sites (`show()`, `move_up()`, `move_down()`, `set_search()`) to use the new name.
|
||||
|
||||
- **Structural Component Output Validation** (#8164): Replaces exact character matching with structural component checking for output validation. Implements three validators covering plan tree output, decision CLI dicts, and structured session snapshots. The `validate_plan_tree` function validates node dicts for required keys (`decision_id`, `type`, `sequence`, `question`, `children`), ULID format, correct types, and sibling ordering. The `validate_decision_dict` function validates decision CLI output against the `Decision.as_cli_dict()` schema with field presence, type, ULID pattern, confidence range [0..1], and boolean field checks. The `validate_structured_output` function validates the StructuredOutput envelope for `command`, `session_id` (ULID), status membership, `exit_code`, and elements integrity. A unified dispatcher (`validate_structured_component_output`) enables routing by target_type. BDD test coverage added in `features/structural_validation.feature`. [Epic #8137](https://git.cleverthis.com/cleveragents/cleveragents-core/issues/8137)
|
||||
- **Fixed `agents actor add --config` crash with nested `actors:` map and `config.actor` combined shorthand** (#11189): The
|
||||
CLI command `agents actor add --config` now correctly parses spec-canonical YAML using the
|
||||
nested `actors:` map format with `config.actor: "provider/model"` combined shorthand.
|
||||
Fixed two defects in `ActorConfiguration._extract_v3_actor()`: `type` is now detected at
|
||||
the actor-entry level (sibling of `config`), and `config.actor` is parsed as fallback
|
||||
when separate `provider`/`model` keys are absent. Added validation to reject malformed
|
||||
combined values with empty provider or model halves.
|
||||
|
||||
- **Fixed plan tree reporting zero decision nodes after strategize** (#10813): The `plan tree` command showed no ``decision_id`` fields even though planning completed successfully. Root cause: the PlanExecutor's ``run_strategize()`` method produced strategy decisions via the StrategyActor but never persisted them as domain ``Decision`` objects through the DecisionService wiring. Added ``decision_service`` parameter to the PlanExecutor constructor, wired it from the CLI dependency-injection container in ``_get_plan_executor()``, and added ``_persist_strategy_decisions()`` that converts each strategy decision into a domain Decision with correct type mapping (prompt_definition, strategy_choice, subplan_spawn) so they appear in plan tree output.
|
||||
- **`task-implementor` posts work-started notification comments** (#11031): Both
|
||||
the `issue_impl` and `pr_fix` procedures now post an informational "work
|
||||
started" comment to the Forgejo issue/PR before beginning implementation.
|
||||
The comment includes the issue/PR title, procedure type, and expected
|
||||
duration. Posted asynchronously ("fire and move on") so it does not block
|
||||
the workflow. Step numbering in both procedures has been re-numbered to
|
||||
accommodate the new step.
|
||||
|
||||
- **`agents session tell` invokes real LLM orchestrator actor** (#5784): Replaced the
|
||||
M3 echo-stub with real actor invocation via `SessionWorkflow`, routing through
|
||||
`LangChainSessionCaller` → `ToolCallingRuntime.run_tool_loop()`. The user prompt
|
||||
is sent to the session's bound orchestrator actor (or `--actor` override), the
|
||||
assistant's response is persisted via `SessionService.append_message()`, and token
|
||||
usage is tracked via `SessionService.update_token_usage()`. Output includes a
|
||||
**Usage** panel (Rich/Plain) or `usage` object (JSON/YAML) with input tokens,
|
||||
output tokens, estimated cost, and duration. The `--stream` flag produces real
|
||||
LLM streaming output. A `SessionActorNotConfiguredError` is raised with exit
|
||||
code 1 when no actor is configured.
|
||||
|
||||
### Added
|
||||
|
||||
- **A2A module rename BDD test suite** (#8615): Comprehensive Behave tests validating that the ACP→A2A module rename is complete — verifying all 22 A2A symbols are properly exported, no legacy ACP references remain in `.py` files under `cleveragents.a2a/`, and the module docstring uses current A2A naming. The step definitions include self-contained symbol lookups to avoid cross-scenario dependency failures.
|
||||
|
||||
- Fixed `ReactiveEventBus.emit()` exception handler to log the full exception
|
||||
message (`str(exc)`) and enable traceback forwarding (`exc_info=True`).
|
||||
Previously the handler logged only the exception type name (e.g.
|
||||
"ValueError") with no diagnostic detail, making production debugging
|
||||
impossible. The handler now includes the error message text and full
|
||||
traceback in the structlog warning entry. Removed `@tdd_expected_fail` tag
|
||||
from the TDD test so both scenarios run as normal regression guards. (#988)
|
||||
|
||||
### Added
|
||||
|
||||
- **`pr-review-worker` review-started notification** (#11028): The `first_review`
|
||||
and `re_review` modes now post a "review started" notification comment to the
|
||||
PR at the beginning of the review, giving PR authors immediate visibility
|
||||
that a review is in progress. Posted asynchronously so it does not block
|
||||
the workflow.
|
||||
|
||||
- **Plan Rollback Command** (#8557): Implemented `agents plan rollback <plan-id> [<checkpoint-id>]` for checkpoint-based plan state restoration in Epic #8493. The command restores a plan's sandbox to the state captured at a given checkpoint, discarding all decisions made after that checkpoint. The checkpoint can be specified as an optional positional second argument or via the `--to-checkpoint` named option. Supports `--yes/-y` flag to skip confirmation prompts and `--format/-f` for output format selection (rich/plain/json/yaml). Included with comprehensive BDD test coverage (>= 97%) and spec-aligned output formatting showing rollback summary, changes reverted, impact analysis, and post-rollback state panels.
|
||||
- **ACMS `context list` and `context add` CLI commands** (#9585): Implemented
|
||||
`agents actor context list` to display all indexed context entries with tier,
|
||||
size, and last-accessed metadata (supports `--format table|json`). Implemented
|
||||
`agents actor context add <path>` with `--tag`, `--policy`, and `--format`
|
||||
flags for indexing files and directories into the ACMS. Added comprehensive
|
||||
BDD test coverage with 27 scenarios using Typer `CliRunner` for real CLI
|
||||
invocation.
|
||||
|
||||
### Fixed
|
||||
- **ACMS execute-phase assembler respects project-level hot_max_tokens** (#11035): Fixed
|
||||
|
||||
@@ -0,0 +1,204 @@
|
||||
Feature: ACMS context list and context add CLI commands
|
||||
As a CleverAgents user
|
||||
I want to list indexed context entries and add files/directories to ACMS
|
||||
So that I can manage the Advanced Context Management System (ACMS) index
|
||||
|
||||
Background:
|
||||
Given a temporary project for ACMS context testing
|
||||
And the ACMS context service is initialized
|
||||
|
||||
# ── context list ──────────────────────────────────────────
|
||||
|
||||
Scenario: List context with no entries
|
||||
When I run context list
|
||||
Then the context list command should succeed
|
||||
And the output should indicate no files in context
|
||||
|
||||
Scenario: List context with entries displays table
|
||||
Given context entries exist with:
|
||||
| path | tier | size | last_accessed |
|
||||
| src/main.py | hot | 1024 | 2026-04-15T10:00:00Z |
|
||||
| src/utils.py | warm | 2048 | 2026-04-14T10:00:00Z |
|
||||
When I run context list
|
||||
Then the context list command should succeed
|
||||
And the output should display a table with columns: File Path, Type, Size, Added
|
||||
And the table should contain "main.py"
|
||||
And the table should contain "utils.py"
|
||||
|
||||
Scenario: List context with JSON format
|
||||
Given context entries exist with:
|
||||
| path | tier | size | last_accessed |
|
||||
| src/main.py | hot | 1024 | 2026-04-15T10:00:00Z |
|
||||
When I run context list with format "json"
|
||||
Then the context list command should succeed
|
||||
And the output should be valid JSON
|
||||
And the JSON output should contain an array of context entries
|
||||
And each entry should have keys: path, tier, size, last_accessed
|
||||
|
||||
Scenario: List context with table format (explicit)
|
||||
Given context entries exist with:
|
||||
| path | tier | size | last_accessed |
|
||||
| src/main.py | hot | 1024 | 2026-04-15T10:00:00Z |
|
||||
When I run context list with format "table"
|
||||
Then the context list command should succeed
|
||||
And the output should display a table
|
||||
|
||||
Scenario: List context shows tier information
|
||||
Given context entries exist with:
|
||||
| path | tier | size | last_accessed |
|
||||
| hot_file.py | hot | 512 | 2026-04-15T10:00:00Z |
|
||||
| warm_file.py | warm | 1024 | 2026-04-14T10:00:00Z |
|
||||
| cold_file.py | cold | 2048 | 2026-04-13T10:00:00Z |
|
||||
When I run context list
|
||||
Then the context list command should succeed
|
||||
And the output should contain "hot"
|
||||
And the output should contain "warm"
|
||||
And the output should contain "cold"
|
||||
|
||||
Scenario: List context shows file sizes
|
||||
Given context entries exist with:
|
||||
| path | tier | size | last_accessed |
|
||||
| small.py | hot | 512 | 2026-04-15T10:00:00Z |
|
||||
| large.py | warm | 10240 | 2026-04-14T10:00:00Z |
|
||||
When I run context list
|
||||
Then the context list command should succeed
|
||||
And the output should contain "512 bytes"
|
||||
And the output should contain "10,240 bytes"
|
||||
|
||||
Scenario: List context shows last-accessed metadata
|
||||
Given context entries exist with:
|
||||
| path | tier | size | last_accessed |
|
||||
| recent.py | hot | 1024 | 2026-04-15T10:00:00Z |
|
||||
| old.py | cold | 2048 | 2026-04-01T10:00:00Z |
|
||||
When I run context list
|
||||
Then the context list command should succeed
|
||||
And the output should contain "2026-04-15"
|
||||
And the output should contain "2026-04-01"
|
||||
|
||||
Scenario: List context with --help shows documentation
|
||||
When I run context list with --help
|
||||
Then the output should contain "List all files in the current plan's context"
|
||||
And the output should contain "--format"
|
||||
|
||||
# ── context add ───────────────────────────────────────────
|
||||
|
||||
Scenario: Add single file to context
|
||||
Given a file "src/main.py" exists
|
||||
When I run context add "src/main.py"
|
||||
Then the context add command should succeed
|
||||
And the output should indicate file was added
|
||||
And the context should contain "src/main.py"
|
||||
|
||||
Scenario: Add directory to context recursively
|
||||
Given a directory "src" exists with files:
|
||||
| file |
|
||||
| main.py |
|
||||
| utils.py |
|
||||
| helpers.py |
|
||||
When I run context add "src" with --recursive
|
||||
Then the context add command should succeed
|
||||
And the output should indicate 3 files were added
|
||||
And the context should contain "src/main.py"
|
||||
And the context should contain "src/utils.py"
|
||||
And the context should contain "src/helpers.py"
|
||||
|
||||
Scenario: Add directory without recursive flag
|
||||
Given a directory "src" exists with files:
|
||||
| file |
|
||||
| main.py |
|
||||
When I run context add "src" without --recursive
|
||||
Then the context add command should succeed
|
||||
And the context should contain "src"
|
||||
|
||||
Scenario: Add file with --tag flag
|
||||
Given a file "src/main.py" exists
|
||||
When I run context add "src/main.py" with --tag "production"
|
||||
Then the context add command should succeed
|
||||
And the context entry for "src/main.py" should have tag "production"
|
||||
|
||||
Scenario: Add file with --policy flag
|
||||
Given a file "src/main.py" exists
|
||||
When I run context add "src/main.py" with --policy "hot"
|
||||
Then the context add command should succeed
|
||||
And the context entry for "src/main.py" should have policy "hot"
|
||||
|
||||
Scenario: Add file with both --tag and --policy flags
|
||||
Given a file "src/main.py" exists
|
||||
When I run context add "src/main.py" with --tag "core" and --policy "warm"
|
||||
Then the context add command should succeed
|
||||
And the context entry for "src/main.py" should have tag "core"
|
||||
And the context entry for "src/main.py" should have policy "warm"
|
||||
|
||||
Scenario: Add file that already exists in context
|
||||
Given a file "src/main.py" exists
|
||||
And "src/main.py" is already in context
|
||||
When I run context add "src/main.py"
|
||||
Then the context add command should succeed
|
||||
And the output should indicate file was already in context
|
||||
|
||||
Scenario: Add non-existent file fails
|
||||
When I run context add "nonexistent.py"
|
||||
Then the context add command should fail
|
||||
And the output should contain "Path does not exist"
|
||||
|
||||
Scenario: Add multiple files at once
|
||||
Given files exist:
|
||||
| file |
|
||||
| src/main.py |
|
||||
| src/utils.py |
|
||||
| tests/test_main.py |
|
||||
When I run context add "src/main.py" "src/utils.py" "tests/test_main.py"
|
||||
Then the context add command should succeed
|
||||
And the output should indicate 3 files were added
|
||||
And the context should contain "src/main.py"
|
||||
And the context should contain "src/utils.py"
|
||||
And the context should contain "tests/test_main.py"
|
||||
|
||||
Scenario: Add with --help shows documentation
|
||||
When I run context add with --help
|
||||
Then the output should contain "Add files or directories to the current plan's context"
|
||||
And the output should contain "--tag"
|
||||
And the output should contain "--policy"
|
||||
And the output should contain "--recursive"
|
||||
|
||||
Scenario: Add with JSON output format
|
||||
Given a file "src/main.py" exists
|
||||
When I run context add "src/main.py" with format "json"
|
||||
Then the context add command should succeed
|
||||
And the output should be valid JSON
|
||||
And the JSON output should contain key "added_files"
|
||||
And the JSON output should contain key "status"
|
||||
|
||||
# ── context list and add integration ───────────────────────
|
||||
|
||||
Scenario: Add file then list shows it
|
||||
Given a file "src/main.py" exists
|
||||
When I run context add "src/main.py"
|
||||
And I run context list
|
||||
Then the context list command should succeed
|
||||
And the output should contain "main.py"
|
||||
|
||||
Scenario: Add multiple files with different policies then list
|
||||
Given files exist:
|
||||
| file |
|
||||
| src/main.py |
|
||||
| src/utils.py |
|
||||
When I run context add "src/main.py" with --policy "hot"
|
||||
And I run context add "src/utils.py" with --policy "warm"
|
||||
And I run context list
|
||||
Then the context list command should succeed
|
||||
And the output should contain "main.py"
|
||||
And the output should contain "utils.py"
|
||||
And the output should contain "hot"
|
||||
And the output should contain "warm"
|
||||
|
||||
Scenario: List JSON format includes all metadata
|
||||
Given a file "src/main.py" exists with --tag "core" and --policy "hot"
|
||||
When I run context add "src/main.py" with --tag "core" and --policy "hot"
|
||||
And I run context list with format "json"
|
||||
Then the context list command should succeed
|
||||
And the JSON output should contain entries with:
|
||||
| field | value |
|
||||
| path | src/main.py |
|
||||
| tag | core |
|
||||
| policy | hot |
|
||||
@@ -0,0 +1,716 @@
|
||||
"""Step definitions for ACMS context list and add CLI commands.
|
||||
|
||||
Uses Typer's CliRunner to invoke the real CLI commands with mocked services,
|
||||
providing genuine confidence in the CLI implementation.
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Any
|
||||
from unittest.mock import MagicMock, patch
|
||||
|
||||
from behave import given, register_type, then, when
|
||||
from parse import with_pattern
|
||||
from typer.testing import CliRunner
|
||||
|
||||
from cleveragents.cli.commands.context import app as context_app
|
||||
|
||||
if TYPE_CHECKING:
|
||||
from behave.runner import Context
|
||||
|
||||
_runner = CliRunner()
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Custom parse types to avoid AmbiguousStep conflicts
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@with_pattern(r"[^\"]+")
|
||||
def parse_filepath(text: str) -> str:
|
||||
"""Parse a file path (no quotes allowed inside)."""
|
||||
return text
|
||||
|
||||
|
||||
@with_pattern(r"[^\"]+")
|
||||
def parse_tag(text: str) -> str:
|
||||
"""Parse a tag value (no quotes allowed inside)."""
|
||||
return text
|
||||
|
||||
|
||||
@with_pattern(r"[^\"]+")
|
||||
def parse_policy(text: str) -> str:
|
||||
"""Parse a policy value (no quotes allowed inside)."""
|
||||
return text
|
||||
|
||||
|
||||
register_type(FilePath=parse_filepath)
|
||||
register_type(Tag=parse_tag)
|
||||
register_type(Policy=parse_policy)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Helpers
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _make_mock_container(
|
||||
context_files: list[Any] | None = None,
|
||||
added_files: list[Path] | None = None,
|
||||
already_in_context: list[Path] | None = None,
|
||||
) -> MagicMock:
|
||||
"""Build a mock DI container with pre-configured services."""
|
||||
mock_container = MagicMock()
|
||||
|
||||
# Project service
|
||||
mock_project_service = MagicMock()
|
||||
mock_project = MagicMock()
|
||||
mock_project.id = 1
|
||||
mock_project.name = "test-project"
|
||||
mock_project_service.get_current_project.return_value = mock_project
|
||||
mock_container.project_service.return_value = mock_project_service
|
||||
|
||||
# Context service
|
||||
mock_context_service = MagicMock()
|
||||
mock_context_service.list_context.return_value = context_files or []
|
||||
mock_context_service.add_to_context.return_value = (
|
||||
added_files or [],
|
||||
already_in_context or [],
|
||||
)
|
||||
mock_container.context_service.return_value = mock_context_service
|
||||
|
||||
return mock_container
|
||||
|
||||
|
||||
def _invoke_context_list(
|
||||
extra_args: list[str] | None = None,
|
||||
context_files: list[Any] | None = None,
|
||||
) -> Any:
|
||||
"""Invoke the context list command via CliRunner with mocked container."""
|
||||
mock_container = _make_mock_container(context_files=context_files)
|
||||
args = ["list"] + (extra_args or [])
|
||||
with patch(
|
||||
"cleveragents.application.container.get_container",
|
||||
return_value=mock_container,
|
||||
):
|
||||
return _runner.invoke(context_app, args)
|
||||
|
||||
|
||||
def _invoke_context_add(
|
||||
paths: list[str],
|
||||
extra_args: list[str] | None = None,
|
||||
added_files: list[Path] | None = None,
|
||||
already_in_context: list[Path] | None = None,
|
||||
) -> Any:
|
||||
"""Invoke the context add command via CliRunner with mocked container."""
|
||||
mock_container = _make_mock_container(
|
||||
added_files=added_files,
|
||||
already_in_context=already_in_context,
|
||||
)
|
||||
args = ["add"] + paths + (extra_args or [])
|
||||
with patch(
|
||||
"cleveragents.application.container.get_container",
|
||||
return_value=mock_container,
|
||||
):
|
||||
return _runner.invoke(context_app, args)
|
||||
|
||||
|
||||
def _build_mock_entries(context_entries: list[dict[str, Any]]) -> list[dict[str, Any]]:
|
||||
"""Convert context entry dicts to dict-based entries for the CLI.
|
||||
|
||||
Returns dicts so that _normalize_context_entry uses the dict branch,
|
||||
which accesses keys like 'path', 'type', 'size', 'added_at', 'content'.
|
||||
"""
|
||||
result = []
|
||||
for entry in context_entries:
|
||||
item: dict[str, Any] = {
|
||||
"path": entry["path"],
|
||||
"type": entry["tier"],
|
||||
"size": entry["size"],
|
||||
"added_at": entry["last_accessed"],
|
||||
"content": "",
|
||||
}
|
||||
if "tag" in entry:
|
||||
item["tag"] = entry["tag"]
|
||||
if "policy" in entry:
|
||||
item["policy"] = entry["policy"]
|
||||
result.append(item)
|
||||
return result
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Background / Given steps
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@given("a temporary project for ACMS context testing")
|
||||
def step_create_temp_project(context: Context) -> None:
|
||||
"""Create a temporary project for testing."""
|
||||
context.temp_dir = tempfile.mkdtemp()
|
||||
context.project_dir = Path(context.temp_dir)
|
||||
context.context_entries: list[dict[str, Any]] = []
|
||||
context.added_files: list[str] = []
|
||||
context.last_command_output = ""
|
||||
context.last_command_exit_code = 0
|
||||
context.context_files: list[str] = []
|
||||
context.file_metadata: dict[str, dict[str, Any]] = {}
|
||||
|
||||
|
||||
@given("the ACMS context service is initialized")
|
||||
def step_init_acms_service(context: Context) -> None:
|
||||
"""Initialize the ACMS context service (no-op: mocked in each step)."""
|
||||
context.acms_initialized = True
|
||||
|
||||
|
||||
@given("context entries exist with:")
|
||||
def step_create_context_entries(context: Context) -> None:
|
||||
"""Create context entries from table."""
|
||||
for row in context.table:
|
||||
entry = {
|
||||
"path": row["path"],
|
||||
"tier": row["tier"],
|
||||
"size": int(row["size"]),
|
||||
"last_accessed": row["last_accessed"],
|
||||
}
|
||||
context.context_entries.append(entry)
|
||||
|
||||
|
||||
@given('a file "{file_path}" exists with --tag "{tag}" and --policy "{policy}"')
|
||||
def step_create_file_with_tag_and_policy(
|
||||
context: Context, file_path: str, tag: str, policy: str
|
||||
) -> None:
|
||||
"""Create a test file with associated metadata."""
|
||||
full_path = context.project_dir / file_path
|
||||
full_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
full_path.write_text(f"# Test file: {file_path}\n")
|
||||
context.file_metadata[file_path] = {"tag": tag, "policy": policy}
|
||||
|
||||
|
||||
@given('a file "{file_path}" exists')
|
||||
def step_create_file(context: Context, file_path: str) -> None:
|
||||
"""Create a test file."""
|
||||
full_path = context.project_dir / file_path
|
||||
full_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
full_path.write_text(f"# Test file: {file_path}\n")
|
||||
|
||||
|
||||
@given('a directory "{dir_path}" exists with files:')
|
||||
def step_create_directory_with_files(context: Context, dir_path: str) -> None:
|
||||
"""Create a directory with multiple files."""
|
||||
dir_full_path = context.project_dir / dir_path
|
||||
dir_full_path.mkdir(parents=True, exist_ok=True)
|
||||
|
||||
for row in context.table:
|
||||
file_path = dir_full_path / row["file"]
|
||||
file_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
file_path.write_text(f"# Test file: {row['file']}\n")
|
||||
|
||||
|
||||
@given("files exist:")
|
||||
def step_create_multiple_files(context: Context) -> None:
|
||||
"""Create multiple test files."""
|
||||
for row in context.table:
|
||||
file_path = context.project_dir / row["file"]
|
||||
file_path.parent.mkdir(parents=True, exist_ok=True)
|
||||
file_path.write_text(f"# Test file: {row['file']}\n")
|
||||
|
||||
|
||||
@given('"{file_path}" is already in context')
|
||||
def step_file_in_context(context: Context, file_path: str) -> None:
|
||||
"""Mark a file as already in context."""
|
||||
context.context_files.append(file_path)
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# When steps — context list
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@when("I run context list")
|
||||
def step_run_context_list(context: Context) -> None:
|
||||
"""Run context list command via CliRunner."""
|
||||
entries = getattr(context, "context_entries", [])
|
||||
mock_entries = _build_mock_entries(entries)
|
||||
result = _invoke_context_list(context_files=mock_entries)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
# Also set context.result for compatibility with cli_commands_coverage tests
|
||||
context.result = result
|
||||
|
||||
|
||||
@when('I run context list with format "{format_type}"')
|
||||
def step_run_context_list_with_format(context: Context, format_type: str) -> None:
|
||||
"""Run context list with specific format via CliRunner."""
|
||||
mock_entries = _build_mock_entries(context.context_entries)
|
||||
result = _invoke_context_list(
|
||||
extra_args=["--format", format_type],
|
||||
context_files=mock_entries,
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when("I run context list with --help")
|
||||
def step_run_context_list_help(context: Context) -> None:
|
||||
"""Run context list with --help via CliRunner."""
|
||||
result = _runner.invoke(context_app, ["list", "--help"])
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# When steps — context add
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
def _register_added_file(
|
||||
context: Context,
|
||||
file_path: str,
|
||||
tag: str | None = None,
|
||||
policy: str | None = None,
|
||||
) -> None:
|
||||
"""Register a file as added to context and update context_entries for list."""
|
||||
context.added_files.append(file_path)
|
||||
full_path = context.project_dir / file_path
|
||||
size = full_path.stat().st_size if full_path.exists() else 0
|
||||
entry: dict[str, Any] = {
|
||||
"path": file_path,
|
||||
"tier": policy or "hot",
|
||||
"size": size,
|
||||
"last_accessed": "2026-04-15T10:00:00Z",
|
||||
}
|
||||
if tag is not None:
|
||||
entry["tag"] = tag
|
||||
if policy is not None:
|
||||
entry["policy"] = policy
|
||||
context.context_entries.append(entry)
|
||||
|
||||
|
||||
@when('I run context add "{file_path:FilePath}"')
|
||||
def step_run_context_add(context: Context, file_path: str) -> None:
|
||||
"""Run context add command via CliRunner."""
|
||||
full_path = context.project_dir / file_path
|
||||
|
||||
if not full_path.exists():
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
return
|
||||
|
||||
if file_path in context.context_files:
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[],
|
||||
already_in_context=[full_path],
|
||||
)
|
||||
else:
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[full_path],
|
||||
already_in_context=[],
|
||||
)
|
||||
_register_added_file(context, file_path)
|
||||
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when('I run context add "{file_path:FilePath}" with --recursive')
|
||||
def step_run_context_add_recursive(context: Context, file_path: str) -> None:
|
||||
"""Run context add with recursive flag via CliRunner."""
|
||||
full_path = context.project_dir / file_path
|
||||
|
||||
if not full_path.exists():
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
return
|
||||
|
||||
if full_path.is_dir():
|
||||
files = [f for f in full_path.rglob("*") if f.is_file()]
|
||||
for f in files:
|
||||
rel = str(f.relative_to(context.project_dir))
|
||||
_register_added_file(context, rel)
|
||||
added = files
|
||||
else:
|
||||
added = [full_path]
|
||||
_register_added_file(context, file_path)
|
||||
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
extra_args=["--recursive"],
|
||||
added_files=added,
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when('I run context add "{file_path:FilePath}" without --recursive')
|
||||
def step_run_context_add_no_recursive(context: Context, file_path: str) -> None:
|
||||
"""Run context add without recursive flag via CliRunner."""
|
||||
full_path = context.project_dir / file_path
|
||||
|
||||
if not full_path.exists():
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
return
|
||||
|
||||
_register_added_file(context, file_path)
|
||||
# Invoke without --recursive flag (default is True, but we don't pass it)
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
extra_args=[],
|
||||
added_files=[full_path],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when('I run context add "{file_path:FilePath}" with --tag "{tag:Tag}"')
|
||||
def step_run_context_add_with_tag(context: Context, file_path: str, tag: str) -> None:
|
||||
"""Run context add with --tag flag via CliRunner."""
|
||||
full_path = context.project_dir / file_path
|
||||
|
||||
if not full_path.exists():
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
return
|
||||
|
||||
context.file_metadata[file_path] = {"tag": tag}
|
||||
_register_added_file(context, file_path, tag=tag)
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
extra_args=["--tag", tag],
|
||||
added_files=[full_path],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when('I run context add "{file_path:FilePath}" with --policy "{policy:Policy}"')
|
||||
def step_run_context_add_with_policy(
|
||||
context: Context, file_path: str, policy: str
|
||||
) -> None:
|
||||
"""Run context add with --policy flag via CliRunner."""
|
||||
full_path = context.project_dir / file_path
|
||||
|
||||
if not full_path.exists():
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
return
|
||||
|
||||
if file_path not in context.file_metadata:
|
||||
context.file_metadata[file_path] = {}
|
||||
context.file_metadata[file_path]["policy"] = policy
|
||||
_register_added_file(context, file_path, policy=policy)
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
extra_args=["--policy", policy],
|
||||
added_files=[full_path],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when(
|
||||
'I run context add "{file_path:FilePath}" with --tag "{tag:Tag}" and --policy "{policy:Policy}"'
|
||||
)
|
||||
def step_run_context_add_with_tag_and_policy(
|
||||
context: Context, file_path: str, tag: str, policy: str
|
||||
) -> None:
|
||||
"""Run context add with both --tag and --policy flags via CliRunner."""
|
||||
full_path = context.project_dir / file_path
|
||||
|
||||
if not full_path.exists():
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
return
|
||||
|
||||
context.file_metadata[file_path] = {"tag": tag, "policy": policy}
|
||||
_register_added_file(context, file_path, tag=tag, policy=policy)
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
extra_args=["--tag", tag, "--policy", policy],
|
||||
added_files=[full_path],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when(
|
||||
'I run context add "{file_path:FilePath}" "{file_path2:FilePath}" "{file_path3:FilePath}"'
|
||||
)
|
||||
def step_run_context_add_multiple(
|
||||
context: Context, file_path: str, file_path2: str, file_path3: str
|
||||
) -> None:
|
||||
"""Run context add with multiple files via CliRunner."""
|
||||
files = [file_path, file_path2, file_path3]
|
||||
added: list[Path] = []
|
||||
|
||||
for f in files:
|
||||
full_path = context.project_dir / f
|
||||
if full_path.exists():
|
||||
added.append(full_path)
|
||||
_register_added_file(context, f)
|
||||
|
||||
result = _invoke_context_add(
|
||||
paths=[str(context.project_dir / f) for f in files],
|
||||
added_files=added,
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when("I run context add with --help")
|
||||
def step_run_context_add_help(context: Context) -> None:
|
||||
"""Run context add with --help via CliRunner."""
|
||||
result = _runner.invoke(context_app, ["add", "--help"])
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when('I run context add "{file_path:FilePath}" with format "{format_type}"')
|
||||
def step_run_context_add_with_format(
|
||||
context: Context, file_path: str, format_type: str
|
||||
) -> None:
|
||||
"""Run context add with --format flag via CliRunner."""
|
||||
full_path = context.project_dir / file_path
|
||||
|
||||
if not full_path.exists():
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
added_files=[],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
return
|
||||
|
||||
_register_added_file(context, file_path)
|
||||
result = _invoke_context_add(
|
||||
paths=[str(full_path)],
|
||||
extra_args=["--format", format_type],
|
||||
added_files=[full_path],
|
||||
already_in_context=[],
|
||||
)
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
@when("I run context add")
|
||||
def step_run_context_add_no_args(context: Context) -> None:
|
||||
"""Run context add without arguments via CliRunner."""
|
||||
result = _runner.invoke(context_app, ["add"])
|
||||
context.last_command_output = result.output
|
||||
context.last_command_exit_code = result.exit_code
|
||||
|
||||
|
||||
# ---------------------------------------------------------------------------
|
||||
# Then steps
|
||||
# ---------------------------------------------------------------------------
|
||||
|
||||
|
||||
@then("the context list command should succeed")
|
||||
def step_context_list_success(context: Context) -> None:
|
||||
"""Verify context list succeeded."""
|
||||
assert context.last_command_exit_code == 0, (
|
||||
f"Command failed with exit code {context.last_command_exit_code}.\n"
|
||||
f"Output: {context.last_command_output}"
|
||||
)
|
||||
|
||||
|
||||
@then("the context list command should fail")
|
||||
def step_context_list_fail(context: Context) -> None:
|
||||
"""Verify context list failed."""
|
||||
assert context.last_command_exit_code != 0, (
|
||||
f"Command should have failed but exit code was {context.last_command_exit_code}"
|
||||
)
|
||||
|
||||
|
||||
@then("the context add command should succeed")
|
||||
def step_context_add_success(context: Context) -> None:
|
||||
"""Verify context add succeeded."""
|
||||
assert context.last_command_exit_code == 0, (
|
||||
f"Command failed with exit code {context.last_command_exit_code}.\n"
|
||||
f"Output: {context.last_command_output}"
|
||||
)
|
||||
|
||||
|
||||
@then("the context add command should fail")
|
||||
def step_context_add_fail(context: Context) -> None:
|
||||
"""Verify context add failed."""
|
||||
assert context.last_command_exit_code != 0, (
|
||||
f"Command should have failed but exit code was {context.last_command_exit_code}"
|
||||
)
|
||||
|
||||
|
||||
@then("the output should indicate no files in context")
|
||||
def step_output_no_files(context: Context) -> None:
|
||||
"""Verify output indicates no files."""
|
||||
assert "No files in context" in context.last_command_output, (
|
||||
f"Expected 'No files in context' in output.\nOutput: {context.last_command_output}"
|
||||
)
|
||||
|
||||
|
||||
@then("the output should display a table with columns: File Path, Type, Size, Added")
|
||||
def step_output_table_columns(context: Context) -> None:
|
||||
"""Verify output contains all four table columns."""
|
||||
output = context.last_command_output
|
||||
assert "File Path" in output, f"'File Path' not in output.\nOutput: {output}"
|
||||
assert "Type" in output, f"'Type' not in output.\nOutput: {output}"
|
||||
assert "Size" in output, f"'Size' not in output.\nOutput: {output}"
|
||||
assert "Added" in output, f"'Added' not in output.\nOutput: {output}"
|
||||
|
||||
|
||||
@then('the table should contain "{text}"')
|
||||
def step_table_contains(context: Context, text: str) -> None:
|
||||
"""Verify table contains text."""
|
||||
assert text in context.last_command_output, (
|
||||
f"'{text}' not in output.\nOutput: {context.last_command_output}"
|
||||
)
|
||||
|
||||
|
||||
@then("the JSON output should contain an array of context entries")
|
||||
def step_json_contains_entries(context: Context) -> None:
|
||||
"""Verify JSON contains entries array."""
|
||||
assert "entries" in context.json_output or isinstance(context.json_output, list), (
|
||||
f"JSON does not contain 'entries'.\nJSON: {context.json_output}"
|
||||
)
|
||||
|
||||
|
||||
@then("each entry should have keys: path, tier, size, last_accessed")
|
||||
def step_json_entry_keys(context: Context) -> None:
|
||||
"""Verify JSON entries have all required keys."""
|
||||
entries = context.json_output.get("entries", context.json_output)
|
||||
if entries:
|
||||
for entry in entries:
|
||||
assert "path" in entry, f"'path' missing from entry: {entry}"
|
||||
assert "tier" in entry, f"'tier' missing from entry: {entry}"
|
||||
assert "size" in entry, f"'size' missing from entry: {entry}"
|
||||
assert "last_accessed" in entry, (
|
||||
f"'last_accessed' missing from entry: {entry}"
|
||||
)
|
||||
|
||||
|
||||
@then("the output should display a table")
|
||||
def step_output_is_table(context: Context) -> None:
|
||||
"""Verify output is a table."""
|
||||
assert (
|
||||
"|" in context.last_command_output or "File Path" in context.last_command_output
|
||||
), f"Output does not appear to be a table.\nOutput: {context.last_command_output}"
|
||||
|
||||
|
||||
@then("the output should indicate file was added")
|
||||
def step_output_file_added(context: Context) -> None:
|
||||
"""Verify output indicates file was added."""
|
||||
assert (
|
||||
"Added" in context.last_command_output or "✓" in context.last_command_output
|
||||
), (
|
||||
f"Output does not indicate file was added.\nOutput: {context.last_command_output}"
|
||||
)
|
||||
|
||||
|
||||
@then('the context should contain "{file_path}"')
|
||||
def step_context_contains_file(context: Context, file_path: str) -> None:
|
||||
"""Verify context contains file."""
|
||||
assert file_path in context.added_files, (
|
||||
f"File '{file_path}' not in context.\nAdded files: {context.added_files}"
|
||||
)
|
||||
|
||||
|
||||
@then('the context entry for "{file_path}" should have tag "{tag}"')
|
||||
def step_context_entry_has_tag(context: Context, file_path: str, tag: str) -> None:
|
||||
"""Verify context entry has tag."""
|
||||
assert file_path in context.file_metadata, (
|
||||
f"No metadata for '{file_path}'.\nMetadata: {context.file_metadata}"
|
||||
)
|
||||
assert context.file_metadata[file_path].get("tag") == tag, (
|
||||
f"Tag mismatch for '{file_path}': "
|
||||
f"expected '{tag}', got '{context.file_metadata[file_path].get('tag')}'"
|
||||
)
|
||||
|
||||
|
||||
@then('the context entry for "{file_path}" should have policy "{policy}"')
|
||||
def step_context_entry_has_policy(
|
||||
context: Context, file_path: str, policy: str
|
||||
) -> None:
|
||||
"""Verify context entry has policy."""
|
||||
assert file_path in context.file_metadata, (
|
||||
f"No metadata for '{file_path}'.\nMetadata: {context.file_metadata}"
|
||||
)
|
||||
assert context.file_metadata[file_path].get("policy") == policy, (
|
||||
f"Policy mismatch for '{file_path}': "
|
||||
f"expected '{policy}', got '{context.file_metadata[file_path].get('policy')}'"
|
||||
)
|
||||
|
||||
|
||||
@then("the output should indicate file was already in context")
|
||||
def step_output_file_already_in_context(context: Context) -> None:
|
||||
"""Verify output indicates file was already in context."""
|
||||
assert "already in context" in context.last_command_output.lower(), (
|
||||
f"Output does not indicate file was already in context.\n"
|
||||
f"Output: {context.last_command_output}"
|
||||
)
|
||||
|
||||
|
||||
@then("the output should indicate {count:d} files were added")
|
||||
def step_output_files_added_count(context: Context, count: int) -> None:
|
||||
"""Verify output indicates correct number of files added."""
|
||||
assert str(count) in context.last_command_output, (
|
||||
f"Count '{count}' not in output.\nOutput: {context.last_command_output}"
|
||||
)
|
||||
|
||||
|
||||
@then("the JSON output should contain entries with:")
|
||||
def step_json_entries_with_values(context: Context) -> None:
|
||||
"""Verify JSON entries contain specific values."""
|
||||
import json as _json
|
||||
|
||||
if not hasattr(context, "json_output"):
|
||||
raw = getattr(context, "last_command_output", "")
|
||||
try:
|
||||
context.json_output = _json.loads(raw)
|
||||
except (_json.JSONDecodeError, ValueError) as e:
|
||||
raise AssertionError(f"Output is not valid JSON: {e}\nOutput: {raw}") from e
|
||||
entries = context.json_output.get("entries", context.json_output)
|
||||
for row in context.table:
|
||||
field = row["field"]
|
||||
value = row["value"]
|
||||
found = any(entry.get(field) == value for entry in entries)
|
||||
assert found, f"No entry found with {field}={value}.\nEntries: {entries}"
|
||||
@@ -74,6 +74,8 @@ def _capture_output(context: Any) -> str:
|
||||
return context.output
|
||||
if hasattr(context, "command_output"):
|
||||
return context.command_output
|
||||
if hasattr(context, "last_command_output"):
|
||||
return context.last_command_output
|
||||
raise AssertionError("No CLI output captured in context")
|
||||
|
||||
|
||||
|
||||
@@ -152,21 +152,6 @@ def step_run_context_clear(context):
|
||||
context.result = result
|
||||
|
||||
|
||||
@when("I run context list")
|
||||
def step_run_context_list(context):
|
||||
"""Run context list command."""
|
||||
runner = CliRunner()
|
||||
with patch("cleveragents.application.container.get_container") as mock_container:
|
||||
mock_context_service = MagicMock(spec=ContextService)
|
||||
mock_context_service.list_context = MagicMock(
|
||||
return_value=["file1.py", "file2.py"]
|
||||
)
|
||||
mock_container.return_value.context_service = mock_context_service
|
||||
|
||||
result = runner.invoke(context_app, ["list"])
|
||||
context.result = result
|
||||
|
||||
|
||||
@when('I run plan tell with instruction "{instruction}"')
|
||||
def step_run_plan_tell(context, instruction):
|
||||
"""Run plan tell command."""
|
||||
|
||||
@@ -237,6 +237,21 @@ def step_save_yaml_keys(context: Context) -> None:
|
||||
|
||||
@then("the output should be valid JSON")
|
||||
def step_output_valid_json(context: Context) -> None:
|
||||
# Support both context.result (CLI output format tests) and
|
||||
# context.last_command_output (ACMS context CLI tests)
|
||||
last_cmd_output = getattr(context, "last_command_output", "")
|
||||
if last_cmd_output:
|
||||
# ACMS context CLI test path: last_command_output takes priority
|
||||
try:
|
||||
context.json_output = json.loads(last_cmd_output)
|
||||
except json.JSONDecodeError as e:
|
||||
raise AssertionError(
|
||||
f"Output is not valid JSON: {e}\nOutput: {last_cmd_output}"
|
||||
) from e
|
||||
return
|
||||
if not hasattr(context, "result"):
|
||||
# No output captured at all
|
||||
raise AssertionError("No CLI output captured in context")
|
||||
assert context.result.exit_code == 0, (
|
||||
f"CLI exited with {context.result.exit_code}: {context.result.output}"
|
||||
)
|
||||
|
||||
@@ -407,7 +407,12 @@ def step_json_valid(context: Context) -> None:
|
||||
|
||||
@then('the JSON output should contain key "{key}"')
|
||||
def step_json_has_key(context: Context, key: str) -> None:
|
||||
data = json.loads(context.json_text)
|
||||
# Support both context.json_text (diff review tests) and
|
||||
# context.json_output (ACMS context CLI tests)
|
||||
if hasattr(context, "json_output"):
|
||||
data = context.json_output
|
||||
else:
|
||||
data = json.loads(context.json_text)
|
||||
assert key in data, f"Expected key '{key}' in JSON output"
|
||||
|
||||
|
||||
|
||||
@@ -9,6 +9,7 @@ Deprecated alias: ``agents context <subcommand>`` (emits deprecation warning)
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json as _json
|
||||
from pathlib import Path
|
||||
from typing import TYPE_CHECKING, Annotated, Any
|
||||
|
||||
@@ -222,6 +223,21 @@ def context_add(
|
||||
recursive: Annotated[
|
||||
bool, typer.Option("-r", "--recursive", help="Add directories recursively")
|
||||
] = True,
|
||||
tag: Annotated[
|
||||
str | None,
|
||||
typer.Option("--tag", help="Tag for the context entry (e.g. 'production')"),
|
||||
] = None,
|
||||
policy: Annotated[
|
||||
str | None,
|
||||
typer.Option(
|
||||
"--policy",
|
||||
help="Storage tier policy for the context entry (hot|warm|cold)",
|
||||
),
|
||||
] = None,
|
||||
output_format: Annotated[
|
||||
str,
|
||||
typer.Option("--format", help="Output format: table or json"),
|
||||
] = "table",
|
||||
) -> None:
|
||||
"""Add files or directories to the current plan's context.
|
||||
|
||||
@@ -248,11 +264,13 @@ def context_add(
|
||||
# Add each path to context
|
||||
added_files: list[Path] = []
|
||||
already_in_context: list[Path] = []
|
||||
has_errors = False
|
||||
for path_str in paths:
|
||||
path = Path(path_str).resolve()
|
||||
|
||||
if not path.exists():
|
||||
console.print(f"[red]Error:[/red] Path does not exist: {path}")
|
||||
has_errors = True
|
||||
continue
|
||||
|
||||
files, already = context_service.add_to_context(
|
||||
@@ -261,6 +279,23 @@ def context_add(
|
||||
added_files.extend(files)
|
||||
already_in_context.extend(already)
|
||||
|
||||
if has_errors and not added_files:
|
||||
raise typer.Exit(code=1)
|
||||
|
||||
if output_format == "json":
|
||||
result: dict[str, Any] = {
|
||||
"status": "success" if added_files else "no_change",
|
||||
"added_files": [str(f) for f in added_files],
|
||||
"already_in_context": [str(f) for f in already_in_context],
|
||||
"count": len(added_files),
|
||||
}
|
||||
if tag is not None:
|
||||
result["tag"] = tag
|
||||
if policy is not None:
|
||||
result["policy"] = policy
|
||||
typer.echo(_json.dumps(result, indent=2))
|
||||
return
|
||||
|
||||
if added_files:
|
||||
console.print(
|
||||
f"[green]✓[/green] Added {len(added_files)} file(s) to context:"
|
||||
@@ -404,6 +439,10 @@ def context_list(
|
||||
resolve_path=True,
|
||||
),
|
||||
] = None,
|
||||
output_format: Annotated[
|
||||
str,
|
||||
typer.Option("--format", help="Output format: table or json"),
|
||||
] = "table",
|
||||
) -> None:
|
||||
"""List all files in the current plan's context.
|
||||
|
||||
@@ -451,7 +490,38 @@ def context_list(
|
||||
console.print("Use 'agents actor context add <path>' to add files.")
|
||||
return
|
||||
|
||||
# Display context files
|
||||
if output_format == "json":
|
||||
entries: list[dict[str, Any]] = []
|
||||
for file_info in context_files:
|
||||
path_text, type_label, size, added_at, _ = _normalize_context_entry(
|
||||
file_info
|
||||
)
|
||||
entry: dict[str, Any] = {
|
||||
"path": path_text,
|
||||
"tier": type_label,
|
||||
"size": size if isinstance(size, int) else 0,
|
||||
"last_accessed": added_at,
|
||||
}
|
||||
# Include optional tag/policy fields if present on the entry
|
||||
if isinstance(file_info, dict):
|
||||
if "tag" in file_info:
|
||||
entry["tag"] = str(file_info["tag"])
|
||||
if "policy" in file_info:
|
||||
entry["policy"] = str(file_info["policy"])
|
||||
else:
|
||||
tag_val = getattr(file_info, "tag", None)
|
||||
if tag_val is not None:
|
||||
entry["tag"] = str(tag_val)
|
||||
policy_val = getattr(file_info, "policy", None)
|
||||
if policy_val is not None:
|
||||
entry["policy"] = str(policy_val)
|
||||
entries.append(entry)
|
||||
typer.echo(
|
||||
_json.dumps({"entries": entries, "total": len(entries)}, indent=2)
|
||||
)
|
||||
return
|
||||
|
||||
# Display context files as table
|
||||
table = Table(title=f"Context Files ({len(context_files)} total)")
|
||||
table.add_column("File Path", style="cyan")
|
||||
table.add_column("Type", style="green")
|
||||
|
||||
Reference in New Issue
Block a user