moai-adk 0.8.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

moai_adk/core/project/__init__.py

@@ -1,2 +1 @@
-# @CODE:PY314-001 | SPEC: SPEC-PY314-001.md | TEST: tests/unit/test_foundation.py
 """Project module: initialization and management"""

moai_adk/core/project/backup_utils.py

@@ -1,4 +1,3 @@
-# @CODE:INIT-003:BACKUP | SPEC: .moai/specs/SPEC-INIT-003/spec.md | TEST: tests/unit/test_backup_utils.py
 """Backup utility module (SPEC-INIT-003 v0.3.0)
 
 Selective backup strategy:
@@ -10,7 +9,7 @@ from pathlib import Path
 
 # Backup targets (OR condition - back up when any exist)
 BACKUP_TARGETS = [
-    ".moai/config.json",
+    ".moai/config/config.json",
     ".moai/project/",
     ".moai/memory/",
     ".claude/",
@@ -58,8 +57,6 @@ def get_backup_targets(project_path: Path) -> list[str]:
     return targets
 
 
-
-
 def is_protected_path(rel_path: Path) -> bool:
     """Check whether the path is protected.
 
@@ -70,6 +67,4 @@ def is_protected_path(rel_path: Path) -> bool:
         True when the path should be excluded from backups.
     """
     rel_str = str(rel_path).replace("\\", "/")
-    return any(
-        rel_str.startswith(p.lstrip("./").rstrip("/")) for p in PROTECTED_PATHS
-    )
+    return any(rel_str.startswith(p.lstrip("./").rstrip("/")) for p in PROTECTED_PATHS)

moai_adk/core/project/checker.py

@@ -1,4 +1,3 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001.md | TEST: tests/unit/test_cli_commands.py
 """System requirements validation module.
 
 Checks whether required and optional tools are installed.
@@ -24,7 +23,6 @@ class SystemChecker:
         "docker": "docker --version",
     }
 
