moai-adk 0.9.0__py3-none-any.whl → 0.15.0__py3-none-any.whl

moai_adk/core/project/initializer.py

@@ -11,7 +11,9 @@ Phase-based 5-step initialization process:
 5. Validation: Verification and finalization
 """
 
+import json
 import time
+from datetime import datetime
 from pathlib import Path
 
 from moai_adk.core.project.phase_executor import PhaseExecutor, ProgressCallback
@@ -55,6 +57,62 @@ 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
+
+        @CODE:INIT-MEMORY-001 | Auto-generate session 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 initialize(
         self,
         mode: str = "personal",
@@ -144,6 +202,9 @@ class ProjectInitializer:
                 self.path, mode, progress_callback
             )
 
+            # Phase 6: Create runtime memory files (auto-generated per user/session)
+            memory_files = self._create_memory_files()
+
             # Generate result
             duration = int((time.time() - start_time) * 1000)  # ms
             return InstallationResult(
@@ -153,7 +214,7 @@ class ProjectInitializer:
                 mode=mode,
                 locale=locale,
                 duration=duration,
-                created_files=resource_files + config_files,
+                created_files=resource_files + config_files + memory_files,
             )
 
         except Exception as e:

moai_adk/core/project/phase_executor.py

@@ -1,4 +1,5 @@
 # @CODE:INIT-003:PHASE | SPEC: .moai/specs/SPEC-INIT-003/spec.md | TEST: tests/unit/test_init_reinit.py
+# @CODE:TEST-COVERAGE-001 | SPEC: SPEC-TEST-COVERAGE-001.md | TEST: tests/unit/test_phase_executor.py
 """Phase-based installation executor (SPEC-INIT-003 v0.4.2)
 
 Runs the project initialization across five phases:
@@ -7,6 +8,8 @@ Runs the project initialization across five phases:
 - Phase 3: Resource (copy templates while preserving user content)
 - Phase 4: Configuration (generate configuration files)
 - Phase 5: Validation (verify and finalize)
+
+Test coverage includes 5-phase integration tests with backup, configuration, and validation
 """
 
 import json
@@ -142,7 +145,7 @@ class PhaseExecutor:
         # Set template variable context (if provided)
         if config:
             # @TAG:LANG-FIX-001:PY-CONFIG | Read language from nested config structure
-            language_config = config.get("language", {})
+            language_config: dict[str, Any] = config.get("language", {})
             if not isinstance(language_config, dict):
                 language_config = {}
 
@@ -193,6 +196,43 @@ class PhaseExecutor:
             "Phase 4: Generating configurations...", progress_callback
         )
 
+        # Read existing config to preserve user settings (Issue #165)
+        config_path = project_path / ".moai" / "config.json"
+        existing_config: dict[str, Any] = {}
+        if config_path.exists():
+            try:
+                with open(config_path, "r", encoding="utf-8") as f:
+                    existing_config = json.load(f)
+            except (json.JSONDecodeError, OSError):
+                # If config reading fails, start fresh
+                existing_config = {}
+
+        # Merge user settings from existing config (preserve customization)
+        if existing_config:
+            # Preserve user.nickname if it exists
+            if "user" in existing_config and isinstance(existing_config.get("user"), dict):
+                if "user" not in config:
+                    config["user"] = {}
+                user_config = config["user"]
+                if isinstance(user_config, dict):
+                    existing_user = existing_config["user"]
+                    if isinstance(existing_user, dict) and "nickname" in existing_user:
+                        user_config["nickname"] = existing_user["nickname"]
+
+            # Preserve language settings if they exist
+            if "language" in existing_config and isinstance(existing_config.get("language"), dict):
+                if "language" not in config:
+                    config["language"] = {}
+                lang_config = config["language"]
+                if isinstance(lang_config, dict):
+                    existing_lang = existing_config["language"]
+                    if isinstance(existing_lang, dict):
+                        # Preserve conversation_language settings
+                        if "conversation_language" in existing_lang:
+                            lang_config["conversation_language"] = existing_lang["conversation_language"]
+                        if "conversation_language_name" in existing_lang:
+                            lang_config["conversation_language_name"] = existing_lang["conversation_language_name"]
+
         # Ensure project section exists and set defaults
         if "project" not in config:
             config["project"] = {}
@@ -202,7 +242,6 @@ class PhaseExecutor:
             project_config["optimized"] = False  # Default value
 
         # Write config.json
-        config_path = project_path / ".moai" / "config.json"
         with open(config_path, "w", encoding="utf-8") as f:
             json.dump(config, f, indent=2, ensure_ascii=False)
 
@@ -216,9 +255,8 @@ class PhaseExecutor:
     ) -> None:
         """Phase 5: validation and wrap-up.
 
-        @CODE:INIT-004:PHASE5 | Phase 5 verification logic
+        @CODE:INIT-PHASE-001 | Phase 5 verification logic
         @REQ:VALIDATION-001 | SPEC-INIT-004: Verify required files after initialization completion
