Merge development: C3.10 Signal Flow Analysis + Complete Godot Support + PR #278

Major Release Content (v2.8.1 / v2.9.0):

🎮 C3.10: Signal Flow Analysis
- 208 signals, 634 connections, 298 emissions analyzed
- EventBus, Observer, and Event Chain pattern detection
- Signal-based how-to guides generation
- New signal_flow_analyzer.py (450+ lines)

🎮 Complete Godot Game Engine Support
- GDScript (.gd), Scene (.tscn), Resource (.tres), Shader (.gdshader)
- 265 GDScript files, 118 scenes, 38 resources analyzed
- GUT/gdUnit4/WAT test framework support
- 396 test cases from 20 test files extracted

📚 C3.9: Project Documentation Extraction (from PR #278)
- Markdown file extraction and categorization
- Smart categorization (overview, architecture, guides)
- 96 markdown files processed in test project

⚡ Performance & UX (from PR #278)
- Parallel LOCAL mode (6-12x faster)
- --enhance-level flag (0-3 granular control)
- Auto-enhancement workflow
- LOCAL mode fallback

🐛 Godot-Specific Fixes:
- GDScript dependency extraction (265+ syntax errors eliminated)
- Framework detection false positive (Unity → Godot)
- Circular dependencies (self-loops filtered)
- Test discovery (0 → 32 test files)
- Config array handling, progress indicators

📊 Quality Metrics:
- SKILL.md: 31KB, 1,030 lines, 9/10 quality rating
- 98% file coverage (443/452 files)
- All tests passing on macOS (Ubuntu runners stuck due to GitHub infra)

Co-authored-by: PR #278 contributors

Author: yusufkaraaslan

CHANGELOG.md

@@ -7,16 +7,59 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
----
-
-## [2.8.0] - 2026-02-01
-
-### 🚀 Major Feature Release - Enhanced Code Analysis & Documentation
-
-This release brings powerful new code analysis features, performance optimizations, and international API support. Special thanks to all our contributors who made this release possible!
-
 ### Added
 
+#### C3.10: Signal Flow Analysis for Godot Projects (NEW)
+- **Complete Signal Flow Analysis System**: Analyze event-driven architectures in Godot game projects
+  - Signal declaration extraction (`signal` keyword detection)
+  - Connection mapping (`.connect()` calls with targets and methods)
+  - Emission tracking (`.emit()` and `emit_signal()` calls)
+  - **208 signals**, **634 connections**, and **298 emissions** detected in test project (Cosmic Idler)
+  - Signal density metrics (signals per file)
+  - Event chain detection (signals triggering other signals)
+  - Output: `signal_flow.json`, `signal_flow.mmd` (Mermaid diagram), `signal_reference.md`
+
+- **Signal Pattern Detection**: Three major patterns identified
+  - **EventBus Pattern** (0.90 confidence): Centralized signal hub in autoload
+  - **Observer Pattern** (0.85 confidence): Multi-observer signals (3+ listeners)
+  - **Event Chains** (0.80 confidence): Cascading signal propagation
+
+- **Signal-Based How-To Guides (C3.10.1)**: AI-generated usage guides
+  - Step-by-step guides (Connect → Emit → Handle)
+  - Real code examples from project
+  - Common usage locations
+  - Parameter documentation
+  - Output: `signal_how_to_guides.md` (10 guides for Cosmic Idler)
+
+#### Godot Game Engine Support
+- **Comprehensive Godot File Type Support**: Full analysis of Godot 4.x projects
+  - **GDScript (.gd)**: 265 files analyzed in test project
+  - **Scene files (.tscn)**: 118 scene files
+  - **Resource files (.tres)**: 38 resource files
+  - **Shader files (.gdshader, .gdshaderinc)**: 9 shader files
+  - **C# integration**: Phantom Camera addon (13 files)
+
+- **GDScript Language Support**: Complete GDScript parsing with regex-based extraction
+  - Dependency extraction: `preload()`, `load()`, `extends` patterns
+  - Test framework detection: GUT, gdUnit4, WAT
+  - Test file patterns: `test_*.gd`, `*_test.gd`
+  - Signal syntax: `signal`, `.connect()`, `.emit()`
+  - Export decorators: `@export`, `@onready`
+  - Test decorators: `@test` (gdUnit4)
+
+- **Game Engine Framework Detection**: Improved detection for Unity, Unreal, Godot
+  - **Godot markers**: `project.godot`, `.godot` directory, `.tscn`, `.tres`, `.gd` files
+  - **Unity markers**: `Assembly-CSharp.csproj`, `UnityEngine.dll`, `ProjectSettings/ProjectVersion.txt`
+  - **Unreal markers**: `.uproject`, `Source/`, `Config/DefaultEngine.ini`
+  - Fixed false positive Unity detection (was using generic "Assets" keyword)
+
+- **GDScript Test Extraction**: Extract usage examples from Godot test files
+  - **396 test cases** extracted from 20 GUT test files in test project
+  - Patterns: instantiation (`preload().new()`, `load().new()`), assertions (`assert_eq`, `assert_true`), signals
+  - GUT framework: `extends GutTest`, `func test_*()`, `add_child_autofree()`
+  - Test categories: instantiation, assertions, signal connections, setup/teardown
+  - Real code examples from production test files
+
 #### C3.9: Project Documentation Extraction
 - **Markdown Documentation Extraction**: Automatically extracts and categorizes all `.md` files from projects
   - Smart categorization by folder/filename (overview, architecture, guides, workflows, features, etc.)
@@ -74,7 +117,7 @@ This release brings powerful new code analysis features, performance optimizatio
 - Updated documentation with GLM-4.7 configuration examples
 - Rewritten LOCAL mode in `config_enhancer.py` to use Claude CLI properly with explicit output file paths
 - Updated MCP `scrape_codebase_tool` with `skip_docs` and `enhance_level` parameters
-- Updated CLAUDE.md with C3.9 documentation extraction feature and --enhance-level flag
+- Updated CLAUDE.md with C3.9 documentation extraction feature
 - Increased default batch size from 5 to 20 patterns for LOCAL mode
 
 ### Fixed
@@ -83,18 +126,60 @@ This release brings powerful new code analysis features, performance optimizatio
 - **LocalSkillEnhancer Import**: Fixed incorrect import and method call in `main.py` (SkillEnhancer → LocalSkillEnhancer)
 - **Code Quality**: Fixed 4 critical linter errors (unused imports, variables, arguments, import sorting)
 
-### Removed
-- Removed client-specific documentation files from repository
-
-### 🙏 Contributors
-
-A huge thank you to everyone who contributed to this release:
+#### Godot Game Engine Fixes
+- **GDScript Dependency Extraction**: Fixed 265+ "Syntax error in *.gd" warnings (commit 3e6c448)
+  - GDScript files were incorrectly routed to Python AST parser
+  - Created dedicated `_extract_gdscript_imports()` with regex patterns
+  - Now correctly parses `preload()`, `load()`, `extends` patterns
+  - Result: 377 dependencies extracted with 0 warnings
+
+- **Framework Detection False Positive**: Fixed Unity detection on Godot projects (commit 50b28fe)
+  - Was detecting "Unity" due to generic "Assets" keyword in comments
+  - Changed Unity markers to specific files: `Assembly-CSharp.csproj`, `UnityEngine.dll`, `Library/`
+  - Now correctly detects Godot via `project.godot`, `.godot` directory
+
+- **Circular Dependencies**: Fixed self-referential cycles (commit 50b28fe)
+  - 3 self-loop warnings (files depending on themselves)
+  - Added `target != file_path` check in dependency graph builder
+  - Result: 0 circular dependencies detected
+
+- **GDScript Test Discovery**: Fixed 0 test files found in Godot projects (commit 50b28fe)
+  - Added GDScript test patterns: `test_*.gd`, `*_test.gd`
+  - Added GDScript to LANGUAGE_MAP
+  - Result: 32 test files discovered (20 GUT files with 396 tests)
+
+- **GDScript Test Extraction**: Fixed "Language GDScript not supported" warning (commit c826690)
+  - Added GDScript regex patterns to PATTERNS dictionary
+  - Patterns: instantiation (`preload().new()`), assertions (`assert_eq`), signals (`.connect()`)
+  - Result: 22 test examples extracted successfully
+
+- **Config Extractor Array Handling**: Fixed JSON/YAML array parsing (commit fca0951)
+  - Error: `'list' object has no attribute 'items'` on root-level arrays
+  - Added isinstance checks for dict/list/primitive at root
+  - Result: No JSON array errors, save.json parsed correctly
+
+- **Progress Indicators**: Fixed missing progress for small batches (commit eec37f5)
+  - Progress only shown every 5 batches, invisible for small jobs
+  - Modified condition to always show for batches < 10
+  - Result: "Progress: 1/2 batches completed" now visible
+
+#### Other Fixes
+- **C# Test Extraction**: Fixed "Language C# not supported" error with language alias mapping
+- **Config Type Field Mismatch**: Fixed KeyError in `config_enhancer.py` by supporting both "type" and "config_type" fields
+- **LocalSkillEnhancer Import**: Fixed incorrect import and method call in `main.py` (SkillEnhancer → LocalSkillEnhancer)
+- **Code Quality**: Fixed 4 critical linter errors (unused imports, variables, arguments, import sorting)
 
-- **[@xuintl](https://github.com/xuintl)** - Chinese README improvements and documentation refinements
-- **[@Zhichang Yu](https://github.com/yuzhichang)** - GLM-4.7 support and PDF scraper fixes
-- **[@YusufKaraaslanSpyke](https://github.com/yusufkaraaslan)** - Core features, bug fixes, and project maintenance
+### Tests
+- **GDScript Test Extraction Test**: Added comprehensive test case for GDScript GUT/gdUnit4 framework
+  - Tests player instantiation with `preload()` and `load()`
+  - Tests signal connections and emissions
+  - Tests gdUnit4 `@test` annotation syntax
+  - Tests game state management patterns
+  - 4 test functions with 60+ lines of GDScript code
+  - Validates extraction of instantiations, assertions, and signal patterns
 
-Special thanks to all our community members who reported issues, provided feedback, and helped test new features. Your contributions make Skill Seekers better for everyone! 🎉
+### Removed
+- Removed client-specific documentation files from repository
 
 ---
 

CLAUDE.md

@@ -292,13 +292,27 @@ skill-seekers analyze --directory . --comprehensive
 # With AI enhancement (auto-detects API or LOCAL)
 skill-seekers analyze --directory . --enhance
 
+# Granular AI enhancement control (NEW)
+skill-seekers analyze --directory . --enhance-level 1  # SKILL.md only
+skill-seekers analyze --directory . --enhance-level 2  # + Architecture + Config + Docs
+skill-seekers analyze --directory . --enhance-level 3  # Full enhancement (all features)
+
 # Disable specific features
 skill-seekers analyze --directory . --skip-patterns --skip-how-to-guides
 ```
 
 - Generates 300+ line standalone SKILL.md files from codebases
 - All C3.x features integrated (patterns, tests, guides, config, architecture, docs)
 - Complete codebase analysis without documentation scraping
+- **NEW**: Granular AI enhancement control with `--enhance-level` (0-3)
+
+**C3.9 Project Documentation Extraction** (`codebase_scraper.py`):
+- Extracts and categorizes all markdown files from the project
+- Auto-detects categories: overview, architecture, guides, workflows, features, etc.
+- Integrates documentation into SKILL.md with summaries
+- AI enhancement (level 2+) adds topic extraction and cross-references
+- Controlled by depth: surface=raw copy, deep=parse+summarize, full=AI-enhanced
+- Default ON, use `--skip-docs` to disable
 
 **C3.9 Project Documentation Extraction** (`codebase_scraper.py`):
 - Extracts and categorizes all markdown files from the project

src/skill_seekers/cli/ai_enhancer.py

@@ -36,7 +36,6 @@
 # Import config manager for settings
 try:
     from skill_seekers.cli.config_manager import get_config_manager
-
     CONFIG_AVAILABLE = True
 except ImportError:
     CONFIG_AVAILABLE = False
@@ -108,9 +107,7 @@ def __init__(self, api_key: str | None = None, enabled: bool = True, mode: str =
                 logger.warning("⚠️  anthropic package not installed, falling back to LOCAL mode")
                 self.mode = "local"
             except Exception as e:
-                logger.warning(
-                    f"⚠️  Failed to initialize API client: {e}, falling back to LOCAL mode"
-                )
+                logger.warning(f"⚠️  Failed to initialize API client: {e}, falling back to LOCAL mode")
                 self.mode = "local"
 
         if self.mode == "local" and self.enabled:
@@ -215,8 +212,7 @@ def _call_claude_local(self, prompt: str) -> str | None:
                     except json.JSONDecodeError:
                         # Try to find JSON in the response
                         import re
-
-                        json_match = re.search(r"\[[\s\S]*\]|\{[\s\S]*\}", response_text)
+                        json_match = re.search(r'\[[\s\S]*\]|\{[\s\S]*\}', response_text)
                         if json_match:
                             return json_match.group()
                         logger.warning("⚠️  Could not parse JSON from LOCAL response")
@@ -302,7 +298,8 @@ def _enhance_patterns_parallel(self, batches: list[list[dict]], workers: int) ->
                 try:
                     results[idx] = future.result()
                     completed += 1
-                    if completed % 5 == 0 or completed == total:
+                    # Show progress: always for small jobs (<10), every 5 for larger jobs
+                    if total < 10 or completed % 5 == 0 or completed == total:
                         logger.info(f"   Progress: {completed}/{total} batches completed")
                 except Exception as e:
                     logger.warning(f"⚠️  Batch {idx} failed: {e}")
@@ -439,7 +436,8 @@ def _enhance_examples_parallel(self, batches: list[list[dict]], workers: int) ->
                 try:
                     results[idx] = future.result()
                     completed += 1
-                    if completed % 5 == 0 or completed == total:
+                    # Show progress: always for small jobs (<10), every 5 for larger jobs
+                    if total < 10 or completed % 5 == 0 or completed == total:
                         logger.info(f"   Progress: {completed}/{total} batches completed")
                 except Exception as e:
                     logger.warning(f"⚠️  Batch {idx} failed: {e}")

src/skill_seekers/cli/architectural_pattern_detector.py

@@ -88,6 +88,11 @@ class ArchitecturalPatternDetector:
 
     # Framework detection patterns
     FRAMEWORK_MARKERS = {
+        # Game Engines (checked first to avoid false positives)
+        "Unity": ["Assembly-CSharp.csproj", "UnityEngine.dll", "ProjectSettings/ProjectVersion.txt", ".unity", "Library/"],
+        "Unreal": ["Source/", ".uproject", "Config/DefaultEngine.ini", "Binaries/", "Content/"],
+        "Godot": ["project.godot", ".godot", ".tscn", ".tres", ".gd"],
+        # Web Frameworks
         "Django": ["django", "manage.py", "settings.py", "urls.py"],
         "Flask": ["flask", "app.py", "wsgi.py"],
         "Spring": ["springframework", "@Controller", "@Service", "@Repository"],
@@ -181,17 +186,48 @@ def _analyze_directory_structure(self, directory: Path) -> dict[str, int]:
 
         return dict(structure)
 
-    def _detect_frameworks(self, _directory: Path, files: list[dict]) -> list[str]:
+    def _detect_frameworks(self, directory: Path, files: list[dict]) -> list[str]:
         """Detect frameworks being used"""
         detected = []
 
-        # Check file paths and content
+        # Check file paths from analyzed files
         all_paths = [str(f.get("file", "")) for f in files]
         all_content = " ".join(all_paths)
 
+        # Also check actual directory structure for game engine markers
+        # (project.godot, .unity, .uproject are config files, not in analyzed files)
+        dir_files = []
+        try:
+            # Get all files and directories in the root (non-recursive for performance)
+            for item in directory.iterdir():
+                dir_files.append(item.name)
+        except Exception as e:
+            logger.warning(f"Could not scan directory for framework markers: {e}")
+
+        dir_content = " ".join(dir_files)
+
+        # Check game engines FIRST (priority detection)
+        for framework in ["Unity", "Unreal", "Godot"]:
+            if framework in self.FRAMEWORK_MARKERS:
+                markers = self.FRAMEWORK_MARKERS[framework]
+                # Check both analyzed files AND directory structure
+                file_matches = sum(1 for marker in markers if marker.lower() in all_content.lower())
+                dir_matches = sum(1 for marker in markers if marker.lower() in dir_content.lower())
+                total_matches = file_matches + dir_matches
+
+                if total_matches >= 2:
+                    detected.append(framework)
+                    logger.info(f"  📦 Detected framework: {framework}")
+                    # Return early to prevent web framework false positives
+                    return detected
+
+        # Check other frameworks
         for framework, markers in self.FRAMEWORK_MARKERS.items():
+            if framework in ["Unity", "Unreal", "Godot"]:
+                continue  # Already checked
+
             matches = sum(1 for marker in markers if marker.lower() in all_content.lower())
-            if matches >= 2:  # Require at least 2 markers
+            if matches >= 2:
                 detected.append(framework)
                 logger.info(f"  📦 Detected framework: {framework}")