ISSUE-004: Stabilize string value encoding for arguments

Problem
- Tests currently accept either String or Raw for str arguments (e.g., 'x'), which masks regressions.

Plan
- Ensure Python str is encoded as String in runtime tracer (already true).
- Tighten tests to require kind == String with text == 'x'.
- Keep varargs/kwargs flexible; their encoding may vary by backend.
- Clarify encoding rule in comments.

Notes
- No schema changes; this is test-only in this repo.

ISSUE-004: Tighten tests to require String encoding for str args

What changed

- Updated test_call_arguments_recorded_on_py_start to assert kind == String and
  text == 'x' for the string argument.
- Added documentation comments to encode_value clarifying canonical encoding
  rules (str -> String; non-handled types -> Raw).

Notes vs. plan
- No runtime logic changes were needed: the Rust runtime tracer already encodes
  Python str as String.

- Varargs/kwargs tests remain flexible, as planned.

- Could not run 'just dev test' due to sandboxed, offline environment; please
  run locally to verify.

Author: tzanko-matev

.gitignore

@@ -5,4 +5,5 @@
 **/target/
 build
 *~
-.idea/
+.idea/
+.cargo/

codetracer-python-recorder/src/runtime_tracer.rs

@@ -77,6 +77,14 @@ impl RuntimeTracer {
         }
     }
 
+    /// Encode a Python value into a `ValueRecord` used by the trace writer.
+    ///
+    /// Canonical rules:
+    /// - `None` -> `NONE_VALUE`
+    /// - `bool` -> `Bool`
+    /// - `int`  -> `Int`
+    /// - `str`  -> `String` (canonical for text; do not fall back to Raw)
+    /// - any other type -> textual `Raw` via `__str__` best-effort
     fn encode_value<'py>(&mut self, _py: Python<'py>, v: &Bound<'py, PyAny>) -> ValueRecord {
         // None
         if v.is_none() {
@@ -91,6 +99,9 @@ impl RuntimeTracer {
             let ty = TraceWriter::ensure_type_id(&mut self.writer, TypeKind::Int, "Int");
             return ValueRecord::Int { i, type_id: ty };
         }
+        // Strings are encoded canonically as `String` to ensure stable tests
+        // and downstream processing. Falling back to `Raw` for `str` is
+        // not allowed.
         if let Ok(s) = v.extract::<String>() {
             let ty = TraceWriter::ensure_type_id(&mut self.writer, TypeKind::String, "String");
             return ValueRecord::String { text: s, type_id: ty };

codetracer-python-recorder/test/test_monitoring_events.py

@@ -190,11 +190,10 @@ def arg_value(i: int) -> Dict[str, Any]:
     assert arg_value(0).get("kind") == "Int" and int(arg_value(0).get("i")) == 1
     assert arg_name(1) == "b"
     v1 = arg_value(1)
-    assert v1.get("kind") in ("String", "Raw")  # backend may encode as String or Raw
-    if v1.get("kind") == "String":
-        assert v1.get("text") == "x"
-    else:
-        assert v1.get("r") == "x"
+    # String encoding must be stable for Python str values.
+    # Enforce canonical kind String and exact text payload.
+    assert v1.get("kind") == "String", f"Expected String encoding for str, got: {v1}"
+    assert v1.get("text") == "x"
 
 
 def test_all_argument_kinds_recorded_on_py_start(tmp_path: Path) -> None:

issues.md

@@ -110,4 +110,18 @@ when `Raw` is expected) and update tests to assert the exact kind.
 - Documentation clarifies encoding rules for string-like types to avoid ambiguity in future changes.
 
 ### Status
-Not started
+Done
+
+Stricter tests now assert `str` values are encoded as `String` with the exact text payload, and runtime docs clarify canonical encoding. No runtime logic change was required since `encode_value` already produced `String` for Python `str`.
+
+## ISSUE-006
+### Description
+Accidental check-in of Cargo cache/artifact files under `codetracer-python-recorder/.cargo/**` (e.g., `registry/CACHEDIR.TAG`, `.package-cache`). These are build/cache directories and should be excluded from version control.
+
+### Definition of Done
+- Add ignore rules to exclude Cargo cache directories (e.g., `.cargo/**`, `target/**`) from version control.
+- Remove already-checked-in cache files from the repository.
+- Verify the working tree is clean after a clean build; no cache artifacts appear as changes.
+
+### Status
+Archived