-        @CODE:INIT-004:PHASE5-INTEGRATION | Integration of validation in Phase 5
 
         Args:
             project_path: Project path.
@@ -230,8 +268,8 @@ class PhaseExecutor:
             "Phase 5: Validation and finalization...", progress_callback
         )
 
-        # @CODE:INIT-004:VERIFY-001 | Validate installation results
-        # @CODE:INIT-004:VALIDATION-CHECK | Comprehensive installation validation
+        # Validate installation results
+        # Comprehensive installation validation
         # Verifies all required files including 4 Alfred command files:
         # - 0-project.md, 1-plan.md, 2-run.md, 3-sync.md
         self.validator.validate_installation(project_path)
@@ -312,8 +350,12 @@ class PhaseExecutor:
                 cwd=project_path,
                 check=True,
                 capture_output=True,
+                timeout=30,  # Default timeout for git operations
             )
             # Intentionally avoid printing to keep progress output clean
+        except subprocess.TimeoutExpired:
+            # Timeout is non-fatal
+            pass
         except subprocess.CalledProcessError:
             # Only log on error; failures are non-fatal
             pass

moai_adk/core/tags/ci_validator.py

@@ -16,6 +16,8 @@ import os
 from typing import Any, Dict, List, Optional
 
 import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util import Retry
 
 from .pre_commit_validator import (
     PreCommitValidator,
@@ -87,16 +89,44 @@ class CIValidator(PreCommitValidator):
             'Accept': 'application/vnd.github.v3+json'
         }
 
+        # Create session with retry strategy
+        session = requests.Session()
+        retry = Retry(
+            total=3,
+            backoff_factor=0.5,
+            status_forcelist=[500, 502, 503, 504],
+            allowed_methods=["GET"]
+        )
+        adapter = HTTPAdapter(max_retries=retry)
+        session.mount("https://", adapter)
+
         try:
-            response = requests.get(url, headers=headers, timeout=10)
+            # Dual timeout: (connect_timeout, read_timeout)
+            response = session.get(
+                url,
+                headers=headers,
+                timeout=(5, 10)
+            )
             response.raise_for_status()
 
             files_data = response.json()
             return [file_info['filename'] for file_info in files_data]
 
-        except Exception:
-            # Return empty list on any error (network, auth, etc.)
+        except requests.exceptions.Timeout:
+            # Network timeout - return empty list gracefully
+            return []
+        except requests.exceptions.HTTPError as e:
+            # HTTP error (4xx, 5xx)
+            if e.response.status_code == 404:
+                # PR not found
+                return []
+            # Other HTTP errors: log but continue
+            return []
+        except requests.exceptions.RequestException:
+            # Network/connection errors
             return []
