Fix tool lookup and imports in launch command

Author: James Zhu

code_assistant_manager/cli/app.py

@@ -40,13 +40,7 @@
     UninstallContext,
     uninstall,
 )
-from code_assistant_manager.config import ConfigManager
-from code_assistant_manager.menu.base import Colors
-from code_assistant_manager.tools import (
-    display_all_tool_endpoints,
-    display_tool_endpoints,
-    get_registered_tools,
-)
+# Lazy imports moved inside functions to improve startup time
 
 logger = logging.getLogger(__name__)
 
@@ -56,7 +50,13 @@
 # ============================================================================
 
 
-def _get_config_manager(ctx: Context) -> ConfigManager:
+
+def _get_config_manager(ctx: Context):
+    # Lazy import
+    from code_assistant_manager.config import ConfigManager
+    
+    # Return type hint for clarity
+    
     """Get or create ConfigManager from context."""
     try:
         config_path = None
@@ -80,6 +80,12 @@ def upgrade(
     """Upgrade CLI tools (alias: u). If not installed, will install.
     If installed, will try to upgrade."""
     from code_assistant_manager.cli.upgrade import handle_upgrade_command
+    from code_assistant_manager.config import ConfigManager
+    from code_assistant_manager.tools import (
+        display_all_tool_endpoints,
+        display_tool_endpoints,
+        get_registered_tools,
+    )
 
     logger.debug(f"Upgrade command called with target: {target}")
     config_path = ctx.obj.get("config_path")
@@ -125,6 +131,10 @@ def doctor(
     config: Optional[str] = CONFIG_FILE_OPTION,
 ):
     """Run diagnostic checks on the code-assistant-manager installation (alias: d)"""
+
+    # Lazy imports
+    from code_assistant_manager.config import ConfigManager
+    from code_assistant_manager.tools import display_all_tool_endpoints, display_tool_endpoints
     # Initialize context object
     ctx.ensure_object(dict)
     ctx.obj["config_path"] = config
@@ -173,6 +183,10 @@ def doctor(
 
 def launch_alias(ctx: Context, tool_name: str = TOOL_NAME_OPTION):
     """Alias for 'launch' command."""
+
+    # Lazy imports
+    from code_assistant_manager.config import ConfigManager
+    from code_assistant_manager.tools import get_registered_tools
     # Initialize context object
     ctx.ensure_object(dict)
     ctx.obj["config_path"] = None
@@ -420,6 +434,10 @@ def validate_config(
     verbose: bool = VALIDATE_VERBOSE_OPTION,
 ):
     """Validate the configuration file for syntax and semantic errors."""
+
+    # Lazy imports
+    from code_assistant_manager.config import ConfigManager
+    from code_assistant_manager.menu.base import Colors
     try:
         cm = ConfigManager(config)
         typer.echo(

code_assistant_manager/cli/commands.py

@@ -10,7 +10,6 @@
 
 from code_assistant_manager.menu.base import Colors
 from code_assistant_manager.plugins import (
-    BUILTIN_PLUGIN_REPOS,
     VALID_APP_TYPES,
     PluginManager,
     PluginRepo,

code_assistant_manager/cli/plugins/plugin_management_commands.py

@@ -39,19 +39,28 @@ def parse_from_file(
 
         # Find the repo root by looking for .git directory
         repo_root = skill_dir
-        for parent in skill_dir.parents:
-            if (parent / '.git').exists():
-                repo_root = parent
-                break
+        # Check current dir first
+        if (skill_dir / '.git').exists():
+            repo_root = skill_dir
         else:
-            # Fallback to the original logic if .git not found
-            repo_root = skill_dir.parents[-2]
+            for parent in skill_dir.parents:
+                if (parent / '.git').exists():
+                    repo_root = parent
+                    break
+            else:
+                # Fallback to the original logic if .git not found
+                try:
+                    repo_root = skill_dir.parents[-2]
+                except IndexError:
+                    repo_root = skill_dir.parent
 
         # Get relative path from repo root to skill directory
         try:
-            source_directory = str(skill_dir.relative_to(repo_root))
+            repo_relative_path = str(skill_dir.relative_to(repo_root))
         except ValueError:
-            source_directory = directory
+            repo_relative_path = directory
+
+        source_directory = repo_relative_path
 
         # If skills_path is set, source_directory should be relative to skills_path
         if repo_config.path:
@@ -64,9 +73,16 @@ def parse_from_file(
                 # If we can't make it relative, keep the full path but warn
                 logger.warning(f"Skill directory {skill_dir} is not under skills_path {repo_config.path}")
 
+        # Determine directory name for key
+        if skill_dir == repo_root:
+            # Use repo name for root skills if directory would be "."
+            directory = repo_config.name if repo_config.name else "."
+        else:
+            directory = skill_dir.name
+
         # Create skill entity
         skill = Skill(
-            key=self.create_entity_key(repo_config, directory),
+            key=self.create_entity_key(repo_config, source_directory),
             name=meta.get("name", directory),
             description=meta.get("description", ""),
             directory=directory,
@@ -75,7 +91,7 @@ def parse_from_file(
             repo_name=repo_config.name,
             repo_branch=repo_config.branch,
             skills_path=repo_config.path,
-            readme_url=f"https://github.com/{repo_config.owner}/{repo_config.name}/tree/{repo_config.branch}/{source_directory}",
+            readme_url=f"https://github.com/{repo_config.owner}/{repo_config.name}/tree/{repo_config.branch}/{repo_relative_path}",
             source_directory=source_directory,
         )
 
@@ -91,23 +107,44 @@ def create_entity_key(self, repo_config: RepoConfig, entity_name: str) -> str:
 
     def _parse_metadata(self, skill_md: Path) -> dict:
         """Parse skill metadata from SKILL.md."""
-        # This is a simplified version - in reality this would parse YAML frontmatter
-        # from the existing handler logic
         meta = {"name": "", "description": ""}
 
         try:
             with open(skill_md, 'r', encoding='utf-8') as f:
                 content = f.read()
 
-            # Simple parsing - look for name and description
+            # Parse frontmatter manually to avoid dependencies if needed, 
+            # or just to handle simple key: value pairs
             lines = content.split('\n')
-            for line in lines[:10]:  # Check first 10 lines
-                line = line.strip()
-                if line.startswith('# '):
-                    meta["name"] = line[2:].strip()
-                elif line.startswith('description:') or line.startswith('Description:'):
-                    meta["description"] = line.split(':', 1)[1].strip()
-                    break
+            frontmatter = []
+            in_frontmatter = False
+
+            for line in lines:
+                if line.strip() == '---':
+                    if not in_frontmatter:
+                        in_frontmatter = True
+                        continue
+                    else:
+                        break
+                if in_frontmatter:
+                    frontmatter.append(line)
+
+            if frontmatter:
+                for line in frontmatter:
+                    if ':' in line:
+                        key, value = line.split(':', 1)
+                        key = key.strip()
+                        value = value.strip().strip('"').strip("'")
+                        if key in meta or key == "name": # Allow updating name and description
+                            meta[key] = value
+            
+            # Fallback to H1 title if name not found in frontmatter
+            if not meta["name"]:
+                for line in lines:
+                    if line.strip().startswith('# '):
+                        meta["name"] = line.strip()[2:].strip()
+                        break
+
         except Exception as e:
             logger.warning(f"Failed to parse metadata from {skill_md}: {e}")
 

code_assistant_manager/fetching/parsers.py

@@ -22,7 +22,6 @@
 )
 from .gemini import GeminiPluginHandler
 from .manager import (
-    BUILTIN_PLUGIN_REPOS,
     PLUGIN_HANDLERS,
     VALID_APP_TYPES,
     PluginManager,
@@ -55,5 +54,4 @@
     # Constants
     "PLUGIN_HANDLERS",
     "VALID_APP_TYPES",
-    "BUILTIN_PLUGIN_REPOS",
 ]

code_assistant_manager/plugins/__init__.py

@@ -21,8 +21,6 @@ def _load_builtin_plugin_repos() -> Dict[str, PluginRepo]:
 
     Returns bundled repos as PluginRepo objects for fallback.
     """
-    from .fetch import fetch_repo_info
-
     package_dir = Path(__file__).parent.parent
     repos_file = package_dir / "plugin_repos.json"
 
@@ -32,23 +30,9 @@ def _load_builtin_plugin_repos() -> Dict[str, PluginRepo]:
             with open(repos_file, "r", encoding="utf-8") as f:
                 data = json.load(f)
             for key, repo_data in data.items():
-                # For marketplace repos, fetch the actual name from the repo's marketplace.json
+                # Use configured name or fallback to key
                 name = repo_data.get("name", key)
-                if repo_data.get("type") == "marketplace" and repo_data.get("repoOwner") and repo_data.get("repoName"):
-                    try:
-                        # Fetch the actual name from the repo's marketplace.json
-                        repo_info = fetch_repo_info(
-                            repo_data["repoOwner"],
-                            repo_data["repoName"],
-                            repo_data.get("repoBranch", "main")
-                        )
-                        if repo_info and repo_info.name:
-                            name = repo_info.name
-                            logger.debug(f"Using fetched name '{name}' for {key} from marketplace.json")
-                    except Exception as e:
-                        logger.warning(f"Failed to fetch name for {key} from marketplace.json: {e}")
-                        # Fall back to the configured name
-
+                
                 repos[key] = PluginRepo(
                     name=name,
                     description=repo_data.get("description", ""),
@@ -76,8 +60,6 @@ def _load_plugin_repos_from_config(config_dir: Optional[Path] = None) -> Dict[st
     Returns:
         Dictionary of PluginRepo objects
     """
-    from .fetch import fetch_repo_info
-
     loader = RepoConfigLoader(config_dir)
     bundled_fallback_dict = _load_builtin_plugin_repos()
 
@@ -102,22 +84,8 @@ def _load_plugin_repos_from_config(config_dir: Optional[Path] = None) -> Dict[st
     # Convert back to PluginRepo objects
     repos: Dict[str, PluginRepo] = {}
     for key, repo_data in repos_dict.items():
-        # For marketplace repos, fetch the actual name from the repo's marketplace.json
+        # Use configured name or fallback to key
         name = repo_data.get("name", key)
-        if repo_data.get("type") == "marketplace" and repo_data.get("repoOwner") and repo_data.get("repoName"):
-            try:
-                # Fetch the actual name from the repo's marketplace.json
-                repo_info = fetch_repo_info(
-                    repo_data["repoOwner"],
-                    repo_data["repoName"],
-                    repo_data.get("repoBranch", "main")
-                )
-                if repo_info and repo_info.name:
-                    name = repo_info.name
-                    logger.debug(f"Using fetched name '{name}' for {key} from marketplace.json")
-            except Exception as e:
-                logger.warning(f"Failed to fetch name for {key} from marketplace.json: {e}")
-                # Fall back to the configured name
 
         repos[key] = PluginRepo(
             name=name,
@@ -145,8 +113,16 @@ def _load_plugin_repos_from_config(config_dir: Optional[Path] = None) -> Dict[st
 # Valid app types that support plugins
 VALID_APP_TYPES = list(PLUGIN_HANDLERS.keys())
 
-# Built-in plugin repositories
-BUILTIN_PLUGIN_REPOS = _load_plugin_repos_from_config()
+# Cache for plugin repositories
+_CACHED_PLUGIN_REPOS: Optional[Dict[str, PluginRepo]] = None
+
+
+def _get_plugin_repos_lazy() -> Dict[str, PluginRepo]:
+    """Get all plugin repos (lazy loaded)."""
+    global _CACHED_PLUGIN_REPOS
+    if _CACHED_PLUGIN_REPOS is None:
+        _CACHED_PLUGIN_REPOS = _load_plugin_repos_from_config()
+    return _CACHED_PLUGIN_REPOS
 
 
 def get_handler(app_type: str) -> BasePluginHandler:
@@ -328,13 +304,14 @@ def remove_marketplace(self, name: str) -> None:
 
     def get_builtin_repos(self) -> Dict[str, PluginRepo]:
         """Get all built-in plugin repositories."""
-        return BUILTIN_PLUGIN_REPOS.copy()
+        return _get_plugin_repos_lazy().copy()
 
     def get_builtin_repo(self, name: str) -> Optional[PluginRepo]:
         """Get a built-in plugin repository by name (supports aliases)."""
-        resolved = self._resolve_repo_name(name, self.get_builtin_repos())
+        repos = self.get_builtin_repos()
+        resolved = self._resolve_repo_name(name, repos)
         if resolved:
-            return BUILTIN_PLUGIN_REPOS.get(resolved)
+            return repos.get(resolved)
         return None
 
     # ==================== User Plugin Repos ====================
@@ -496,7 +473,7 @@ def install(
         else:
             raise ValueError(
                 f"Invalid source: {source}. Must be a local path, GitHub repo (owner/repo), "
-                f"or built-in repo name: {list(BUILTIN_PLUGIN_REPOS.keys())}"
+                f"or built-in repo name: {list(_get_plugin_repos_lazy().keys())}"
             )
 
         # Save to registry

code_assistant_manager/plugins/manager.py

@@ -1,5 +1,6 @@
 import logging
 import os
+import time
 from pathlib import Path
 from typing import Dict, List, Optional
 
@@ -9,7 +10,7 @@
 
 
 class ToolRegistry:
-    """Registry for external CLI tools loaded from tools.yaml with lazy loading."""
+    """Registry for external CLI tools loaded from tools.yaml with lazy loading and caching."""
 
     def __init__(self, config_path: Optional[Path] = None):
         env_override = os.environ.get("CODE_ASSISTANT_MANAGER_TOOLS_FILE")
@@ -23,6 +24,8 @@ def __init__(self, config_path: Optional[Path] = None):
                 Path(__file__).resolve().parent.parent.parent / "tools.yaml"
             )
         self._tools = None  # Lazy load on first access
+        self._cache_time = None
+        self._cache_ttl = 30  # Cache for 30 seconds
 
     def _load(self) -> Dict[str, dict]:
         """Load tools from packaged resources first, then fall back to file path.
@@ -81,11 +84,14 @@ def _load(self) -> Dict[str, dict]:
         return tools if isinstance(tools, dict) else {}
 
     def _ensure_loaded(self):
-        if self._tools is None:
+        # Check if cache is still valid
+        if self._tools is None or self._cache_time is None or (time.time() - self._cache_time) > self._cache_ttl:
             self._tools = self._load()
+            self._cache_time = time.time()
 
     def reload(self):
         self._tools = self._load()
+        self._cache_time = time.time()
 
     def get_tool(self, tool_key: str) -> dict:
         self._ensure_loaded()