cr-proc 0.1.5__tar.gz → 0.1.7__tar.gz

{cr_proc-0.1.5 → cr_proc-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cr_proc
-Version: 0.1.5
+Version: 0.1.7
 Summary: A tool for processing BYU CS code recording files.
 Author: Ethan Dye
 Author-email: mrtops03@gmail.com

{cr_proc-0.1.5 → cr_proc-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cr_proc"
-version = "0.1.5"
+version = "0.1.7"
 description = "A tool for processing BYU CS code recording files."
 authors = [
     {name = "Ethan Dye",email = "mrtops03@gmail.com"}

{cr_proc-0.1.5 → cr_proc-0.1.7}/src/code_recorder_processor/api/verify.py

@@ -313,6 +313,19 @@ def _detect_rapid_paste_sequences(jsonData: tuple[dict[str, Any], ...]) -> list[
         # If we found 3+ one-line pastes within 1 second, flag it
         if len(cluster) >= 3:
             event_indices = [p["event_index"] for p in cluster]
+
+            # Build detailed events list for optional detailed review
+            detailed_events = []
+            for paste in cluster:
+                idx = paste["event_index"]
+                content = paste["content"]
+                detailed_events.append({
+                    "event_index": idx,
+                    "line_count": 1,
+                    "char_count": len(content),
+                    "newFragment": content,
+                })
+
             suspicious_events.append({
                 "event_index": event_indices[0],
                 "event_indices": event_indices,
@@ -320,6 +333,7 @@ def _detect_rapid_paste_sequences(jsonData: tuple[dict[str, Any], ...]) -> list[
                 "char_count": sum(len(p["content"]) for p in cluster),
                 "reason": "rapid one-line pastes (AI indicator)",
                 "newFragment": f"{len(cluster)} one-line pastes in 1 second",
+                "detailed_events": detailed_events,
             })
 
         i = j if j > i + 1 else i + 1
@@ -334,16 +348,22 @@ def _detect_fullline_autocomplete(
     excluded_indices: set[int]
 ) -> list[dict[str, Any]]:
     """
-    Detect full-line auto-complete events where the IDE/AI completes code.
+    Detect multi-line auto-complete events where the IDE/AI generates multiple complete lines.
+
+    Focuses on significant AI assistance where the system generates entire functions or blocks
+    (2+ lines) in a single completion event. This is distinct from basic IDE autocomplete
+    (e.g., finishing a function name).
 
     At keystroke level, events show:
     - Normal typing: oldFragment="" (empty), newFragment="X" (1 char)
-    - Auto-complete: oldFragment="" (empty), newFragment="long_text" (10+ chars)
+    - Basic autocomplete: oldFragment="" (empty), newFragment="function_name" (IDE suggests identifier)
+    - Full-line AI completion: oldFragment="" (empty), newFragment="def foo():\n    pass" (entire function)
 
-    Auto-complete is detected when:
+    Full-line auto-complete is detected when:
     - oldFragment is empty or very short (0-3 chars)
-    - newFragment is substantial (10+ characters)
-    - newFragment contains code structure (assignment, parens, brackets, etc.)
+    - newFragment generates 2+ complete lines
+    - newFragment contains complete statements (not just identifiers)
+    - Content represents meaningful code structure
     - newFragment does NOT already exist in the document state
     - Event not already flagged as external copy-paste
 
@@ -361,7 +381,7 @@ def _detect_fullline_autocomplete(
     Returns
     -------
     list[dict[str, Any]]
-        List of suspected auto-complete events.
+        List of suspected multi-line auto-complete events.
     """
     suspicious_events = []
 
@@ -381,20 +401,22 @@ def _detect_fullline_autocomplete(
         new_len = len(new_frag)
 
         # At keystroke level, oldFragment is typically empty for insertions
-        # Allow up to 3 chars for prefix-based autocomplete triggers
+        # Allow up to 3 chars for prefix-based triggers (e.g., "de" -> "def")
         if old_len > 3:
             continue
 
-        # Skip single-character additions (normal typing)
-        # Auto-complete typically adds 10+ characters at once
-        if new_len < 10:
-            continue
+        # Check line count - we care about complete statements
+        # Multi-line is obviously concerning, but single-line with a complete statement
+        # (like "if x: return True") is also suspicious if it came from autocomplete
+        new_lines = [n for n in new_frag.split("\n") if n.strip() != ""]
 
-        # Skip large multi-line pastes - those should be caught by multi-line paste detector
-        # Auto-complete is typically 1-2 lines and under 100 chars
-        # Anything larger is likely external copy-paste, not auto-complete
-        new_lines = new_frag.split("\n")
-        if len(new_lines) > 2 or new_len > 100:
+        # For single-line completions, be more strict about what we flag
+        # We only flag if it's a complete statement with keywords, not just identifier completion
+        is_single_line = len(new_lines) <= 2  # 2 elements = 1 line + trailing \n
+        is_multi_line = len(new_lines) >= 3   # 3+ elements = 2+ actual lines
+
+        if not (is_single_line or is_multi_line):
+            # Shouldn't happen, but skip if malformed
             continue
 
         # The new fragment should not be just whitespace
@@ -402,40 +424,59 @@ def _detect_fullline_autocomplete(
             continue
 
         # Check if the new fragment contains code structure indicators
-        # These strongly suggest IDE/AI auto-completion of code
-        code_indicators = [
-            "=",  # Assignment (most common in autocomplete)
-            "(",  # Function call/definition
-            ")",  # Closing paren
-            ":",  # Block statement (if, for, def, etc.)
-            "{",  # Dictionary/block
-            "}",  # Closing brace
-            "[",  # List/index
-            "]",  # Closing bracket
-            "=>", # Arrow function
-            ";",  # Statement end
+        # These strongly suggest IDE/AI auto-completion of actual code (not just identifiers)
+        complete_statement_indicators = [
+            ":",      # Block statement (if:, for:, def:, class:, while:, with:, etc.)
+            "return", # Return statement
+            "def ",   # Function definition
+            "class ", # Class definition
+            "if ",    # If statement
+            "for ",   # For loop
+            "while ", # While loop
+            "try:",   # Try block
+            "except", # Exception handling
+            "import ", # Import statement
+            "=",      # Assignment
         ]
 
-        has_code_structure = any(indicator in new_frag for indicator in code_indicators)
+        has_complete_statement = any(indicator in new_frag for indicator in complete_statement_indicators)
 
-        # Must have code structure to be considered auto-complete
-        if has_code_structure:
-            # Check if this content already existed in the document state BEFORE this event
-            is_internal_copy = False
+        if not has_complete_statement:
+            # No complete statement - skip basic identifier completion
+            continue
 
-            if idx > 0:
-                prior_state = document_states[idx - 1]
-                if new_frag in prior_state:
-                    is_internal_copy = True
+        # Minimum size for meaningful completion
+        if new_len < 10:
+            continue
 
-            if not is_internal_copy:
-                suspicious_events.append({
-                    "event_index": idx,
-                    "line_count": len(new_lines),
-                    "char_count": new_len,
-                    "reason": "full-line auto-complete",
-                    "newFragment": new_frag,
-                })
+        # For multi-line: maximum size to distinguish from external pastes
+        # External pastes are typically much larger (100+ chars)
+        # Multi-line completions are usually 20-300 chars for a small function/block
+        if is_multi_line and new_len > 300:
+            continue
+
+        # For single-line: could be larger due to chained methods or long statements
+        # but cap at 200 chars to avoid flagging user-typed long lines
+        if is_single_line and new_len > 200:
+            continue
+
+        # Check if this content already existed in the document state BEFORE this event
+        is_internal_copy = False
+
+        if idx > 0:
+            prior_state = document_states[idx - 1]
+            if new_frag in prior_state:
+                is_internal_copy = True
+
+        if not is_internal_copy:
+            line_desc = "line" if is_single_line else "lines"
+            suspicious_events.append({
+                "event_index": idx,
+                "line_count": len(new_lines),
+                "char_count": new_len,
+                "reason": f"complete statement auto-complete (AI assistance)",
+                "newFragment": new_frag,
+            })
 
     return suspicious_events
 

{cr_proc-0.1.5 → cr_proc-0.1.7}/src/code_recorder_processor/cli.py

@@ -190,7 +190,29 @@ def display_suspicious_event(event: dict[str, Any], show_details: bool) -> None:
                     print(f"        {line}", file=sys.stderr)
                 print("        ```", file=sys.stderr)
 
+    elif "event_indices" in event and reason == "rapid one-line pastes (AI indicator)":
+        # Rapid paste sequences (AI indicator) - show aggregate style
+        indices = event["event_indices"]
+        print(
+            f"  AI Rapid Paste: Events #{indices[0]}-#{indices[-1]} "
+            f"({event['line_count']} lines, {event['char_count']} chars, "
+            f"{len(indices)} events in < 1 second)",
+            file=sys.stderr,
+        )
+
+        if show_details and "detailed_events" in event:
+            # Combine all detailed events into one block
+            combined_content = "".join(
+                detail["newFragment"] for detail in event["detailed_events"]
+            )
+            print("    Combined output:", file=sys.stderr)
+            print("        ```", file=sys.stderr)
+            for line in combined_content.split("\n"):
+                print(f"        {line}", file=sys.stderr)
+            print("        ```", file=sys.stderr)
+
     elif "event_indices" in event:
+        # Other multi-event clusters
         indices = event.get("event_indices", [event["event_index"]])
         print(
             f"  Events #{indices[0]}-#{indices[-1]} ({reason}): "
@@ -222,8 +244,20 @@ def display_suspicious_events(
         Whether to show detailed autocomplete events
     """
     if suspicious_events:
-        print("\nSuspicious copy-paste events detected:", file=sys.stderr)
-        for event in suspicious_events:
+        print("\nSuspicious events detected:", file=sys.stderr)
+
+        # Sort events by their index for chronological display
+        def get_sort_key(event: dict[str, Any]) -> int | float:
+            if "event_indices" in event and event["event_indices"]:
+                return event["event_indices"][0]
+            if "detailed_events" in event and event["detailed_events"]:
+                return event["detailed_events"][0].get("event_index", float("inf"))
+            event_idx = event.get("event_index", -1)
+            return event_idx if event_idx >= 0 else float("inf")
+
+        sorted_events = sorted(suspicious_events, key=get_sort_key)
+
+        for event in sorted_events:
             display_suspicious_event(event, show_details)
     else:
         print("Success! No suspicious events detected.", file=sys.stderr)