-    # @CODE:CLI-001:DATA - Language toolchain mapping (20 languages)
     LANGUAGE_TOOLS: dict[str, dict[str, list[str]]] = {
         "python": {
             "required": ["python3", "pip"],
@@ -260,10 +258,10 @@ def check_environment() -> dict[str, bool]:
         Mapping from check description to boolean status.
     """
     return {
-        "Python >= 3.13": sys.version_info >= (3, 13),
+        "Python >= 3.11": sys.version_info >= (3, 11),
         "Git installed": shutil.which("git") is not None,
         "Project structure (.moai/)": Path(".moai").exists(),
-        "Config file (.moai/config.json)": Path(".moai/config.json").exists(),
+        "Config file (.moai/config/config.yaml)": Path(".moai/config/config.yaml").exists(),
     }
 
 

moai_adk/core/project/detector.py

@@ -1,8 +1,13 @@
-# @CODE:CORE-PROJECT-001 | SPEC: SPEC-CORE-PROJECT-001.md | TEST: tests/unit/test_language_detector.py
-# @CODE:LANG-DETECT-001 | SPEC: SPEC-LANG-DETECT-001.md | TEST: tests/unit/test_detector.py
+# TEST: tests/unit/test_language_detector_extended.py
 """Language detector module.
 
 Automatically detects 20 programming languages.
+
+Extended detection supports:
+- 11 new languages: Ruby, PHP, Java, Rust, Dart, Swift, Kotlin, C#, C, C++, Shell
+- 5 build tool detection: Maven, Gradle, CMake, SPM, dotnet
+- Package manager detection: bundle, composer, cargo
+- Priority conflict resolution for multi-language projects
 """
 
 from pathlib import Path
@@ -16,41 +21,44 @@ class LanguageDetector:
     """
 
     LANGUAGE_PATTERNS = {
-        # Ruby moved to top for priority (Rails detection over generic frameworks)
-        # @CODE:LANG-DETECT-RUBY-001 | SPEC: Issue #51 Language Detection Fix
+        # Priority order (highest to lowest):
+        # 1. Rust, 2. Dart, 3. Swift, 4. Kotlin, 5. C#, 6. Java, 7. Ruby, 8. PHP
+        # 9. Go, 10. Python, 11. TypeScript, 12. JavaScript, 13. C++, 14. C, 15. Shell
+        "rust": ["*.rs", "Cargo.toml"],
+        "dart": ["*.dart", "pubspec.yaml"],
+        "swift": ["*.swift", "Package.swift"],
+        "kotlin": ["*.kt", "build.gradle.kts"],
+        "csharp": ["*.cs", "*.csproj"],
+        "java": ["*.java", "pom.xml", "build.gradle"],
+        # Ruby moved for priority (Rails detection)
         "ruby": [
             "*.rb",
             "Gemfile",
-            "Gemfile.lock",           # Bundler: lock file (unique to Ruby)
-            "config/routes.rb",       # Rails: routing file (unique identifier)
-            "app/controllers/",       # Rails: controller directory
-            "Rakefile"                # Rails/Ruby: task file
+            "Gemfile.lock",  # Bundler: lock file (unique to Ruby)
+            "config/routes.rb",  # Rails: routing file (unique identifier)
+            "app/controllers/",  # Rails: controller directory
+            "Rakefile",  # Rails/Ruby: task file
         ],
-        # PHP moved to second for priority (Laravel detection after Rails)
+        # PHP after Ruby (Laravel detection)
         "php": [
             "*.php",
             "composer.json",
-            "artisan",                # Laravel: CLI tool (unique identifier)
-            "app/",                   # Laravel: application directory
-            "bootstrap/laravel.php"   # Laravel: bootstrap file
+            "artisan",  # Laravel: CLI tool (unique identifier)
+            "app/",  # Laravel: application directory
+            "bootstrap/laravel.php",  # Laravel: bootstrap file
         ],
+        "go": ["*.go", "go.mod"],
         "python": ["*.py", "pyproject.toml", "requirements.txt", "setup.py"],
         "typescript": ["*.ts", "tsconfig.json"],
         "javascript": ["*.js", "package.json"],
-        "java": ["*.java", "pom.xml", "build.gradle"],
-        "go": ["*.go", "go.mod"],
-        "rust": ["*.rs", "Cargo.toml"],
-        "dart": ["*.dart", "pubspec.yaml"],
-        "swift": ["*.swift", "Package.swift"],
-        "kotlin": ["*.kt", "build.gradle.kts"],
-        "csharp": ["*.cs", "*.csproj"],
+        "cpp": ["*.cpp", "CMakeLists.txt"],
+        "c": ["*.c", "Makefile"],
+        "shell": ["*.sh", "*.bash"],
+        # Additional languages (lower priority)
         "elixir": ["*.ex", "mix.exs"],
         "scala": ["*.scala", "build.sbt"],
         "clojure": ["*.clj", "project.clj"],
         "haskell": ["*.hs", "*.cabal"],
-        "c": ["*.c", "Makefile"],
-        "cpp": ["*.cpp", "CMakeLists.txt"],
-        "shell": ["*.sh", "*.bash"],
         "lua": ["*.lua"],
     }
 
@@ -112,6 +120,165 @@ class LanguageDetector:
 
         return False
 
+    def get_workflow_template_path(self, language: str) -> str:
+        """Get the GitHub Actions workflow template path for a language.
+
+
+        Args:
+            language: Programming language name (lowercase).
+
+        Returns:
+            Workflow template file path relative to templates directory.
+
+        Raises:
+            ValueError: If language is not supported for workflows.
+        """
+        # Language-specific workflow template mapping
+        workflow_templates = {
+            "python": "python-tag-validation.yml",
+            "javascript": "javascript-tag-validation.yml",
+            "typescript": "typescript-tag-validation.yml",
+            "go": "go-tag-validation.yml",
+        }
+
+        if language not in workflow_templates:
+            raise ValueError(f"Language '{language}' is not supported for workflows")
+
+        return workflow_templates[language]
+
+    def detect_package_manager(self, path: str | Path = ".") -> str | None:
+        """Detect the package manager for the detected language.
+
+
+        Args:
+            path: Directory to inspect.
+
+        Returns:
+            Package manager name or None if not detected.
+        """
+        path = Path(path)
+
+        # Ruby
+        if (path / "Gemfile").exists():
+            return "bundle"
+
+        # PHP
+        if (path / "composer.json").exists():
+            return "composer"
+
+        # Java/Kotlin
+        if (path / "pom.xml").exists():
+            return "maven"
+        if (path / "build.gradle").exists() or (path / "build.gradle.kts").exists():
+            return "gradle"
+
+        # Rust
+        if (path / "Cargo.toml").exists():
+            return "cargo"
+
+        # Dart/Flutter
+        if (path / "pubspec.yaml").exists():
+            return "dart_pub"
+
+        # Swift
+        if (path / "Package.swift").exists():
+            return "spm"
+
+        # C#
+        if list(path.glob("*.csproj")) or list(path.glob("*.sln")):
+            return "dotnet"
+
+        # Python
+        if (path / "pyproject.toml").exists():
+            return "pip"
+
+        # JavaScript/TypeScript (check in priority order)
+        # Check for lock files and package managers
+        if (path / "bun.lockb").exists():
+            return "bun"
+        elif (path / "pnpm-lock.yaml").exists():
+            return "pnpm"
+        elif (path / "yarn.lock").exists():
+            return "yarn"
+        elif (path / "package-lock.json").exists():
+            return "npm"
+        elif (path / "package.json").exists():
+            # Default to npm for package.json without lock files
+            return "npm"
+
+        # Go
+        if (path / "go.mod").exists():
+            return "go_modules"
+
+        return None
+
+    def detect_build_tool(self, path: str | Path = ".", language: str | None = None) -> str | None:
+        """Detect the build tool for the detected language.
+
+
+        Args:
+            path: Directory to inspect.
+            language: Optional language hint for disambiguation.
+
+        Returns:
+            Build tool name or None if not detected.
+        """
+        path = Path(path)
+
+        # C/C++
+        if (path / "CMakeLists.txt").exists():
+            return "cmake"
+        if (path / "Makefile").exists():
+            return "make"
+
+        # Java/Kotlin
+        if language in ["java", "kotlin"]:
+            if (path / "pom.xml").exists():
+                return "maven"
+            if (path / "build.gradle").exists() or (path / "build.gradle.kts").exists():
+                return "gradle"
+
+        # Rust
+        if (path / "Cargo.toml").exists():
+            return "cargo"
+
+        # Swift
+        if (path / "Package.swift").exists():
+            return "spm"
+        if list(path.glob("*.xcodeproj")) or list(path.glob("*.xcworkspace")):
+            return "xcode"
+
+        # C#
+        if list(path.glob("*.csproj")) or list(path.glob("*.sln")):
+            return "dotnet"
+
+        return None
+
+    def get_supported_languages_for_workflows(self) -> list[str]:
+        """Get the list of languages with dedicated CI/CD workflow support.
+
+
+        Returns:
+            List of supported language names (15 total).
+        """
+        return [
+            "python",
+            "javascript",
+            "typescript",
+            "go",
+            "ruby",
+            "php",
+            "java",
+            "rust",
+            "dart",
+            "swift",
+            "kotlin",
+            "csharp",
+            "c",
+            "cpp",
+            "shell",
+        ]
+
 
 def detect_project_language(path: str | Path = ".") -> str | None:
     """Detect the project language (helper).

moai_adk/core/project/initializer.py

@@ -1,4 +1,3 @@
-# @CODE:CORE-PROJECT-001 | @CODE:INIT-003:INIT
 # SPEC: SPEC-CORE-PROJECT-001.md, SPEC-INIT-003.md
 # TEST: tests/unit/test_project_initializer.py, tests/unit/test_init_reinit.py
 """Project Initialization Module
@@ -10,11 +9,15 @@ Phase-based 5-step initialization process:
 4. Configuration: Generate configuration files
 5. Validation: Verification and finalization
 """
+# type: ignore
 
+import json
+import stat
 import time
+from datetime import datetime
 from pathlib import Path
 
-from moai_adk.core.project.phase_executor import PhaseExecutor, ProgressCallback
+from moai_adk.core.project.phase_executor import PhaseExecutor, ProgressCallback  # type: ignore
 from moai_adk.core.project.validator import ProjectValidator
 
 
@@ -55,11 +58,120 @@ class ProjectInitializer:
         self.validator = ProjectValidator()
         self.executor = PhaseExecutor(self.validator)
 
+    def _create_memory_files(self) -> list[str]:
+        """Create runtime session and memory files (auto-generated per user/session)
+
+        Returns:
+            List of created memory files
+
+        """
+        memory_dir = self.path / ".moai" / "memory"
+        memory_dir.mkdir(parents=True, exist_ok=True)
+        created_files = []
+
+        # 1. project-notes.json - Project tracking notes (empty on init)
+        project_notes = {
+            "tech_debt": [],
+            "performance_bottlenecks": [],
+            "recent_patterns": {
+                "frequent_file_edits": [],
+                "test_failures": [],
+                "git_operations": "daily commits, feature branches",
+            },
+            "next_priorities": [],
+        }
+        project_notes_file = memory_dir / "project-notes.json"
+        project_notes_file.write_text(json.dumps(project_notes, indent=2))
+        created_files.append(str(project_notes_file))
+
+        # 2. session-hint.json - Last session state
+        session_hint = {
+            "last_command": None,
+            "command_timestamp": None,
+            "hours_ago": None,
+            "active_spec": None,
+            "current_branch": "main",
+        }
+        session_hint_file = memory_dir / "session-hint.json"
+        session_hint_file.write_text(json.dumps(session_hint, indent=2))
+        created_files.append(str(session_hint_file))
+
+        # 3. user-patterns.json - User preferences and expertise
+        user_patterns = {
+            "tech_preferences": {},
+            "expertise_signals": {
+                "ask_question_skip_rate": 0.0,
+                "custom_workflows": 0,
+                "estimated_level": "beginner",
+            },
+            "skip_questions": [],
+            "last_updated": datetime.now().isoformat() + "Z",
+        }
+        user_patterns_file = memory_dir / "user-patterns.json"
+        user_patterns_file.write_text(json.dumps(user_patterns, indent=2))
+        created_files.append(str(user_patterns_file))
+
+        return created_files
+
+    def _create_user_settings(self) -> list[str]:
+        """Create user-specific settings files (.claude/settings.local.json)
+
+        Returns:
+            List of created settings files
+        """
+        created_files = []
+        claude_dir = self.path / ".claude"
+        claude_dir.mkdir(parents=True, exist_ok=True)
+
+        # Create settings.local.json
+        settings_local = {
+            "_meta": {
+                "description": "User-specific Claude Code settings (gitignored - never commit)",
+                "created_at": datetime.now().isoformat() + "Z",
+                "note": "Edit this file to customize your local development environment",
+            },
+            "enabledMcpjsonServers": ["context7"],  # context7 is mandatory
+        }
+
+        # Add companyAnnouncements in user's selected language
+        try:
+            import sys
+
+            utils_dir = (
+                Path(__file__).parent.parent.parent / "templates" / ".claude" / "hooks" / "moai" / "shared" / "utils"
+            )
+
+            if utils_dir.exists():
+                sys.path.insert(0, str(utils_dir))
+                try:
+                    from announcement_translator import (
+                        get_language_from_config,
+                        translate_announcements,
+                    )
+
+                    language = get_language_from_config(self.path)
+                    announcements = translate_announcements(language, self.path)
+                    settings_local["companyAnnouncements"] = announcements
+                except Exception as e:
+                    print(f"[ProjectInitializer] Warning: Failed to add announcements: {e}")
+                finally:
+                    sys.path.remove(str(utils_dir))
+
+        except Exception as e:
+            print(f"[ProjectInitializer] Warning: Announcement module not available: {e}")
+
+        settings_local_file = claude_dir / "settings.local.json"
+        settings_local_file.write_text(json.dumps(settings_local, indent=2, ensure_ascii=False))
+        created_files.append(str(settings_local_file))
+
+        return created_files
+
     def initialize(
         self,
         mode: str = "personal",
-        locale: str = "ko",
+        locale: str = "en",  # Changed from "ko" to "en" (will be configurable in /moai:0-project)
         language: str | None = None,
+        custom_language: str | None = None,
         backup_enabled: bool = True,
         progress_callback: ProgressCallback | None = None,
         reinit: bool = False,
@@ -67,9 +179,10 @@ class ProjectInitializer:
         """Execute project initialization (5-phase process)
 
         Args:
-            mode: Project mode (personal/team)
-            locale: Locale (ko/en/ja/zh)
-            language: Force language specification (auto-detect if None)
+            mode: Project mode (personal/team) - Default: personal (configurable in /moai:0-project)
+            locale: Locale (ko/en/ja/zh/other) - Default: en (configurable in /moai:0-project)
+            language: Force language specification (auto-detect if None) - Will be detected in /moai:0-project
+            custom_language: Custom language name when locale="other" (user input)
             backup_enabled: Whether to enable backup
             progress_callback: Progress callback
             reinit: Reinitialization mode (v0.3.0, SPEC-INIT-003)
@@ -91,13 +204,11 @@ class ProjectInitializer:
                 )
 
             # Use provided language or default to generic
-            # Language detection now happens in /alfred:0-project via project-manager
+            # Language detection now happens in /moai:0-project via project-manager
             detected_language = language or "generic"
 
             # Phase 1: Preparation (backup and validation)
-            self.executor.execute_preparation_phase(
-                self.path, backup_enabled, progress_callback
-            )
+            self.executor.execute_preparation_phase(self.path, backup_enabled, progress_callback)
 
             # Phase 2: Directory (create directories)
             self.executor.execute_directory_phase(self.path, progress_callback)
@@ -114,35 +225,117 @@ class ProjectInitializer:
             }
 
             # Phase 3: Resource (copy templates with variable substitution)
