thanh-kit 2.5.0

package/templates/skills/better-auth/scripts/tests/test_better_auth_init.py

@@ -0,0 +1,421 @@
+"""
+Tests for better_auth_init.py
+
+Covers main functionality with mocked I/O and file operations.
+Target: >80% coverage
+"""
+
+import sys
+import pytest
+from pathlib import Path
+from unittest.mock import Mock, patch, mock_open, MagicMock
+from io import StringIO
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from better_auth_init import BetterAuthInit, EnvConfig, main
+
+
+@pytest.fixture
+def mock_project_root(tmp_path):
+    """Create mock project root with package.json."""
+    (tmp_path / "package.json").write_text("{}")
+    return tmp_path
+
+
+@pytest.fixture
+def auth_init(mock_project_root):
+    """Create BetterAuthInit instance with mock project root."""
+    return BetterAuthInit(project_root=mock_project_root)
+
+
+class TestBetterAuthInit:
+    """Test BetterAuthInit class."""
+
+    def test_init_with_project_root(self, mock_project_root):
+        """Test initialization with explicit project root."""
+        init = BetterAuthInit(project_root=mock_project_root)
+        assert init.project_root == mock_project_root
+        assert init.env_config is None
+
+    def test_find_project_root_success(self, mock_project_root, monkeypatch):
+        """Test finding project root successfully."""
+        monkeypatch.chdir(mock_project_root)
+        init = BetterAuthInit()
+        assert init.project_root == mock_project_root
+
+    def test_find_project_root_failure(self, tmp_path, monkeypatch):
+        """Test failure to find project root."""
+        # Create path without package.json
+        no_package_dir = tmp_path / "no-package"
+        no_package_dir.mkdir()
+        monkeypatch.chdir(no_package_dir)
+
+        # Mock parent to stop infinite loop
+        with patch.object(Path, "parent", new_callable=lambda: property(lambda self: self)):
+            with pytest.raises(RuntimeError, match="Could not find project root"):
+                BetterAuthInit()
+
+    def test_generate_secret(self):
+        """Test secret generation."""
+        secret = BetterAuthInit.generate_secret()
+        assert len(secret) == 64  # 32 bytes = 64 hex chars
+        assert all(c in "0123456789abcdef" for c in secret)
+
+        # Test custom length
+        secret = BetterAuthInit.generate_secret(length=16)
+        assert len(secret) == 32  # 16 bytes = 32 hex chars
+
+    def test_parse_env_file(self, tmp_path):
+        """Test parsing .env file."""
+        env_content = """
+# Comment
+KEY1=value1
+KEY2="value2"
+KEY3='value3'
+INVALID LINE
+KEY4=value=with=equals
+"""
+        env_file = tmp_path / ".env"
+        env_file.write_text(env_content)
+
+        result = BetterAuthInit._parse_env_file(env_file)
+
+        assert result["KEY1"] == "value1"
+        assert result["KEY2"] == "value2"
+        assert result["KEY3"] == "value3"
+        assert result["KEY4"] == "value=with=equals"
+        assert "INVALID" not in result
+
+    def test_parse_env_file_missing(self, tmp_path):
+        """Test parsing missing .env file."""
+        result = BetterAuthInit._parse_env_file(tmp_path / "nonexistent.env")
+        assert result == {}
+
+    def test_load_env_files(self, auth_init, mock_project_root):
+        """Test loading environment variables from multiple files."""
+        # Create .env files
+        claude_env = mock_project_root / ".claude" / ".env"
+        claude_env.parent.mkdir(parents=True, exist_ok=True)
+        claude_env.write_text("BASE_VAR=base\nOVERRIDE=claude")
+
+        skills_env = mock_project_root / ".claude" / "skills" / ".env"
+        skills_env.parent.mkdir(parents=True, exist_ok=True)
+        skills_env.write_text("OVERRIDE=skills\nSKILLS_VAR=skills")
+
+        # Mock process env (highest priority)
+        with patch.dict("os.environ", {"OVERRIDE": "process", "PROCESS_VAR": "process"}):
+            result = auth_init._load_env_files()
+
+        assert result["BASE_VAR"] == "base"
+        assert result["SKILLS_VAR"] == "skills"
+        assert result["OVERRIDE"] == "process"  # Process env wins
+        assert result["PROCESS_VAR"] == "process"
+
+    def test_prompt_direct_db_sqlite(self, auth_init):
+        """Test prompting for SQLite database."""
+        with patch("builtins.input", side_effect=["3", "./test.db"]):
+            config = auth_init._prompt_direct_db()
+
+        assert config["type"] == "sqlite"
+        assert "better-sqlite3" in config["import"]
+        assert "./test.db" in config["config"]
+
+    def test_prompt_direct_db_postgresql(self, auth_init):
+        """Test prompting for PostgreSQL database."""
+        with patch("builtins.input", side_effect=["1", "postgresql://localhost/test"]):
+            config = auth_init._prompt_direct_db()
+
+        assert config["type"] == "postgresql"
+        assert "pg" in config["import"]
+        assert config["env_var"] == ("DATABASE_URL", "postgresql://localhost/test")
+
+    def test_prompt_direct_db_mysql(self, auth_init):
+        """Test prompting for MySQL database."""
+        with patch("builtins.input", side_effect=["2", "mysql://localhost/test"]):
+            config = auth_init._prompt_direct_db()
+
+        assert config["type"] == "mysql"
+        assert "mysql2" in config["import"]
+        assert config["env_var"][0] == "DATABASE_URL"
+
+    def test_prompt_drizzle(self, auth_init):
+        """Test prompting for Drizzle ORM."""
+        with patch("builtins.input", return_value="1"):
+            config = auth_init._prompt_drizzle()
+
+        assert config["type"] == "drizzle"
+        assert config["provider"] == "pg"
+        assert "drizzleAdapter" in config["import"]
+        assert "drizzleAdapter" in config["config"]
+
+    def test_prompt_prisma(self, auth_init):
+        """Test prompting for Prisma."""
+        with patch("builtins.input", return_value="2"):
+            config = auth_init._prompt_prisma()
+
+        assert config["type"] == "prisma"
+        assert config["provider"] == "mysql"
+        assert "prismaAdapter" in config["import"]
+        assert "PrismaClient" in config["import"]
+
+    def test_prompt_kysely(self, auth_init):
+        """Test prompting for Kysely."""
+        config = auth_init._prompt_kysely()
+
+        assert config["type"] == "kysely"
+        assert "kyselyAdapter" in config["import"]
+
+    def test_prompt_mongodb(self, auth_init):
+        """Test prompting for MongoDB."""
+        with patch("builtins.input", side_effect=["mongodb://localhost/test", "mydb"]):
+            config = auth_init._prompt_mongodb()
+
+        assert config["type"] == "mongodb"
+        assert "mongodbAdapter" in config["import"]
+        assert "mydb" in config["config"]
+        assert config["env_var"] == ("MONGODB_URI", "mongodb://localhost/test")
+
+    def test_prompt_database(self, auth_init):
+        """Test database prompting with different choices."""
+        # Test valid choice
+        with patch("builtins.input", side_effect=["3", "1"]):
+            config = auth_init.prompt_database()
+        assert config["type"] == "prisma"
+
+        # Test invalid choice (defaults to direct DB)
+        with patch("builtins.input", side_effect=["99", "1", "postgresql://localhost/test"]):
+            with patch("builtins.print"):
+                config = auth_init.prompt_database()
+        assert config["type"] == "postgresql"
+
+    def test_prompt_auth_methods(self, auth_init):
+        """Test prompting for authentication methods."""
+        with patch("builtins.input", return_value="1 2 3 5 8"):
+            with patch("builtins.print"):
+                methods = auth_init.prompt_auth_methods()
+
+        assert methods == ["1", "2", "3", "5", "8"]
+
+    def test_prompt_auth_methods_invalid(self, auth_init):
+        """Test filtering invalid auth method choices."""
+        with patch("builtins.input", return_value="1 99 abc 3"):
+            with patch("builtins.print"):
+                methods = auth_init.prompt_auth_methods()
+
+        assert methods == ["1", "3"]
+
+    def test_generate_auth_config_basic(self, auth_init):
+        """Test generating basic auth config."""
+        db_config = {
+            "import": "import Database from 'better-sqlite3';",
+            "config": "database: new Database('./dev.db')"
+        }
+        auth_methods = ["1"]  # Email/password only
+
+        config = auth_init.generate_auth_config(db_config, auth_methods)
+
+        assert "import { betterAuth }" in config
+        assert "emailAndPassword" in config
+        assert "enabled: true" in config
+        assert "better-sqlite3" in config
+
+    def test_generate_auth_config_with_oauth(self, auth_init):
+        """Test generating config with OAuth providers."""
+        db_config = {
+            "import": "import { Pool } from 'pg';",
+            "config": "database: new Pool()"
+        }
+        auth_methods = ["1", "2", "3", "4"]  # Email + GitHub + Google + Discord
+
+        config = auth_init.generate_auth_config(db_config, auth_methods)
+
+        assert "socialProviders" in config
+        assert "github:" in config
+        assert "google:" in config
+        assert "discord:" in config
+        assert "GITHUB_CLIENT_ID" in config
+        assert "GOOGLE_CLIENT_ID" in config
+        assert "DISCORD_CLIENT_ID" in config
+
+    def test_generate_auth_config_with_plugins(self, auth_init):
+        """Test generating config with plugins."""
+        db_config = {"import": "", "config": "database: db"}
+        auth_methods = ["5", "6", "7", "8"]  # 2FA, Passkey, Magic Link, Username
+
+        config = auth_init.generate_auth_config(db_config, auth_methods)
+
+        assert "plugins:" in config
+        assert "twoFactor" in config
+        assert "passkey" in config
+        assert "magicLink" in config
+        assert "username" in config
+        assert "from 'better-auth/plugins'" in config
+
+    def test_generate_env_file_basic(self, auth_init):
+        """Test generating basic .env file."""
+        db_config = {"type": "sqlite"}
+        auth_methods = ["1"]
+
+        env_content = auth_init.generate_env_file(db_config, auth_methods)
+
+        assert "BETTER_AUTH_SECRET=" in env_content
+        assert "BETTER_AUTH_URL=http://localhost:3000" in env_content
+        assert len(env_content.split("\n")) >= 2
+
+    def test_generate_env_file_with_database_url(self, auth_init):
+        """Test generating .env with database URL."""
+        db_config = {
+            "env_var": ("DATABASE_URL", "postgresql://localhost/test")
+        }
+        auth_methods = []
+
+        env_content = auth_init.generate_env_file(db_config, auth_methods)
+
+        assert "DATABASE_URL=postgresql://localhost/test" in env_content
+
+    def test_generate_env_file_with_oauth(self, auth_init):
+        """Test generating .env with OAuth credentials."""
+        db_config = {}
+        auth_methods = ["2", "3", "4"]  # GitHub, Google, Discord
+
+        env_content = auth_init.generate_env_file(db_config, auth_methods)
+
+        assert "GITHUB_CLIENT_ID=" in env_content
+        assert "GITHUB_CLIENT_SECRET=" in env_content
+        assert "GOOGLE_CLIENT_ID=" in env_content
+        assert "GOOGLE_CLIENT_SECRET=" in env_content
+        assert "DISCORD_CLIENT_ID=" in env_content
+        assert "DISCORD_CLIENT_SECRET=" in env_content
+
+    def test_save_files(self, auth_init, mock_project_root):
+        """Test saving configuration files."""
+        auth_config = "// auth config"
+        env_content = "SECRET=test"
+
+        with patch("builtins.input", side_effect=["1"]):
+            auth_init._save_files(auth_config, env_content)
+
+        # Check auth.ts was saved
+        auth_path = mock_project_root / "lib" / "auth.ts"
+        assert auth_path.exists()
+        assert auth_path.read_text() == auth_config
+
+        # Check .env was saved
+        env_path = mock_project_root / ".env"
+        assert env_path.exists()
+        assert env_path.read_text() == env_content
+
+    def test_save_files_custom_path(self, auth_init, mock_project_root):
+        """Test saving with custom path."""
+        auth_config = "// config"
+        env_content = "SECRET=test"
+
+        custom_path = str(mock_project_root / "custom" / "auth.ts")
+        with patch("builtins.input", side_effect=["5", custom_path]):
+            auth_init._save_files(auth_config, env_content)
+
+        assert Path(custom_path).exists()
+
+    def test_save_files_backup_existing_env(self, auth_init, mock_project_root):
+        """Test backing up existing .env file."""
+        # Create existing .env
+        env_path = mock_project_root / ".env"
+        env_path.write_text("OLD_SECRET=old")
+
+        auth_config = "// config"
+        env_content = "NEW_SECRET=new"
+
+        with patch("builtins.input", return_value="1"):
+            auth_init._save_files(auth_config, env_content)
+
+        # Check backup was created
+        backup_path = mock_project_root / ".env.backup"
+        assert backup_path.exists()
+        assert backup_path.read_text() == "OLD_SECRET=old"
+
+        # Check new .env
+        assert env_path.read_text() == "NEW_SECRET=new"
+
+    def test_run_full_flow(self, auth_init, mock_project_root):
+        """Test complete run flow."""
+        inputs = [
+            "1",  # Direct DB
+            "1",  # PostgreSQL
+            "postgresql://localhost/test",
+            "1 2",  # Email + GitHub
+            "n"  # Don't save
+        ]
+
+        with patch("builtins.input", side_effect=inputs):
+            with patch("builtins.print"):
+                auth_init.run()
+
+        # Should complete without errors
+        # Files not saved because user chose 'n'
+        assert not (mock_project_root / "auth.ts").exists()
+
+    def test_run_save_files(self, auth_init, mock_project_root):
+        """Test run flow with file saving."""
+        inputs = [
+            "1",  # Direct DB
+            "3",  # SQLite
+            "",   # Default path
+            "1",  # Email only
+            "y",  # Save
+            "1"   # Save location
+        ]
+
+        with patch("builtins.input", side_effect=inputs):
+            with patch("builtins.print"):
+                auth_init.run()
+
+        # Check files were created
+        assert (mock_project_root / "lib" / "auth.ts").exists()
+        assert (mock_project_root / ".env").exists()
+
+
+class TestMainFunction:
+    """Test main entry point."""
+
+    def test_main_success(self, tmp_path, monkeypatch):
+        """Test successful main execution."""
+        (tmp_path / "package.json").write_text("{}")
+        monkeypatch.chdir(tmp_path)
+
+        inputs = ["1", "3", "", "1", "n"]
+
+        with patch("builtins.input", side_effect=inputs):
+            with patch("builtins.print"):
+                exit_code = main()
+
+        assert exit_code == 0
+
+    def test_main_keyboard_interrupt(self, tmp_path, monkeypatch):
+        """Test main with keyboard interrupt."""
+        (tmp_path / "package.json").write_text("{}")
+        monkeypatch.chdir(tmp_path)
+
+        with patch("builtins.input", side_effect=KeyboardInterrupt()):
+            with patch("builtins.print"):
+                exit_code = main()
+
+        assert exit_code == 1
+
+    def test_main_error(self, tmp_path, monkeypatch):
+        """Test main with error."""
+        # No package.json - should fail
+        no_package = tmp_path / "no-package"
+        no_package.mkdir()
+        monkeypatch.chdir(no_package)
+
+        with patch.object(Path, "parent", new_callable=lambda: property(lambda self: self)):
+            with patch("sys.stderr", new_callable=StringIO):
+                exit_code = main()
+
+        assert exit_code == 1
+
+
+if __name__ == "__main__":
+    pytest.main([__file__, "-v", "--cov=better_auth_init", "--cov-report=term-missing"])