+        finally:
+            session.close()
 
     def validate_pr_changes(
         self,
@@ -260,7 +290,7 @@ class CIValidator(PreCommitValidator):
                 tag = error.tag
                 message = error.message
                 locations = ', '.join([
-                    f"`{f}:{l}`" for f, l in error.locations[:3]
+                    f"`{f}:{line}`" for f, line in error.locations[:3]
                 ])
                 if len(error.locations) > 3:
                     locations += f" (+{len(error.locations) - 3} more)"

moai_adk/core/tags/pre_commit_validator.py

@@ -26,7 +26,7 @@ class ValidationError:
     locations: List[Tuple[str, int]] = field(default_factory=list)
 
     def __str__(self) -> str:
-        loc_str = ", ".join([f"{f}:{l}" for f, l in self.locations])
+        loc_str = ", ".join([f"{f}:{line}" for f, line in self.locations])
         return f"{self.message}: {self.tag} at {loc_str}"
 
 
@@ -98,6 +98,37 @@ class PreCommitValidator:
         self.strict_mode = strict_mode
         self.check_orphans = check_orphans
         self.tag_pattern = re.compile(tag_pattern or self.DEFAULT_TAG_PATTERN)
+        # Document files to exclude from TAG validation
+        self.excluded_file_patterns = [
+            r"\.md$",  # Markdown files
+            r"README",  # README files
+            r"CHANGELOG",  # CHANGELOG files
+            r"CONTRIBUTING",  # CONTRIBUTING files
+            r"LICENSE",  # LICENSE files
+            r"\.txt$",  # Text files
+            r"\.rst$",  # ReStructuredText files
+            r"test_.*\.py$",  # Test files (test_*.py)
+            r".*_test\.py$",  # Test files (*_test.py)
+            r"tests/",  # Files in tests/ directory
+            r"validator\.py$",  # Validator files (contain example TAGs in docstrings)
+        ]
+
+    def should_validate_file(self, filepath: str) -> bool:
+        """Check if file should be validated for TAGs
+
+        Document files (*.md, README, CONTRIBUTING, etc.) are excluded
+        because they often contain example TAGs that are not actual code.
+
+        Args:
+            filepath: File path to check
+
+        Returns:
+            True if file should be validated, False if excluded
+        """
+        for pattern in self.excluded_file_patterns:
+            if re.search(pattern, filepath):
+                return False
+        return True
 
     def validate_format(self, tag: str) -> bool:
         """Validate TAG format
@@ -137,6 +168,10 @@ class PreCommitValidator:
         tag_locations: Dict[str, List[Tuple[str, int]]] = {}
 
         for filepath in files:
+            # Skip document files (*.md, README, CONTRIBUTING, etc.)
+            if not self.should_validate_file(filepath):
+                continue
+
             try:
                 path = Path(filepath)
                 if not path.exists() or not path.is_file():
@@ -195,6 +230,10 @@ class PreCommitValidator:
         }
 
         for filepath in files:
+            # Skip document files (*.md, README, CONTRIBUTING, etc.)
+            if not self.should_validate_file(filepath):
+                continue
+
             try:
                 path = Path(filepath)
                 if not path.exists() or not path.is_file():
@@ -206,7 +245,6 @@ class PreCommitValidator:
                 for line_num, line in enumerate(lines, start=1):
                     matches = self.tag_pattern.findall(line)
                     for prefix, domain in matches:
-                        tag = f"@{prefix}:{domain}"
                         if domain not in tags_by_type[prefix]:
                             tags_by_type[prefix][domain] = []
                         tags_by_type[prefix][domain].append((filepath, line_num))

moai_adk/core/tags/reporter.py

@@ -155,7 +155,7 @@ class InventoryGenerator:
         Returns:
             List of TagInventory objects
         """
-        inventory = []
+        inventory: list[TagInventory] = []
         root = Path(root_path)
 
         if not root.exists() or not root.is_dir():
@@ -224,7 +224,6 @@ class InventoryGenerator:
 
                 for tag_type, domain in matches:
                     tag_id = domain
-                    full_tag = f"@{tag_type}:{domain}"
 
                     # Extract context (±2 lines)
                     context_lines = []
@@ -421,7 +420,7 @@ class MatrixGenerator:
             spec = "1" if row["SPEC"] else "0"
             code = "1" if row["CODE"] else "0"
             test = "1" if row["TEST"] else "0"
-            doc = "1" if row["DOC"] else "0"
+            "1" if row["DOC"] else "0"
             completion = f"{matrix.completion_percentages[domain]:.1f}"
 
             lines.append(f"{domain},{spec},{code},{test},{completion}")

moai_adk/core/tags/validator.py

@@ -85,7 +85,7 @@ class ValidationIssue:
             "tag": self.tag,
             "message": self.message,
             "locations": [
-                {"file": f, "line": l} for f, l in self.locations
+                {"file": f, "line": line} for f, line in self.locations
             ],
             "suggestion": self.suggestion
         }

moai_adk/core/template_engine.py

@@ -31,13 +31,17 @@ class TemplateEngine:
     - File-based and string-based template rendering
     """
 
-    def __init__(self, strict_undefined: bool = False):
+    def __init__(self, strict_undefined: bool = True):
         """
         Initialize the template engine.
 
         Args:
-            strict_undefined: If True, raise error on undefined variables.
+            strict_undefined: If True, raise error on undefined variables (default: True).
                              If False, render undefined variables as empty strings.
+
+        Note:
+            Changed to strict_undefined=True (v0.10.2+) for safer template rendering.
+            Variables must be explicitly provided to avoid silent template failures.
         """
         self.strict_undefined = strict_undefined
         self.undefined_behavior = StrictUndefined if strict_undefined else None
@@ -241,13 +245,24 @@ class TemplateVariableValidator:
             if var_name not in variables:
                 errors.append(f"Missing required variable: {var_name}")
             elif not isinstance(variables[var_name], var_type):
-                errors.append(f"Invalid type for {var_name}: expected {var_type.__name__}, got {type(variables[var_name]).__name__}")
+                actual_type = type(variables[var_name]).__name__
+                errors.append(
+                    f"Invalid type for {var_name}: "
+                    f"expected {var_type.__name__}, got {actual_type}"
+                )
 
         # Check optional variables (if present)
         for var_name, var_type in cls.OPTIONAL_VARIABLES.items():
             if var_name in variables:
                 if not isinstance(variables[var_name], var_type):
-                    type_names = " or ".join(t.__name__ for t in var_type) if isinstance(var_type, tuple) else var_type.__name__
-                    errors.append(f"Invalid type for {var_name}: expected {type_names}, got {type(variables[var_name]).__name__}")
+                    if isinstance(var_type, tuple):
+                        type_names = " or ".join(t.__name__ for t in var_type)
+                    else:
+                        type_names = var_type.__name__
+                    actual_type = type(variables[var_name]).__name__
+                    errors.append(
+                        f"Invalid type for {var_name}: "
+                        f"expected {type_names}, got {actual_type}"
+                    )
 
         return len(errors) == 0, errors