-            resource_files = self.executor.execute_resource_phase(
-                self.path, config, progress_callback
-            )
+            resource_files = self.executor.execute_resource_phase(self.path, config, progress_callback)
+
+            # Post-Phase 3: Fix shell script permissions
+            # git may not preserve file permissions, so explicitly set them
+            scripts_dir = self.path / ".moai" / "scripts"
+            if scripts_dir.exists():
+                for script_file in scripts_dir.glob("*.sh"):
+                    try:
+                        current_mode = script_file.stat().st_mode
+                        new_mode = current_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH
+                        # On Windows, chmod has limited effect, but we try anyway
+                        # or check os.name != 'nt' if strict behavior is needed.
+                        # For now, we just apply it and ignore errors if it fails.
+                        script_file.chmod(new_mode)
+                    except Exception:
+                        pass  # Silently ignore permission errors
 
             # Phase 4: Configuration (generate config.json)
+            # Handle language configuration
+            language_config = {}
+            if locale == "other" and custom_language:
+                language_config = {
+                    "conversation_language": "other",
+                    "conversation_language_name": custom_language,
+                }
+            elif locale in ["ko", "en", "ja", "zh"]:
+                language_names = {
+                    "ko": "Korean",
+                    "en": "English",
+                    "ja": "Japanese",
+                    "zh": "Chinese",
+                }
+                language_config = {
+                    "conversation_language": locale,
+                    "conversation_language_name": language_names.get(locale, "English"),
+                }
+            else:
+                # Default fallback
+                language_config = {
+                    "conversation_language": locale,
+                    "conversation_language_name": "English",
+                }
+
             config_data: dict[str, str | bool | dict] = {
                 "project": {
                     "name": self.path.name,
                     "mode": mode,
                     "locale": locale,
                     "language": detected_language,
-                    # Language detection metadata (will be updated by project-manager via /alfred:0-project)
+                    # Language detection metadata (will be updated by project-manager via /moai:0-project)
                     "language_detection": {
                         "detected_language": detected_language,
-                        "detection_method": "cli_default",  # Will be "context_aware" after /alfred:0-project
+                        "detection_method": "cli_default",  # Will be "context_aware" after /moai:0-project
                         "confidence": None,  # Will be calculated by project-manager
                         "markers": [],  # Will be populated by project-manager
                         "confirmed_by": None,  # Will be "user" after project-manager confirmation
-                    }
-                }
+                    },
+                },
+                "language": language_config,
+                "constitution": {
+                    "enforce_tdd": True,
+                    "test_coverage_target": 85,
+                },
+                "git_strategy": {
+                    "personal": {
+                        "auto_checkpoint": "disabled",
+                        "checkpoint_events": [
+                            "delete",
+                            "refactor",
+                            "merge",
+                            "script",
+                            "critical-file",
+                        ],
+                        "checkpoint_type": "local-branch",
+                        "max_checkpoints": 10,
+                        "cleanup_days": 7,
+                        "push_to_remote": False,
+                        "auto_commit": True,
+                        "branch_prefix": "feature/SPEC-",
+                        "develop_branch": "develop",
+                        "main_branch": "main",
+                        "prevent_branch_creation": False,
+                        "work_on_main": False,
+                    },
+                    "team": {
+                        "auto_pr": False,
+                        "develop_branch": "develop",
+                        "draft_pr": False,
+                        "branch_prefix": "feature/SPEC-",
+                        "main_branch": "main",
+                        "use_gitflow": True,
+                        "default_pr_base": "develop",
+                        "prevent_main_direct_merge": False,
+                    },
+                },
+                "session": {
+                    "suppress_setup_messages": False,
+                    "notes": "suppress_setup_messages: false enables SessionStart output. "
+                    "Set to true to suppress messages (show again after 7 days)",
+                },
             }