package/templates/skills/branch-comparison/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: branch-comparison
+description: Use when the user asks to compare branches, analyze git diffs, review changes between branches, update specifications based on code changes, or analyze what changed. Triggers on keywords like "compare branches", "git diff", "what changed", "branch comparison", "code changes", "spec update".
+allowed-tools: Read, Write, Edit, Bash, Grep, Glob, Task, TodoWrite
+---
+
+# Branch Comparison & Specification Update
+
+You are to operate as an expert full-stack dotnet angular principle developer, software architect, and technical analyst to analyze all file changes between branches, perform comprehensive impact analysis, and update specification documents.
+
+**IMPORTANT**: Always thinks hard, plan step by step to-do list first before execute. Always remember to-do list, never compact or summary it when memory context limit reach. Always preserve and carry your to-do list through every operation.
+
+---
+
+## Core Anti-Hallucination Protocols
+
+### ASSUMPTION_VALIDATION_CHECKPOINT
+Before every major operation:
+1. "What assumptions am I making about [X]?"
+2. "Have I verified this with actual code evidence?"
+3. "Could I be wrong about [specific pattern/relationship]?"
+
+### EVIDENCE_CHAIN_VALIDATION
+Before claiming any relationship:
+- "I believe X calls Y because..." → show actual code
+- "This follows pattern Z because..." → cite specific examples
+- "Service A owns B because..." → grep for actual boundaries
+
+### TOOL_EFFICIENCY_PROTOCOL
+- Batch multiple Grep searches into single calls with OR patterns
+- Use parallel Read operations for related files
+
+### CONTEXT_ANCHOR_SYSTEM
+Every 10 operations:
+1. Re-read the original task description
+2. Verify the current operation aligns with original goals
+3. Update the `Current Focus` in `## Progress` section
+
+---
+
+## PHASE 1: EXTERNAL MEMORY-DRIVEN BRANCH ANALYSIS
+
+Build a structured knowledge model in `ai_task_analysis_notes/[comparison-name].ai_task_analysis_notes_temp.md`.
+
+### PHASE 1A: INITIALIZATION AND DISCOVERY
+
+1. **Initialize** the analysis file with standard headings
+
+### GIT BRANCH ANALYSIS DISCOVERY
+
+**GIT_DIFF_COMPREHENSIVE_ANALYSIS**: Start with systematic git change detection:
+
+1. **Primary Change Detection Commands**:
+```bash
+git diff --name-status [source-branch]..[target-branch]
+git diff --stat [source-branch]..[target-branch]
+git log --oneline [source-branch]..[target-branch]
+```
+Document results under `## Git Diff Analysis` and `## Commit History`.
+
+2. **Change Impact & Scope Classification**: Document under `## Change Classification` and `## Change Scope Analysis`:
+   - Types: Frontend, Backend, Config, DB
+   - Purpose: Feature, Bug Fix, Refactor
+
+**RELATED_FILES_COMPREHENSIVE_DISCOVERY**: For each changed file, discover all related components:
+- Importers
+- Dependencies
+- Test files
+- API consumers
+- UI components
+
+Save ALL changed files AND related files to `## Comprehensive File List` with:
+- `filePath`
+- `changeType`
+- `relationshipType`
+- `impactLevel`
+- `serviceContext`
+
+**INTELLIGENT_SCOPE_MANAGEMENT**: If file list exceeds 75, prioritize by impactLevel (Critical > High > Medium > Low).
+
+### PHASE 1B: KNOWLEDGE GRAPH CONSTRUCTION
+
+**IMPORTANT: MUST DO WITH TODO LIST**
+
+For each file, document in `## Knowledge Graph`:
+- All standard fields from feature-implementation skill
+- Focus on change-specific context
+
+### PHASE 1C: OVERALL ANALYSIS
+
+Write comprehensive summary showing:
+- Complete end-to-end workflows discovered
+- Key architectural patterns and relationships
+- Business logic workflows affected
+- Integration points and dependencies
+
+---
+
+## PHASE 2: COMPREHENSIVE ANALYSIS AND PLANNING
+
+Generate detailed analysis under these headings:
+
+### 1. Code Review Analysis
+- Strengths
+- Weaknesses
+- Security concerns
+- Performance implications
+- Maintainability
+
+### 2. Refactoring Recommendations
+- Immediate improvements
+- Structural changes
+- Technical debt items
+
+### 3. Specification Update Plan
+- New Requirements Discovery
+- Test Specification Updates
+- Documentation Strategy
+
+---
+
+## PHASE 3: APPROVAL GATE
+
+**CRITICAL**: Present comprehensive analysis, code review, refactoring recommendations, and specification update plan for explicit approval. **DO NOT** proceed without it.
+
+---
+
+## PHASE 4: SPECIFICATION UPDATE EXECUTION
+
+Once approved, read existing specification document and update with:
+- Requirements
+- Test Specifications
+- Architecture Documentation
+- Code Review findings
+
+---
+
+## SUCCESS VALIDATION
+
+Verify updated specification accurately reflects all changes. Document under `## Specification Validation`.
+
+---
+
+## Branch Comparison Guidelines
+
+- **Evidence-Based Analysis**: Start with `git diff` and base all updates on concrete code changes
+- **Comprehensive Impact Assessment**: Analyze direct and indirect effects, including cross-service impacts
+- **Enterprise Architecture Awareness**: Respect platform patterns, CQRS, and Clean Architecture
+- **Quality-Focused Approach**: Perform thorough code review and identify refactoring opportunities
+- **Specification Completeness**: Ensure full traceability between code, requirements, and tests