feat: Default to first attempts and improve threshold calculation

- Change default mode from all attempts to unique students (first attempts only)
  for more meaningful educational analysis
- Add selected sequence filtering to only count students who took exact paths
- Improve minimum threshold calculation with predecessor validation to prevent
  orphaning of intermediate nodes when applying filters
- Fix student visit statistics to show mathematically possible counts

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: tzacks-cl

src/App.tsx

@@ -74,7 +74,7 @@ function App() {
     // State to toggle whether self-loops (transitions back to the same node) should be included
     const [selfLoops, setSelfLoops] = useState<boolean>(true);
     const [errorMode, setErrorMode] = useState<boolean>(false);
-    const [uniqueStudentMode, setUniqueStudentMode] = useState<boolean>(false);
+    const [uniqueStudentMode, setUniqueStudentMode] = useState<boolean>(true);
     const [fileInfo, setFileInfo] = useState<{filename: string, source: string} | null>(null);
     // State to manage the minimum number of visits for displaying edges in the graph
     const [minVisitsPercentage, setMinVisitsPercentage] = useState<number>(0);

src/components/GraphvizParent.tsx

@@ -31,6 +31,12 @@ interface HistoryItem {
 
 const titleCase = (str: string | null) => str ? str.charAt(0).toUpperCase() + str.slice(1).toLowerCase() : '';
 
+// Helper function to compare arrays for exact equality
+const arraysEqual = (a: string[], b: string[]): boolean => {
+    if (a.length !== b.length) return false;
+    return a.every((val, index) => val === b[index]);
+};
+
 interface GraphvizParentProps {
     csvData: string;
     filter: string | null;
@@ -431,12 +437,30 @@ const GraphvizParent: React.FC<GraphvizParentProps> = ({
         // Calculate statistics
         let totalVisitors = 0;
         let totalNodeVisits = 0;
+        const visitCounts: { [studentId: string]: number } = {};
+        
+        // Check if this is the selected sequence graph and we need to filter
+        const isSelectedSequenceGraph = graphType === 'Selected Sequence';
+        const sequenceToFilter = isSelectedSequenceGraph ? selectedSequence : null;
 
         if (stepSequences && Object.keys(stepSequences).length > 0) {
-            const visitCounts: { [studentId: string]: number } = {};
             Object.entries(stepSequences).forEach(([studentId, studentProblems]) => {
                 // studentProblems is { [problemName]: string[] }
                 if (studentProblems && typeof studentProblems === 'object') {
+                    
+                    // For selected sequence graph, check if student took the exact path
+                    if (isSelectedSequenceGraph && sequenceToFilter) {
+                        let studentFollowedSequence = false;
+                        Object.values(studentProblems).forEach((problemSequence: string[]) => {
+                            if (Array.isArray(problemSequence) && arraysEqual(problemSequence, sequenceToFilter)) {
+                                studentFollowedSequence = true;
+                            }
+                        });
+                        if (!studentFollowedSequence) {
+                            return; // Skip this student if they didn't follow the exact sequence
+                        }
+                    }
+                    
                     let studentNodeVisits = 0;
                     Object.values(studentProblems).forEach((problemSequence: string[]) => {
                         if (Array.isArray(problemSequence)) {
@@ -455,9 +479,22 @@ const GraphvizParent: React.FC<GraphvizParentProps> = ({
         }
 
         const avgVisitsPerStudent = totalVisitors > 0 ? (totalNodeVisits / totalVisitors).toFixed(1) : '0';
-        const studentsWithRepeats = Math.max(0, totalNodeVisits - totalVisitors);
-        const singleVisits = Math.max(0, totalVisitors - studentsWithRepeats);
-        const multipleVisits = studentsWithRepeats;
+        
+        // Calculate correct student visit statistics
+        let studentsWithSingleVisit = 0;
+        let studentsWithMultipleVisits = 0;
+        
+        Object.values(visitCounts).forEach((visitCount: number) => {
+            if (visitCount > 1) {
+                studentsWithMultipleVisits++;
+            } else {
+                studentsWithSingleVisit++;
+            }
+        });
+        
+        
+        const singleVisits = studentsWithSingleVisit;
+        const multipleVisits = studentsWithMultipleVisits;
 
         // Count unique edges that meet the minimum visits threshold
         const filteredIncomingEdges = incomingEdges.filter(edge => (edgeCounts[edge] || 0) >= minVisits);

src/components/GraphvizProcessing.ts

@@ -987,12 +987,15 @@ export function calculateMaxMinEdgeCount(
         // Additional check: ensure selected sequence remains connected
         const isSequenceConnected = checkSequenceConnectivity(validEdges, selectedSequence);
 
-        if (isGraphConnected && isSequenceConnected) {
+        // Additional check: ensure non-first nodes have preceding nodes
+        const hasValidPredecessors = checkNodePredecessors(validEdges, allNodes, selectedSequence);
+        
+        if (isGraphConnected && isSequenceConnected && hasValidPredecessors) {
             maxValidThreshold = threshold;
             console.log(`✓ Threshold ${threshold} keeps all nodes and sequence connected`);
             break; // Since we're going in descending order, this is the maximum valid threshold
         } else {
-            console.log(`✗ Threshold ${threshold} disconnects nodes (graph: ${isGraphConnected}, sequence: ${isSequenceConnected})`);
+            console.log(`✗ Threshold ${threshold} disconnects nodes (graph: ${isGraphConnected}, sequence: ${isSequenceConnected}, predecessors: ${hasValidPredecessors})`);
         }
     }
 
@@ -1047,6 +1050,57 @@ function checkSequenceConnectivity(
     return true;
 }
 
+/**
+ * Ensures that nodes which aren't first nodes in any path still have at least one preceding node.
+ * This prevents orphaning of intermediate nodes when applying threshold filters.
+ * 
+ * @param edges - Available edges with their counts
+ * @param allNodes - All nodes in the graph
+ * @param selectedSequence - The selected sequence (first node is considered a valid starting point)
+ * @returns True if all non-first nodes have at least one incoming edge
+ */
+function checkNodePredecessors(
+    edges: Array<{edge: string, count: number}>, 
+    allNodes: Set<string>,
+    selectedSequence: string[]
+): boolean {
+    // Build incoming edge map
+    const incomingEdges = new Map<string, Set<string>>();
+    
+    // Initialize all nodes with empty sets
+    allNodes.forEach(node => {
+        incomingEdges.set(node, new Set());
+    });
+    
+    // Track incoming edges for each node
+    edges.forEach(({ edge }) => {
+        const [fromNode, toNode] = edge.split('->');
+        if (fromNode && toNode) {
+            incomingEdges.get(toNode)?.add(fromNode);
+        }
+    });
+    
+    // Get the first node in the selected sequence (this can be without predecessors)
+    const firstSequenceNode = selectedSequence.length > 0 ? selectedSequence[0] : null;
+    
+    // Check that all nodes (except potential first nodes) have at least one predecessor
+    for (const node of allNodes) {
+        const hasIncomingEdges = (incomingEdges.get(node)?.size ?? 0) > 0;
+        
+        // Allow nodes without predecessors only if they're the first in the selected sequence
+        // or if they could be legitimate starting points
+        if (!hasIncomingEdges && node !== firstSequenceNode) {
+            // Additional check: see if this node appears as first in any actual student path
+            // For now, we'll be conservative and require all non-first-sequence nodes to have predecessors
+            console.log(`Node ${node} has no predecessors and isn't the first in selected sequence`);
+            return false;
+        }
+    }
+    
+    console.log("All nodes have valid predecessors or are legitimate starting points");
+    return true;
+}
+
 /**
  * Checks if a graph is connected (all nodes can reach each other) given a set of edges.
  * Uses depth-first search to verify connectivity.