moai-adk 0.25.4__py3-none-any.whl → 0.32.8__py3-none-any.whl

moai_adk/core/analysis/session_analyzer.py

@@ -86,9 +86,7 @@ class SessionAnalyzer:
                                     sessions.append(session)
                                 except json.JSONDecodeError as e:
                                     if self.verbose:
-                                        print(
-                                            f"⚠️ Error reading line {line_num} in {session_file}: {e}"
-                                        )
+                                        print(f"⚠️ Error reading line {line_num} in {session_file}: {e}")
 
                     # Analyze each session from the JSONL file
                     for session in sessions:
@@ -120,15 +118,9 @@ class SessionAnalyzer:
             summary = cast(str, session.get("summary", "")).lower()
 
             # Simple analysis of session summaries
-            if any(
-                keyword in summary for keyword in ["error", "fail", "issue", "problem"]
-            ):
-                self.patterns["failed_sessions"] = (
-                    cast(int, self.patterns["failed_sessions"]) + 1
-                )
-                tool_failures = cast(
-                    defaultdict[str, int], self.patterns["tool_failures"]
-                )
+            if any(keyword in summary for keyword in ["error", "fail", "issue", "problem"]):
+                self.patterns["failed_sessions"] = cast(int, self.patterns["failed_sessions"]) + 1
+                tool_failures = cast(defaultdict[str, int], self.patterns["tool_failures"])
                 tool_failures["session_error_in_summary"] += 1
 
             # Extract potential tool usage from summary
@@ -153,9 +145,7 @@ class SessionAnalyzer:
 
         # Handle detailed event format (legacy session-*.json format)
         events = cast(list[Dict[str, Any]], session.get("events", []))
-        self.patterns["total_events"] = cast(int, self.patterns["total_events"]) + len(
-            events
-        )
+        self.patterns["total_events"] = cast(int, self.patterns["total_events"]) + len(events)
 
         has_error = False
 
@@ -171,26 +161,20 @@ class SessionAnalyzer:
             # Tool error patterns
             elif event_type == "tool_error":
                 error_msg = cast(str, event.get("error", "unknown error"))
-                tool_failures = cast(
-                    defaultdict[str, int], self.patterns["tool_failures"]
-                )
+                tool_failures = cast(defaultdict[str, int], self.patterns["tool_failures"])
                 tool_failures[error_msg[:50]] += 1  # First 50 characters
                 has_error = True
 
             # Permission requests
             elif event_type == "permission_request":
                 perm_type = cast(str, event.get("permission_type", "unknown"))
-                perm_requests = cast(
-                    defaultdict[str, int], self.patterns["permission_requests"]
-                )
+                perm_requests = cast(defaultdict[str, int], self.patterns["permission_requests"])
                 perm_requests[perm_type] += 1
 
             # Hook failures
             elif event_type == "hook_failure":
                 hook_name = cast(str, event.get("hook_name", "unknown"))
-                hook_failures = cast(
-                    defaultdict[str, int], self.patterns["hook_failures"]
-                )
+                hook_failures = cast(defaultdict[str, int], self.patterns["hook_failures"])
                 hook_failures[hook_name] += 1
                 has_error = True
 
@@ -199,15 +183,11 @@ class SessionAnalyzer:
                 cmd_str = cast(str, event.get("command", "")).split()
                 if cmd_str:
                     cmd = cmd_str[0]
-                    cmd_freq = cast(
-                        defaultdict[str, int], self.patterns["command_frequency"]
-                    )
+                    cmd_freq = cast(defaultdict[str, int], self.patterns["command_frequency"])
                     cmd_freq[cmd] += 1
 
         if has_error:
-            self.patterns["failed_sessions"] = (
-                cast(int, self.patterns["failed_sessions"]) + 1
-            )
+            self.patterns["failed_sessions"] = cast(int, self.patterns["failed_sessions"]) + 1
 
     def generate_report(self) -> str:
         """
@@ -220,11 +200,7 @@ class SessionAnalyzer:
         total_sessions = cast(int, self.patterns["total_sessions"])
         failed_sessions = cast(int, self.patterns["failed_sessions"])
         total_events = cast(int, self.patterns["total_events"])
-        success_rate = (
-            ((total_sessions - failed_sessions) / total_sessions * 100)
-            if total_sessions > 0
-            else 0
-        )
+        success_rate = ((total_sessions - failed_sessions) / total_sessions * 100) if total_sessions > 0 else 0
 
         report = f"""# MoAI-ADK Session Meta-Analysis Report
 
@@ -291,9 +267,7 @@ class SessionAnalyzer:
         # Permission request analysis
         report += "\n## Permission Request Patterns\n\n"
 
-        perm_requests = cast(
-            defaultdict[str, int], self.patterns["permission_requests"]
-        )
+        perm_requests = cast(defaultdict[str, int], self.patterns["permission_requests"])
         if perm_requests:
             sorted_perms = sorted(
                 perm_requests.items(),
@@ -322,9 +296,7 @@ class SessionAnalyzer:
         suggestions: list[str] = []
 
         # High permission requests - review permission settings
-        perm_requests = cast(
-            defaultdict[str, int], self.patterns["permission_requests"]
-        )
+        perm_requests = cast(defaultdict[str, int], self.patterns["permission_requests"])
         if perm_requests:
             top_perm = max(
                 perm_requests.items(),
@@ -369,11 +341,7 @@ class SessionAnalyzer:
         # Low success rate - general diagnosis
         total_sessions = cast(int, self.patterns["total_sessions"])
         failed_sessions = cast(int, self.patterns["failed_sessions"])
-        success_rate = (
-            ((total_sessions - failed_sessions) / total_sessions * 100)
-            if total_sessions > 0
-            else 0
-        )
+        success_rate = ((total_sessions - failed_sessions) / total_sessions * 100) if total_sessions > 0 else 0
 
         if success_rate < 80 and total_sessions >= 5:
             suggestions.append(
@@ -384,16 +352,11 @@ class SessionAnalyzer:
             )
 
         if not suggestions:
-            suggestions.append(
-                "✅ No major issues detected\n"
-                "   - Current settings and rules are working well"
-            )
+            suggestions.append("✅ No major issues detected\n   - Current settings and rules are working well")
 
         return "\n\n".join(suggestions)
 
-    def save_report(
-        self, output_path: Optional[Path] = None, project_path: Optional[Path] = None
-    ) -> Path:
+    def save_report(self, output_path: Optional[Path] = None, project_path: Optional[Path] = None) -> Path:
         """
         Save report to file
 
@@ -431,9 +394,7 @@ class SessionAnalyzer:
         if total_sessions > 0:
             failed_sessions = cast(int, self.patterns["failed_sessions"])
             total_events = cast(int, self.patterns["total_events"])
-            self.patterns["success_rate"] = (
-                (total_sessions - failed_sessions) / total_sessions * 100
-            )
+            self.patterns["success_rate"] = (total_sessions - failed_sessions) / total_sessions * 100
             self.patterns["average_session_length"] = total_events / total_sessions
 
         return self.patterns.copy()

moai_adk/core/claude_integration.py

@@ -35,9 +35,7 @@ class ClaudeCLIIntegration:
         """
         self.template_engine = template_engine or TemplateEngine()
 
-    def generate_claude_settings(
-        self, variables: Dict[str, Any], output_path: Optional[Path] = None
-    ) -> Path:
+    def generate_claude_settings(self, variables: Dict[str, Any], output_path: Optional[Path] = None) -> Path:
         """Generate Claude settings JSON file with variables.
 
         Args:
@@ -48,9 +46,7 @@ class ClaudeCLIIntegration:
             Path to generated settings file
         """
         if output_path is None:
-            temp_file = tempfile.NamedTemporaryFile(
-                mode="w", suffix=".json", delete=False
-            )
+            temp_file = tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False)
             output_path = Path(temp_file.name)
             temp_file.close()
 
@@ -58,9 +54,7 @@ class ClaudeCLIIntegration:
             "variables": variables,
             "template_context": {
                 "conversation_language": variables.get("CONVERSATION_LANGUAGE", "en"),
-                "conversation_language_name": variables.get(
-                    "CONVERSATION_LANGUAGE_NAME", "English"
-                ),
+                "conversation_language_name": variables.get("CONVERSATION_LANGUAGE_NAME", "English"),
                 "project_name": variables.get("PROJECT_NAME", ""),
                 "codebase_language": variables.get("CODEBASE_LANGUAGE", "python"),
             },
@@ -89,9 +83,7 @@ class ClaudeCLIIntegration:
         """
         try:
             # Process template variables
-            processed_command = self.template_engine.render_string(
-                command_template, variables
-            )
+            processed_command = self.template_engine.render_string(command_template, variables)
 
             # Build Claude CLI command
             cmd_parts = ["claude"]
@@ -108,14 +100,12 @@ class ClaudeCLIIntegration:
             cmd_parts.append(processed_command)
 
             # Execute Claude CLI
-            result = subprocess.run(
-                cmd_parts, capture_output=True, text=True, encoding="utf-8"
-            )
+            result = subprocess.run(cmd_parts, capture_output=True, text=True, encoding="utf-8")
 
             # Cleanup settings file
             try:
                 settings_file.unlink()
-            except:
+            except OSError:
                 pass  # Ignore cleanup errors
 
             return {
@@ -168,7 +158,7 @@ class ClaudeCLIIntegration:
                     continue
 
                 # Create language-specific description prompt
-                translation_prompt = f"""Translate the following Claude Code description to {lang_info['native_name']}.
+                translation_prompt = f"""Translate the following Claude Code description to {lang_info["native_name"]}.
 Keep technical terms in English. Provide only the translation without explanation:
 
 Original: {base_desc}
@@ -215,15 +205,11 @@ Translation:"""
             target_languages = ["en", "ko", "ja", "es", "fr", "de"]
 
         # Generate multilingual descriptions
-        descriptions = self.generate_multilingual_descriptions(
-            {agent_name: base_description}, target_languages
-        )
+        descriptions = self.generate_multilingual_descriptions({agent_name: base_description}, target_languages)
 
         agent_config = {
             "name": agent_name,
-            "description": descriptions[agent_name][
-                "en"
-            ],  # Primary English description
+            "description": descriptions[agent_name]["en"],  # Primary English description
             "tools": tools,
             "model": model,
             "descriptions": descriptions[agent_name],  # All language versions
@@ -258,15 +244,11 @@ Translation:"""
             target_languages = ["en", "ko", "ja", "es", "fr", "de"]
 
         # Generate multilingual descriptions
-        descriptions = self.generate_multilingual_descriptions(
-            {command_name: base_description}, target_languages
-        )
+        descriptions = self.generate_multilingual_descriptions({command_name: base_description}, target_languages)
 
         command_config = {
             "name": command_name,
-            "description": descriptions[command_name][
-                "en"
-            ],  # Primary English description
+            "description": descriptions[command_name]["en"],  # Primary English description
             "argument-hint": argument_hint,
             "tools": tools,
             "model": model,
@@ -290,21 +272,23 @@ Translation:"""
         Returns:
             Processed input data
         """
+        # Convert string to dict if needed
+        processed_data: Dict[str, Any]
         if isinstance(input_data, str):
             try:
-                input_data = json.loads(input_data)
+                processed_data = json.loads(input_data)
             except json.JSONDecodeError as e:
                 raise ValueError(f"Invalid JSON input: {e}")
+        else:
+            processed_data = input_data
 
         if variables:
-            # Process any string values in input_data with variables
-            for key, value in input_data.items():
+            # Process any string values in processed_data with variables
+            for key, value in processed_data.items():
                 if isinstance(value, str) and "{{" in value and "}}" in value:
-                    input_data[key] = self.template_engine.render_string(
-                        value, variables
-                    )
+                    processed_data[key] = self.template_engine.render_string(value, variables)
 
-        return input_data
+        return processed_data
 
     def execute_headless_command(
         self,
@@ -328,9 +312,7 @@ Translation:"""
         """
         try:
             # Process prompt template
-            processed_prompt = self.template_engine.render_string(
-                prompt_template, variables
-            )
+            processed_prompt = self.template_engine.render_string(prompt_template, variables)
 
             # Build Claude command
             cmd_parts = ["claude", "--print"]
@@ -367,11 +349,7 @@ Translation:"""
                     stdout_line = process.stdout.readline()
                     stderr_line = process.stderr.readline()
 
-                    if (
-                        stdout_line == ""
-                        and stderr_line == ""
-                        and process.poll() is not None
-                    ):
+                    if stdout_line == "" and stderr_line == "" and process.poll() is not None:
                         break
 
                     if stdout_line:
@@ -385,22 +363,16 @@ Translation:"""
 
             else:
                 # Non-streaming execution
-                result = subprocess.run(
-                    cmd_parts, capture_output=True, text=True, encoding="utf-8"
-                )
+                result = subprocess.run(cmd_parts, capture_output=True, text=True, encoding="utf-8")
 
-                stdout_lines = (
-                    result.stdout.strip().split("\n") if result.stdout else []
-                )
-                stderr_lines = (
-                    result.stderr.strip().split("\n") if result.stderr else []
-                )
+                stdout_lines = result.stdout.strip().split("\n") if result.stdout else []
+                stderr_lines = result.stderr.strip().split("\n") if result.stderr else []
                 returncode = result.returncode
 
             # Cleanup
             try:
                 settings_file.unlink()
-            except:
+            except OSError:
                 pass
 
             return {

moai_adk/core/command_helpers.py

@@ -10,6 +10,8 @@ import os
 from datetime import datetime, timezone
 from typing import Any, Dict, List, Optional
 
+import yaml
+
 # Conditional import of ContextManager
 try:
     from moai_adk.core.context_manager import (
@@ -25,7 +27,7 @@ except ImportError:
 
 def extract_project_metadata(project_root: str) -> Dict[str, Any]:
     """
-    Extract project metadata from config.json.
+    Extract project metadata from config.yaml.
 
     Args:
         project_root: Root directory of the project
@@ -34,22 +36,22 @@ def extract_project_metadata(project_root: str) -> Dict[str, Any]:
         Dictionary containing project metadata
 
     Raises:
-        FileNotFoundError: If config.json doesn't exist
-        json.JSONDecodeError: If config.json is invalid
+        FileNotFoundError: If config.yaml doesn't exist
+        yaml.YAMLError: If config.yaml is invalid
     """
-    config_path = os.path.join(project_root, ".moai", "config", "config.json")
+    config_path = os.path.join(project_root, ".moai", "config", "config.yaml")
 
     if not os.path.exists(config_path):
         raise FileNotFoundError(f"Config file not found: {config_path}")
 
-    with open(config_path, "r") as f:
-        config = json.load(f)
+    with open(config_path, "r", encoding="utf-8") as f:
+        config = yaml.safe_load(f) or {}
 
     # Extract key metadata
     metadata = {
         "project_name": config.get("project", {}).get("name", "Unknown"),
         "mode": config.get("project", {}).get("mode", "personal"),
-        "owner": config.get("project", {}).get("owner", "@user"),
+        "github_profile": config.get("github", {}).get("profile_name", ""),
         "language": config.get("language", {}).get("conversation_language", "en"),
         "tech_stack": [],  # To be detected separately
     }
@@ -238,9 +240,7 @@ def save_command_context(
     try:
         context_mgr = ContextManager(project_root)
         absolute_paths = validate_phase_files(files_created, project_root)
-        phase_data = _prepare_phase_data(
-            phase_name, status, outputs, absolute_paths, next_phase
-        )
+        phase_data = _prepare_phase_data(phase_name, status, outputs, absolute_paths, next_phase)
         return _validate_and_save(context_mgr, phase_data)
 
     except Exception as e: