add

Author: jzhu

code_assistant_manager/cli/prompts_commands.py

@@ -254,17 +254,56 @@ def deactivate_prompt(prompt_id: str = typer.Argument(..., help="Prompt identifi
 
 
 @prompt_app.command("sync")
-def sync_prompts():
-    """Sync all active prompts to their respective app files."""
+def sync_prompts(
+    prompt_id: Optional[str] = typer.Argument(
+        None, help="Prompt ID to sync. If not specified, syncs all active prompts."
+    ),
+    app_type: Optional[str] = typer.Option(
+        None,
+        "--app",
+        "-a",
+        help="App type to sync to (claude, codex, gemini). Required if prompt_id is specified.",
+    ),
+):
+    """Sync prompts to app files. Can sync a specific prompt or all active prompts."""
     manager = _get_prompt_manager()
 
-    results = manager.sync_all()
+    if prompt_id:
+        # Sync specific prompt to specific app
+        if not app_type:
+            typer.echo(
+                f"{Colors.RED}✗ --app is required when specifying a prompt ID{Colors.RESET}"
+            )
+            raise typer.Exit(1)
 
-    for app_type, success in results.items():
-        if success:
-            typer.echo(f"{Colors.GREEN}✓ {app_type}: synced{Colors.RESET}")
-        else:
-            typer.echo(f"{Colors.RED}✗ {app_type}: failed{Colors.RESET}")
+        if app_type not in VALID_APP_TYPES:
+            typer.echo(
+                f"{Colors.RED}✗ Invalid app type: {app_type}. Valid: {', '.join(VALID_APP_TYPES)}{Colors.RESET}"
+            )
+            raise typer.Exit(1)
+
+        prompt = manager.get(prompt_id)
+        if not prompt:
+            typer.echo(f"{Colors.RED}✗ Prompt not found: {prompt_id}{Colors.RESET}")
+            raise typer.Exit(1)
+
+        try:
+            manager._sync_prompt_to_file(prompt.content, app_type)
+            typer.echo(f"{Colors.GREEN}✓ Synced '{prompt_id}' to {app_type}{Colors.RESET}")
+            file_path = PROMPT_FILE_PATHS.get(app_type)
+            typer.echo(f"  {Colors.CYAN}File:{Colors.RESET} {file_path}")
+        except Exception as e:
+            typer.echo(f"{Colors.RED}✗ Error: {e}{Colors.RESET}")
+            raise typer.Exit(1)
+    else:
+        # Sync all active prompts
+        results = manager.sync_all()
+
+        for app, synced_prompt_id in results.items():
+            if synced_prompt_id:
+                typer.echo(f"{Colors.GREEN}✓ {app}: synced ({synced_prompt_id}){Colors.RESET}")
+            else:
+                typer.echo(f"{Colors.YELLOW}○ {app}: no active prompt{Colors.RESET}")
 
 
 @prompt_app.command("import-live")

code_assistant_manager/prompts.py

@@ -439,12 +439,12 @@ def get_active_prompt(self, app_type: str) -> Optional[Prompt]:
                 return prompt
         return None
 
-    def sync_all(self) -> Dict[str, bool]:
+    def sync_all(self) -> Dict[str, Optional[str]]:
         """
         Sync all active prompts to their respective app files.
 
         Returns:
-            Dictionary mapping app types to success status
+            Dictionary mapping app types to prompt ID synced (or None if no prompt)
         """
         prompts = self._load_prompts()
         results = {}
@@ -462,11 +462,11 @@ def sync_all(self) -> Dict[str, bool]:
             if active_prompt:
                 try:
                     self._sync_prompt_to_file(active_prompt.content, app_type)
-                    results[app_type] = True
+                    results[app_type] = active_prompt.id
                 except Exception as e:
                     logger.error(f"Failed to sync prompt to {app_type}: {e}")
-                    results[app_type] = False
+                    results[app_type] = None
             else:
-                results[app_type] = True  # No active prompt is not an error
+                results[app_type] = None  # No active prompt
 
         return results

code_assistant_manager/skills.py

@@ -23,23 +23,52 @@
 
 logger = logging.getLogger(__name__)
 
-# Default skill repositories (similar to cc-switch)
-DEFAULT_SKILL_REPOS = [
-    {
-        "owner": "anthropics",
-        "name": "skills",
-        "branch": "main",
-        "enabled": True,
-        "skillsPath": None,
-    },
-    {
-        "owner": "ComposioHQ",
-        "name": "awesome-claude-skills",
-        "branch": "main",
-        "enabled": True,
-        "skillsPath": None,
-    },
-]
+
+def _load_builtin_skill_repos() -> List[Dict]:
+    """Load built-in skill repos from the bundled skill_repos.json file."""
+    # Look for skill_repos.json in the package directory
+    package_dir = Path(__file__).parent
+    repos_file = package_dir / "skill_repos.json"
+    
+    if repos_file.exists():
+        try:
+            with open(repos_file, "r", encoding="utf-8") as f:
+                repos_data = json.load(f)
+                # Convert from dict format to list format
+                return [
+                    {
+                        "owner": repo.get("owner"),
+                        "name": repo.get("name"),
+                        "branch": repo.get("branch", "main"),
+                        "enabled": repo.get("enabled", True),
+                        "skillsPath": repo.get("skillsPath"),
+                    }
+                    for repo in repos_data.values()
+                ]
+        except Exception as e:
+            logger.warning(f"Failed to load builtin skill repos: {e}")
+    
+    # Fallback defaults if file not found
+    return [
+        {
+            "owner": "ComposioHQ",
+            "name": "awesome-claude-skills",
+            "branch": "main",
+            "enabled": True,
+            "skillsPath": None,
+        },
+        {
+            "owner": "obra",
+            "name": "superpowers",
+            "branch": "main",
+            "enabled": True,
+            "skillsPath": "skills",
+        },
+    ]
+
+
+# Default skill repositories loaded from bundled file
+DEFAULT_SKILL_REPOS = _load_builtin_skill_repos()
 
 # Skill install directories for each app type
 SKILL_INSTALL_DIRS = {
@@ -195,9 +224,10 @@ def _save_skills(self, skills: Dict[str, Skill]) -> None:
             raise
 
     def _load_repos(self) -> Dict[str, SkillRepo]:
-        """Load skill repos from file."""
+        """Load skill repos from file. Initializes with defaults if file doesn't exist."""
         if not self.repos_file.exists():
-            return {}
+            # Initialize with default repos on first use
+            self._init_default_repos_file()
 
         try:
             with open(self.repos_file, "r") as f:
@@ -210,6 +240,23 @@ def _load_repos(self) -> Dict[str, SkillRepo]:
             logger.warning(f"Failed to load skill repos: {e}")
             return {}
 
+    def _init_default_repos_file(self) -> None:
+        """Initialize the repos file with default skill repos."""
+        repos = {}
+        for repo_data in DEFAULT_SKILL_REPOS:
+            repo = SkillRepo(
+                owner=repo_data["owner"],
+                name=repo_data["name"],
+                branch=repo_data.get("branch", "main"),
+                enabled=repo_data.get("enabled", True),
+                skills_path=repo_data.get("skillsPath"),
+            )
+            repo_id = f"{repo.owner}/{repo.name}"
+            repos[repo_id] = repo
+
+        self._save_repos(repos)
+        logger.info(f"Initialized {len(repos)} default skill repos")
+
     def _save_repos(self, repos: Dict[str, SkillRepo]) -> None:
         """Save skill repos to file."""
         try:

install.sh

@@ -168,11 +168,30 @@ setup_config() {
 
     mkdir -p ~/.config/code-assistant-manager
 
-    if [ -f "code_assistant_manager/providers.json" ]; then
-        cp code_assistant_manager/providers.json ~/.config/code-assistant-manager/providers.json
+    # Try to find config files from local dir or installed package
+    local pkg_dir=""
+    if [ -d "code_assistant_manager" ]; then
+        pkg_dir="code_assistant_manager"
+    else
+        # Try to find from installed package
+        pkg_dir=$(python3 -c "import code_assistant_manager; import os; print(os.path.dirname(code_assistant_manager.__file__))" 2>/dev/null || echo "")
+    fi
+
+    if [ -n "$pkg_dir" ] && [ -f "$pkg_dir/providers.json" ]; then
+        cp "$pkg_dir/providers.json" ~/.config/code-assistant-manager/providers.json
         print_success "Created providers.json"
     fi
 
+    # Initialize skill_repos.json with built-in repos
+    if [ -n "$pkg_dir" ] && [ -f "$pkg_dir/skill_repos.json" ]; then
+        if [ ! -f ~/.config/code-assistant-manager/skill_repos.json ]; then
+            cp "$pkg_dir/skill_repos.json" ~/.config/code-assistant-manager/skill_repos.json
+            print_success "Created skill_repos.json with default repositories"
+        else
+            print_info "skill_repos.json already exists, skipping"
+        fi
+    fi
+
     if [ ! -f ~/.env ]; then
         touch ~/.env
         chmod 600 ~/.env

pyproject.toml

@@ -64,6 +64,7 @@ version = {attr = "code_assistant_manager.__version__"}
   "mcp/registry/*.json",
   "providers.json",
   "tools.yaml",
+  "skill_repos.json",
 ]
 
 [project.scripts]

tests/unit/test_prompts.py

@@ -363,7 +363,9 @@ def test_sync_all(self, temp_config_dir, temp_prompt_dir):
         with patch.dict('code_assistant_manager.prompts.PROMPT_FILE_PATHS', {'claude': prompt_file, 'codex': temp_prompt_dir / "AGENTS.md", 'gemini': temp_prompt_dir / "GEMINI.md"}):
             results = manager.sync_all()
 
-            assert results["claude"] is True
+            assert results["claude"] == "test"  # Returns prompt ID
+            assert results["codex"] is None  # No active prompt
+            assert results["gemini"] is None  # No active prompt
             assert prompt_file.exists()
             assert prompt_file.read_text() == "Sync content"
 

tests/unit/test_skills.py

@@ -217,16 +217,22 @@ def test_manager_delete(self, temp_config_dir):
     def test_manager_add_remove_repo(self, temp_config_dir):
         """Test adding and removing skill repos."""
         manager = SkillManager(temp_config_dir)
-        repo = SkillRepo(owner="owner", name="repo", branch="main")
+        
+        # Get initial count (includes default repos)
+        initial_repos = manager.get_repos()
+        initial_count = len(initial_repos)
+        
+        repo = SkillRepo(owner="testowner", name="testrepo", branch="main")
         manager.add_repo(repo)
 
         repos = manager.get_repos()
-        assert len(repos) == 1
-        assert repos[0].owner == "owner"
+        assert len(repos) == initial_count + 1
+        # Check that our new repo is in the list
+        assert any(r.owner == "testowner" and r.name == "testrepo" for r in repos)
 
-        manager.remove_repo("owner", "repo")
+        manager.remove_repo("testowner", "testrepo")
         repos = manager.get_repos()
-        assert len(repos) == 0
+        assert len(repos) == initial_count
 
     def test_manager_export_import(self, temp_config_dir):
         """Test exporting and importing skills."""
@@ -287,11 +293,11 @@ def test_manager_init_default_repos(self, temp_config_dir):
         """Test initializing default repos."""
         manager = SkillManager(temp_config_dir)
 
-        # Initially no repos
+        # Repos are auto-initialized now, so should already have defaults
         repos = manager.get_repos()
-        assert len(repos) == 0
+        assert len(repos) == len(DEFAULT_SKILL_REPOS)
 
-        # Initialize defaults
+        # Calling init_default_repos again should be idempotent
         manager.init_default_repos()
         repos = manager.get_repos()
         assert len(repos) == len(DEFAULT_SKILL_REPOS)