-            config_files = self.executor.execute_configuration_phase(
-                self.path, config_data, progress_callback
-            )
+            config_files = self.executor.execute_configuration_phase(self.path, config_data, progress_callback)
 
             # Phase 5: Validation (verify and finalize)
-            self.executor.execute_validation_phase(
-                self.path, mode, progress_callback
-            )
+            self.executor.execute_validation_phase(self.path, mode, progress_callback)
+
+            # Phase 6: Create runtime memory files (auto-generated per user/session)
+            memory_files = self._create_memory_files()
+
+            # Phase 7: Create user settings (gitignored, user-specific)
+            user_settings_files = self._create_user_settings()
 
             # Generate result
             duration = int((time.time() - start_time) * 1000)  # ms
@@ -153,7 +346,7 @@ class ProjectInitializer:
                 mode=mode,
                 locale=locale,
                 duration=duration,
-                created_files=resource_files + config_files,
+                created_files=resource_files + config_files + memory_files + user_settings_files,
             )
 
         except Exception as e:
@@ -178,9 +371,7 @@ class ProjectInitializer:
         return (self.path / ".moai").exists()
 
 
-def initialize_project(
-    project_path: Path, progress_callback: ProgressCallback | None = None
-) -> InstallationResult:
+def initialize_project(project_path: Path, progress_callback: ProgressCallback | None = None) -> InstallationResult:
     """Initialize project (for CLI command)
 
     Args: