test: cover packaged cli behavior

Author: danjdewhurst

crates/agenthint/tests/cli.rs

@@ -0,0 +1,74 @@
+use std::collections::HashMap;
+use std::process::Command;
+
+use serde_json::Value;
+
+fn fixture_path(name: &str) -> String {
+    format!("{}/../../fixtures/{name}", env!("CARGO_MANIFEST_DIR"))
+}
+
+#[test]
+fn cli_matches_shared_fixtures() {
+    let fixtures: Value =
+        serde_json::from_str(&std::fs::read_to_string(fixture_path("cli-cases.json")).unwrap())
+            .unwrap();
+    let fixtures = fixtures.as_array().unwrap();
+
+    for fixture in fixtures {
+        let name = fixture["name"].as_str().unwrap();
+        let args = fixture["args"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|arg| arg.as_str().unwrap())
+            .collect::<Vec<_>>();
+        let env = fixture["env"]
+            .as_object()
+            .unwrap()
+            .iter()
+            .map(|(key, value)| (key.as_str(), value.as_str().unwrap()))
+            .collect::<HashMap<_, _>>();
+
+        let output = Command::new(env!("CARGO_BIN_EXE_agenthint"))
+            .args(args)
+            .env_clear()
+            .envs(env)
+            .output()
+            .unwrap();
+
+        assert_eq!(
+            output.status.code(),
+            Some(fixture["status"].as_i64().unwrap() as i32),
+            "{name}"
+        );
+
+        let stdout = String::from_utf8(output.stdout).unwrap();
+
+        if let Some(expected) = fixture["stdout"].as_str() {
+            assert_eq!(stdout, expected, "{name}");
+        }
+
+        if let Some(expected_values) = fixture["stdoutContains"].as_array() {
+            for expected in expected_values {
+                assert!(stdout.contains(expected.as_str().unwrap()), "{name}");
+            }
+        }
+    }
+}
+
+#[test]
+fn cli_rejects_invalid_usage() {
+    let output = Command::new(env!("CARGO_BIN_EXE_agenthint"))
+        .arg("bogus")
+        .env_clear()
+        .output()
+        .unwrap();
+
+    assert_eq!(output.status.code(), Some(2));
+    assert!(output.stdout.is_empty());
+    assert!(
+        String::from_utf8(output.stderr)
+            .unwrap()
+            .contains("invalid usage: bogus")
+    );
+}

python/agenthint/__init__.py

@@ -264,7 +264,7 @@ def _setup_advice(result: AgentHintResult, *, json_shape: bool = False) -> dict[
         message = "Detection is heuristic. Prefer setting AI_AGENT for a stable explicit signal."
         return {
             "kind": "heuristic",
-            "message": message if json_shape else f"setup: {message}",
+            "message": message if json_shape else f"setup: {message[:1].lower()}{message[1:]}",
             "hint": _setup_hint(result.agent),
         }
 

test/python_test.py

@@ -1,10 +1,26 @@
 import json
+import subprocess
+import sys
 import unittest
+from importlib.resources import files
 from pathlib import Path
 
 from agenthint import detect_agent, format_json
 
 
+def run_cli(args, env):
+    python_path = str(Path("python").resolve())
+    subprocess_env = {"PYTHONPATH": python_path, **env}
+
+    return subprocess.run(
+        [sys.executable, "-m", "agenthint.cli", *args],
+        env=subprocess_env,
+        text=True,
+        capture_output=True,
+        check=False,
+    )
+
+
 class AgentHintPythonTest(unittest.TestCase):
     def test_matches_shared_detection_fixtures(self):
         fixtures = json.loads(Path("fixtures/detection-cases.json").read_text())
@@ -43,6 +59,34 @@ def test_json_uses_camel_case_shape(self):
             },
         )
 
+    def test_cli_matches_shared_fixtures(self):
+        fixtures = json.loads(Path("fixtures/cli-cases.json").read_text())
+
+        for fixture in fixtures:
+            with self.subTest(fixture["name"]):
+                result = run_cli(fixture["args"], fixture["env"])
+
+                self.assertEqual(result.returncode, fixture["status"])
+
+                if fixture.get("stdout") is not None:
+                    self.assertEqual(result.stdout, fixture["stdout"])
+
+                for expected in fixture.get("stdoutContains", []):
+                    self.assertIn(expected, result.stdout)
+
+    def test_cli_rejects_invalid_usage(self):
+        result = run_cli(["bogus"], {})
+
+        self.assertEqual(result.returncode, 2)
+        self.assertEqual(result.stdout, "")
+        self.assertIn("invalid usage: bogus", result.stderr)
+
+    def test_package_includes_detection_rules(self):
+        rules = json.loads(files("agenthint").joinpath("detection-rules.json").read_text(encoding="utf8"))
+
+        self.assertIn("environmentRules", rules)
+        self.assertIn("parentProcessRules", rules)
+
 
 if __name__ == "__main__":
     unittest.main()