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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cr_proc
-Version: 0.1.6
+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.6 → cr_proc-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "cr_proc"
-version = "0.1.6"
+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.6 → cr_proc-0.1.7}/src/code_recorder_processor/api/verify.py

@@ -348,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
 
@@ -375,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 = []
 
@@ -395,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
@@ -416,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