v0.7.1: Social Card Generator & UI Improvements

New Features:
- Social Card Generator with Brand/2D/3D preview options
- Toast system improvements (top position, 15 max, 24px radius)

Known Issues:
- Social Card export may be unstable in certain conditions

Author: ChidcGithub

README.md

@@ -13,7 +13,7 @@
 
 # PyVizAST
 
-[![Version](https://img.shields.io/badge/Version-0.7.0-blue.svg)](https://github.com/ChidcGithub/PyVizAST)
+[![Version](https://img.shields.io/badge/Version-0.7.1-blue.svg)](https://github.com/ChidcGithub/PyVizAST)
 [![Python](https://img.shields.io/badge/Python-3.8%2B-brightgreen.svg)](https://www.python.org/)
 [![License](https://img.shields.io/badge/License-GPL%20v3-blue.svg)](LICENSE)
 [![Platform](https://img.shields.io/badge/Platform-Windows%20%7C%20Linux%20%7C%20macOS-lightgrey.svg)](https://github.com/ChidcGithub/PyVizAST)
@@ -207,12 +207,57 @@ GNU General Public License v3.0
 
 Contributions are welcome. Please submit pull requests to the main repository.
 
+## Known Issues
+
+- **Social Card Export**: The social card generator may be unstable in certain browsers. 3D visualization capture requires the 3D view to be fully rendered before capturing.
+- **Gesture Control**: Gesture recognition may be unstable in certain lighting conditions.
+
 ---
 
 <details>
 
 <summary>Version History</summary>
 
+<details>
+<summary>v0.7.1 (2026-03-14)</summary>
+
+**Social Card Generator & UI Improvements**
+
+**New Features:**
+- **Social Card Generator**: Generate shareable image cards from the Share dropdown
+  - Brand card with AST visualization, logo, and feature highlights
+  - 2D Preview card with captured AST visualization
+  - 3D Preview card with captured 3D AST visualization
+  - Black/white theme adaptation
+  - PNG download (1200x630px standard social share size)
+
+**Toast System Improvements:**
+- Toast position moved to top-right of screen
+- Simplified vertical stacking (removed complex stacking logic)
+- Increased maximum toast limit from 5 to 15
+- Increased border-radius from 16px to 24px for rounder corners
+
+**UI Enhancements:**
+- Share button now shows dropdown menu with "Share Code" and "Social Card" options
+- Visualizer components expose `captureScreenshot` method for card generation
+- Improved card preview modal with style selector
+
+**Known Issues:**
+- Social Card export may be unstable in certain browsers/conditions
+- 3D visualization capture requires the 3D view to be fully rendered
+
+**Files Modified:**
+- `frontend/src/components/SocialCardGenerator.js` - New social card generator component
+- `frontend/src/components/Header.js` - Share dropdown menu
+- `frontend/src/components/Toast.js` - Simplified toast system
+- `frontend/src/components/ToastContext.js` - Increased toast limit
+- `frontend/src/App.js` - Screenshot capture handlers
+- `frontend/src/App.css` - Social card styles, toast improvements
+- `frontend/src/components/ASTVisualizer.js` - Screenshot capture method
+- `frontend/src/components/ASTVisualizer3D.js` - Screenshot capture method
+
+</details>
+
 <details>
 <summary>v0.7.0 (2026-03-14)</summary>
 

backend/analyzers/code_smells.py

@@ -245,29 +245,71 @@ def visit_Constant(self, node):
         visitor.visit(tree)
 
     def _detect_unused_variables(self, tree: ast.AST):
-        """Detect unused variables"""
-        assigned_vars = set()
-        used_vars = set()
+        """Detect unused variables - Enhanced version with unpacking support"""
+        assigned_vars = set()  # (var_name, lineno)
+        used_vars = set()      # var_name
+        
+        # Helper function to extract variable names from assignment targets
+        def extract_var_names(target, lineno):
+            """Extract variable names from assignment target, handling unpacking"""
+            names = []
+            if isinstance(target, ast.Name):
+                names.append((target.id, lineno))
+            elif isinstance(target, ast.Tuple) or isinstance(target, ast.List):
+                # Handle tuple/list unpacking: a, b = func() or [a, b] = func()
+                for elt in target.elts:
+                    names.extend(extract_var_names(elt, lineno))
+            elif isinstance(target, ast.Starred):
+                # Handle starred unpacking: a, *rest = func()
+                names.extend(extract_var_names(target.value, lineno))
+            return names
 
         for node in ast.walk(tree):
+            # Handle regular assignments
+            if isinstance(node, ast.Assign):
+                for target in node.targets:
+                    assigned_vars.update(extract_var_names(target, node.lineno))
+            
+            # Handle annotated assignments: x: int = 5
+            elif isinstance(node, ast.AnnAssign):
+                if isinstance(node.target, ast.Name):
+                    assigned_vars.add((node.target.id, node.lineno))
+            
+            # Handle augmented assignments: x += 1 (counts as both assign and use)
+            elif isinstance(node, ast.AugAssign):
+                if isinstance(node.target, ast.Name):
+                    used_vars.add(node.target.id)
+            
+            # Handle for loop variables: for i in range(10):
+            elif isinstance(node, ast.For):
+                assigned_vars.update(extract_var_names(node.target, node.lineno))
+            
+            # Handle with statement variables: with open() as f:
+            elif isinstance(node, ast.withitem):
+                if node.optional_vars:
+                    assigned_vars.update(extract_var_names(node.optional_vars, node.lineno if hasattr(node, 'lineno') else 0))
+            
+            # Handle variable usage
             if isinstance(node, ast.Name):
-                if isinstance(node.ctx, ast.Store):
-                    assigned_vars.add((node.id, node.lineno))
-                elif isinstance(node.ctx, ast.Load):
+                if isinstance(node.ctx, ast.Load):
                     used_vars.add(node.id)
 
         # Find defined but unused variables
         for var_name, lineno in assigned_vars:
-            if var_name not in used_vars and not var_name.startswith('_'):
-                # Exclude some special cases
-                if var_name not in ('_', 'self', 'cls'):
-                    self.issues.append(CodeIssue(
-                        id=self._generate_issue_id("unused_var"),
-                        type="code_smell",
-                        severity=SeverityLevel.INFO,
-                        message=f"Variable '{var_name}' may be unused",
-                        lineno=lineno
-                    ))
+            # Skip special cases
+            if var_name.startswith('_'):  # Convention for intentionally unused
+                continue
+            if var_name in ('self', 'cls', 'args', 'kwargs'):  # Special parameters
+                continue
+            
+            if var_name not in used_vars:
+                self.issues.append(CodeIssue(
+                    id=self._generate_issue_id("unused_var"),
+                    type="code_smell",
+                    severity=SeverityLevel.INFO,
+                    message=f"Variable '{var_name}' may be unused",
+                    lineno=lineno
+                ))
 
     def _detect_poor_names(self, tree: ast.AST):
         """Detect poor naming"""

backend/analyzers/complexity.py

@@ -192,12 +192,13 @@ def visit_Call(self, node):
                 if self.current_function:
                     func_name = None
                     is_self_call = False
+                    is_class_call = False  # ClassName.method(self) pattern
 
                     if isinstance(node.func, ast.Name):
                         # Direct function call: func()
                         func_name = node.func.id
                     elif isinstance(node.func, ast.Attribute):
-                        # Method call: self.func() or obj.func()
+                        # Method call: self.func(), obj.func(), or ClassName.method()
                         if isinstance(node.func.value, ast.Name):
                             if node.func.value.id == 'self':
                                 # self.method() - potential method recursion
@@ -207,12 +208,24 @@ def visit_Call(self, node):
                                 # cls.method() - class method recursion
                                 is_self_call = True
                                 func_name = node.func.attr
+                            elif node.func.value.id == self.current_class:
+                                # ClassName.method(self) - static method call within the same class
+                                # This is also a form of recursion if method name matches
+                                is_class_call = True
+                                func_name = node.func.attr
 
                     # Add complexity for recursive calls
-                    # For self.method(), only count if we're inside a class and method name matches
                     if func_name == self.current_function:
                         if is_self_call:
                             # self.current_method() inside the same method = definite recursion
+                            # Note: current_class must be set for self.method() to be valid
+                            # In module-level functions, 'self' doesn't exist, so this check
+                            # correctly ignores invalid AST patterns
+                            if self.current_class is not None:
+                                self.complexity += 1
+                        elif is_class_call:
+                            # ClassName.method(self) call within the same class
+                            # This is recursion if we're inside that method
                             if self.current_class is not None:
                                 self.complexity += 1
                         else:

backend/analyzers/performance.py

@@ -337,9 +337,30 @@ def visit_Call(self, node):
     def _detect_expensive_operations_in_loops(self, tree: ast.AST):
         """Detect expensive operations inside loops"""
 
+        # Expensive operations that should be avoided in loops
         expensive_calls = {
-            'open', 'read', 'write', 'connect', 'request',
-            'query', 'execute', 'fetch', 'commit'
+            # I/O operations
+            'open', 'read', 'write', 'close', 'flush',
+            # Network operations
+            'connect', 'request', 'send', 'recv', 'urlopen',
+            # Database operations
+            'query', 'execute', 'fetch', 'commit', 'rollback', 'cursor',
+            # File system operations
+            'listdir', 'walk', 'glob', 'stat', 'exists', 'isfile', 'isdir', 'mkdir', 'rmdir', 'remove',
+            # Serialization
+            'dumps', 'loads', 'dump', 'load',
+            # Heavy computations
+            'sort', 'sorted', 'reverse', 'reversed',
+            # Regex compilation
+            'compile', 'match', 'search', 'findall', 'sub',
+            # Sleep (blocks execution)
+            'sleep',
+            # Image processing
+            'imread', 'imwrite', 'resize', 'save', 'show',
+            # Cryptographic operations
+            'encrypt', 'decrypt', 'hash', 'sign', 'verify',
+            # HTTP requests
+            'get', 'post', 'put', 'delete', 'patch', 'head', 'options',
         }
 
         class ExpensiveOpVisitor(ast.NodeVisitor):

backend/ast_parser/parser.py

@@ -80,6 +80,12 @@ def parse(self, code: str, source_lines: Optional[List[str]] = None, tree: Optio
                 raise ValueError("Code too large to parse (out of memory). Try simplifying the code or use simplified mode.")
             except RecursionError:
                 raise ValueError("Code structure too deeply nested to parse.")
+            except (ValueError, TypeError) as e:
+                # Handle encoding issues, invalid characters, or type errors
+                raise ValueError(f"Invalid code format: {e}")
+            except Exception as e:
+                # Catch-all for any other unexpected errors during parsing
+                raise ValueError(f"Failed to parse code: {type(e).__name__}: {e}")
 
         if source_lines is None:
             source_lines = code.splitlines()

backend/data/__init__.py

@@ -1,4 +1,4 @@
 """
-PyVizAST 数据模块
-包含挑战数据等静态资源
+PyVizAST Data Module
+Contains static resources such as challenge data
 """

backend/main.py

@@ -58,7 +58,7 @@ async def lifespan(app: FastAPI) -> AsyncIterator[None]:
 app = FastAPI(
     title="PyVizAST API",
     description="Python AST Visualization and Static Analysis API",
-    version="0.7.0",
+    version="0.7.1",
     docs_url="/docs",
     redoc_url="/redoc",
     lifespan=lifespan