python-skills 1.0.0__py3-none-any.whl

python_skills/adapters/zed.py

@@ -0,0 +1,27 @@
+"""Zed adapter for python-skills."""
+
+from pathlib import Path
+
+from .agent_skills import AgentSkillsAdapter
+
+
+class ZedAdapter(AgentSkillsAdapter):
+    """Adapter for Zed editor.
+    
+    Zed discovers skills from:
+    - .agents/skills/<name>/SKILL.md (Agent Skills spec)
+    
+    Zed also reads AGENTS.md for instructions.
+    """
+
+    target_name = "zed"
+    display_name = "Zed"
+    agent_skills_dir = ".agents/skills"
+    detection_app_command = "zed"
+    detection_project_markers = ["AGENTS.md", ".agents"]
+
+    def _get_global_path(self) -> Path:
+        import platform
+        if platform.system() == "Windows":
+            return Path.home() / "AppData" / "Roaming" / "Zed" / "skills"
+        return Path.home() / ".config" / "zed" / "skills"

python_skills/cli.py

@@ -0,0 +1,326 @@
+"""CLI for python-skills."""
+
+import sys
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+from python_skills.config import InstallConfig, Scope, Target
+from python_skills.detector import EnvironmentDetector
+from python_skills.installer import SkillInstaller
+
+console = Console()
+
+
+@click.group()
+@click.option("--project-root", "-p", type=click.Path(exists=True, file_okay=False, path_type=Path),
+              default=".", help="Project root directory")
+@click.option("--dry-run", is_flag=True, help="Show what would be done without making changes")
+@click.pass_context
+def main(ctx: click.Context, project_root: Path, dry_run: bool):
+    """Python Skills - Python engineering skills for AI coding agents."""
+    ctx.ensure_object(dict)
+    ctx.obj["project_root"] = project_root
+    ctx.obj["dry_run"] = dry_run
+
+
+@main.command()
+@click.option("--target", "-t", multiple=True,
+              type=click.Choice([t.value for t in Target], case_sensitive=False),
+              help="Target AI coding agent(s)")
+@click.option("--scope", "-s", type=click.Choice([s.value for s in Scope], case_sensitive=False),
+              default="project", help="Installation scope")
+@click.option("--auto/--no-auto", default=False, help="Auto-detect and install all compatible targets")
+@click.pass_context
+def install(ctx: click.Context, target: list[str], scope: str, auto: bool):
+    """Install python-skills for AI coding agents."""
+    project_root = ctx.obj["project_root"]
+    dry_run = ctx.obj["dry_run"]
+    scope_enum = Scope(scope)
+
+    console.print(Panel.fit(
+        f"[bold]Python Skills Installer[/bold]\n"
+        f"Project: {project_root}\n"
+        f"Scope: {scope}\n"
+        f"Dry run: {dry_run}",
+        title="Installation"
+    ))
+
+    # Parse targets
+    targets = [Target(t.lower()) for t in target] if target else None
+
+    # Create config
+    config = InstallConfig(
+        targets=targets or [],
+        scope=scope_enum,
+        dry_run=dry_run
+    )
+
+    # Create installer
+    installer = SkillInstaller(project_root, config)
+
+    # Detect environments
+    detection = installer.detect_environments()
+
+    # Print detection results
+    table = Table(title="Environment Detection")
+    table.add_column("Target", style="cyan")
+    table.add_column("Application", style="green")
+    table.add_column("Project Config", style="yellow")
+    table.add_column("Details", style="dim")
+
+    for name, result in detection.targets.items():
+        app_status = "Yes" if result.application_detected else "No"
+        proj_status = "Yes" if result.project_config_detected else "No"
+        table.add_row(name, app_status, proj_status, result.details)
+
+    console.print(table)
+    console.print()
+
+    # Plan installation
+    plan = installer.plan_installation(
+        targets=targets,
+        scope=scope_enum,
+        auto=auto
+    )
+
+    if not plan.targets:
+        console.print("[yellow]No targets to install[/yellow]")
+        return
+
+    # Print plan
+    plan_table = Table(title="Installation Plan")
+    plan_table.add_column("Target", style="cyan")
+    plan_table.add_column("Scope", style="green")
+    plan_table.add_column("Dry Run", style="yellow")
+
+    for target, scope_val in plan.targets.items():
+        plan_table.add_row(target.value, scope_val.value, "Yes" if plan.dry_run else "No")
+
+    console.print(plan_table)
+    console.print()
+
+    if dry_run:
+        console.print("[yellow]DRY RUN - No changes will be made[/yellow]")
+        return
+
+    # Confirm
+    if not click.confirm("Proceed with installation?"):
+        console.print("[red]Installation cancelled[/red]")
+        return
+
+    # Execute installation
+    console.print("\n[bold]Installing...[/bold]")
+    results = installer.execute_install(plan)
+
+    # Summary
+    success_count = sum(1 for r in results.values() if r.success)
+    total_count = len(results)
+
+    console.print(f"\n[bold]Installation complete: {success_count}/{total_count} successful[/bold]")
+
+    if success_count < total_count:
+        sys.exit(1)
+
+
+@main.command()
+@click.option("--target", "-t", multiple=True,
+              type=click.Choice([t.value for t in Target], case_sensitive=False),
+              help="Target(s) to sync")
+@click.option("--scope", "-s", type=click.Choice([s.value for s in Scope], case_sensitive=False),
+              default="project", help="Sync scope")
+@click.pass_context
+def sync(ctx: click.Context, target: list[str], scope: str):
+    """Sync python-skills with current canonical skills."""
+    project_root = ctx.obj["project_root"]
+    dry_run = ctx.obj["dry_run"]
+    scope_enum = Scope(scope)
+
+    console.print(Panel.fit(
+        f"[bold]Python Skills Sync[/bold]\n"
+        f"Project: {project_root}\n"
+        f"Scope: {scope}\n"
+        f"Dry run: {dry_run}",
+        title="Sync"
+    ))
+
+    config = InstallConfig(targets=[], scope=scope_enum, dry_run=dry_run)
+    installer = SkillInstaller(project_root, config)
+
+    targets = [Target(t.lower()) for t in target] if target else None
+
+    if dry_run:
+        console.print("[yellow]DRY RUN - No changes will be made[/yellow]")
+
+    console.print("\n[bold]Syncing...[/bold]")
+    results = installer.run_sync(scope=scope_enum, targets=targets, dry_run=dry_run)
+
+    # Summary
+    success_count = sum(1 for r in results.values() if r.success)
+    total_count = len(results)
+
+    console.print(f"\n[bold]Sync complete: {success_count}/{total_count} successful[/bold]")
+
+    if success_count < total_count:
+        sys.exit(1)
+
+
+@main.command()
+@click.option("--target", "-t", multiple=True,
+              type=click.Choice([t.value for t in Target], case_sensitive=False),
+              help="Target(s) to uninstall")
+@click.option("--scope", "-s", type=click.Choice([s.value for s in Scope], case_sensitive=False),
+              default="project", help="Uninstall scope")
+@click.pass_context
+def uninstall(ctx: click.Context, target: list[str], scope: str):
+    """Uninstall python-skills for AI coding agents."""
+    project_root = ctx.obj["project_root"]
+    dry_run = ctx.obj["dry_run"]
+    scope_enum = Scope(scope)
+
+    console.print(Panel.fit(
+        f"[bold]Python Skills Uninstaller[/bold]\n"
+        f"Project: {project_root}\n"
+        f"Scope: {scope}\n"
+        f"Dry run: {dry_run}",
+        title="Uninstallation"
+    ))
+
+    targets = [Target(t.lower()) for t in target] if target else None
+
+    config = InstallConfig(targets=targets or [], scope=scope_enum, dry_run=dry_run)
+    installer = SkillInstaller(project_root, config)
+
+    if dry_run:
+        console.print("[yellow]DRY RUN - No changes will be made[/yellow]")
+
+    console.print("\n[bold]Uninstalling...[/bold]")
+    results = installer.run_uninstall(scope=scope_enum, targets=targets, dry_run=dry_run)
+
+    success_count = sum(1 for r in results.values() if r.success)
+    total_count = len(results)
+
+    console.print(f"\n[bold]Uninstallation complete: {success_count}/{total_count} successful[/bold]")
+
+    if success_count < total_count:
+        sys.exit(1)
+
+
+@main.command()
+@click.option("--scope", "-s", type=click.Choice([s.value for s in Scope], case_sensitive=False),
+              default="project", help="Status scope")
+@click.pass_context
+def status(ctx: click.Context, scope: str):
+    """Show installation status."""
+    project_root = ctx.obj["project_root"]
+    scope_enum = Scope(scope)
+
+    console.print(Panel.fit(
+        f"[bold]Python Skills Status[/bold]\n"
+        f"Project: {project_root}\n"
+        f"Scope: {scope}",
+        title="Status"
+    ))
+
+    config = InstallConfig(targets=[], scope=scope_enum, dry_run=False)
+    installer = SkillInstaller(project_root, config)
+
+    console.print("\n[bold]Installation Status[/bold]")
+    results = installer.get_status(scope=scope_enum)
+
+    # Summary table
+    table = Table()
+    table.add_column("Target", style="cyan")
+    table.add_column("Status", style="green")
+    table.add_column("Files", style="yellow")
+
+    for name, result in results.items():
+        status = "Installed" if result.installed else "Not installed"
+        table.add_row(name, status, str(len(result.files)))
+
+    console.print(table)
+
+
+@main.command()
+@click.option("--scope", "-s", type=click.Choice([s.value for s in Scope], case_sensitive=False),
+              default="project", help="Detection scope")
+@click.option("--project-root", "-p", type=click.Path(exists=True, file_okay=False, path_type=Path),
+              default=".", help="Project root directory")
+@click.pass_context
+def detect(ctx: click.Context, scope: str, project_root: Path):
+    """Detect AI coding agent environments."""
+    scope_enum = Scope(scope)
+
+    console.print(Panel.fit(
+        f"[bold]Environment Detection[/bold]\n"
+        f"Project: {project_root}\n"
+        f"Scope: {scope}",
+        title="Detection"
+    ))
+
+    detector = EnvironmentDetector(project_root)
+    detection = detector.detect_all()
+
+    table = Table(title="Environment Detection Results")
+    table.add_column("Target", style="cyan")
+    table.add_column("Application", style="green")
+    table.add_column("Project Config", style="yellow")
+    table.add_column("Global Config", style="blue")
+    table.add_column("Details", style="dim")
+
+    for name, result in detection.targets.items():
+        app = "Yes" if result.application_detected else "No"
+        proj = "Yes" if result.project_config_detected else "No"
+        glob = "Yes" if (result.details and "Global: yes" in result.details) else "No"
+        table.add_row(name, app, proj, glob, result.details)
+
+    console.print(table)
+
+
+@main.command()
+@click.option("--category", "-c", help="Filter by category")
+def list(category: str):
+    """List available skills and supported targets."""
+    from python_skills.skills.registry import get_registry
+
+    registry = get_registry()
+
+    # List targets
+    console.print(Panel.fit(
+        "[bold]Supported Targets (16)[/bold]\n"
+        + "\n".join(f"  {t.value}" for t in Target),
+        title="Targets"
+    ))
+
+    # List skills
+    if category:
+        skills = registry.get_skills_by_category(category)
+        title = f"Skills in '{category}'"
+    else:
+        skills = registry.get_all_skills()
+        title = f"All Skills ({len(skills)})"
+
+    table = Table(title=title)
+    table.add_column("Name", style="cyan")
+    table.add_column("Category", style="green")
+    table.add_column("Description", style="dim")
+
+    for skill in sorted(skills, key=lambda s: s.name):
+        desc = skill.description[:60] + "..." if len(skill.description) > 60 else skill.description
+        table.add_row(skill.name, skill.category, desc)
+
+    console.print(table)
+
+
+@main.command()
+def version():
+    """Show version."""
+    from python_skills import __version__
+    console.print(f"python-skills v{__version__}")
+
+
+if __name__ == "__main__":
+    main()

python_skills/config.py

@@ -0,0 +1,160 @@
+"""Configuration management for python-skills."""
+
+from dataclasses import dataclass
+from enum import Enum
+
+
+class Scope(str, Enum):
+    """Installation scope."""
+    PROJECT = "project"
+    GLOBAL = "global"
+
+
+class Target(str, Enum):
+    """Target AI coding agent."""
+    CLAUDE = "claude"
+    CURSOR = "cursor"
+    KIRO = "kiro"
+    CLINE = "cline"
+    OPENCODE = "opencode"
+    WINDSURF = "windsurf"
+    VSCODE = "vscode"
+    ROO = "roo"
+    GEMINI = "gemini"
+    CODEX = "codex"
+    JETBRAINS = "jetbrains"
+    GOOSE = "goose"
+    ZED = "zed"
+    CONTINUE = "continue"
+    AIDER = "aider"
+    UNIVERSAL = "universal"
+
+
+@dataclass
+class AdapterCapabilities:
+    """Capabilities of an adapter."""
+    supports_project: bool = True
+    supports_global: bool = False
+    has_native_skills: bool = False
+    has_native_rules: bool = False
+    has_native_instructions: bool = False
+    supports_path_conditions: bool = False
+    supports_file_references: bool = False
+    supports_manual_activation: bool = False
+    supports_auto_activation: bool = True
+    supports_cli: bool = False
+    supports_ide: bool = False
+    safe_uninstall: bool = True
+    adapter_class: str = "E"  # A=NativeSkills, B=NativeRules, C=NativeInstructions, D=Config, E=Universal
+
+
+ADAPTER_CAPABILITIES = {
+    Target.CLAUDE: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_rules=True,
+        has_native_instructions=True, supports_path_conditions=True,
+        supports_file_references=True, supports_cli=True,
+        adapter_class="A",
+    ),
+    Target.CURSOR: AdapterCapabilities(
+        supports_project=True, supports_global=False,
+        has_native_rules=True, supports_path_conditions=True,
+        supports_ide=True, adapter_class="B",
+    ),
+    Target.KIRO: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_rules=True,
+        has_native_instructions=True, supports_path_conditions=True,
+        supports_ide=True, adapter_class="A",
+    ),
+    Target.CLINE: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_rules=True,
+        has_native_instructions=True, supports_path_conditions=True,
+        supports_ide=True, adapter_class="A",
+    ),
+    Target.OPENCODE: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_instructions=True,
+        supports_file_references=True,
+        supports_cli=True, supports_ide=True,
+        adapter_class="A",
+    ),
+    Target.WINDSURF: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_rules=True,
+        has_native_instructions=True, supports_path_conditions=True,
+        supports_ide=True, adapter_class="A",
+    ),
+    Target.VSCODE: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_rules=True,
+        has_native_instructions=True, supports_path_conditions=True,
+        supports_file_references=True,
+        supports_cli=True, supports_ide=True,
+        adapter_class="A",
+    ),
+    Target.ROO: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_rules=True,
+        has_native_instructions=True,
+        supports_ide=True, adapter_class="A",
+    ),
+    Target.GEMINI: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_instructions=True,
+        supports_file_references=True,
+        supports_cli=True, adapter_class="A",
+    ),
+    Target.CODEX: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_instructions=True,
+        supports_cli=True, adapter_class="A",
+    ),
+    Target.JETBRAINS: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_instructions=True,
+        supports_ide=True, adapter_class="A",
+    ),
+    Target.GOOSE: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_instructions=True,
+        supports_file_references=True,
+        supports_cli=True, adapter_class="A",
+    ),
+    Target.ZED: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_skills=True, has_native_instructions=True,
+        supports_ide=True, adapter_class="A",
+    ),
+    Target.CONTINUE: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_rules=True, has_native_instructions=True,
+        supports_path_conditions=True,
+        supports_ide=True, adapter_class="B",
+    ),
+    Target.AIDER: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_instructions=True,
+        supports_cli=True, adapter_class="D",
+    ),
+    Target.UNIVERSAL: AdapterCapabilities(
+        supports_project=True, supports_global=True,
+        has_native_instructions=True,
+        supports_cli=True, supports_ide=True,
+        adapter_class="E",
+    ),
+}
+
+
+@dataclass
+class InstallConfig:
+    """Configuration for installation."""
+    targets: list[Target]
+    scope: Scope = Scope.PROJECT
+    dry_run: bool = False
+
+
+def get_adapter_capabilities(target: Target) -> AdapterCapabilities:
+    """Get capabilities for a target adapter."""
+    return ADAPTER_CAPABILITIES.get(target, AdapterCapabilities())

python_skills/detector.py

@@ -0,0 +1,152 @@
+"""Environment detection for AI coding agents."""
+
+import shutil
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from python_skills.adapters.base import DetectionResult
+from python_skills.config import Target
+
+
+@dataclass
+class DetectionSummary:
+    """Summary of detection results for all targets."""
+    targets: dict[str, DetectionResult] = field(default_factory=dict)
+
+    def get_available_targets(self) -> list[str]:
+        """Get list of targets with detected application."""
+        return [name for name, result in self.targets.items() if result.application_detected]
+
+
+class EnvironmentDetector:
+    """Detects AI coding agent environments and configurations."""
+
+    def __init__(self, project_root: Path):
+        self.project_root = Path(project_root).resolve()
+
+    def detect_all(self) -> DetectionSummary:
+        """Detect all supported AI coding agents."""
+        summary = DetectionSummary()
+
+        # Existing targets
+        summary.targets[Target.CLAUDE.value] = self._detect_claude()
+        summary.targets[Target.CURSOR.value] = self._detect_cursor()
+        summary.targets[Target.KIRO.value] = self._detect_kiro()
+        summary.targets[Target.CLINE.value] = self._detect_cline()
+
+        # Phase 4 targets
+        summary.targets[Target.OPENCODE.value] = self._detect_app("opencode", [".opencode", "opencode.json", "opencode.jsonc"])
+        summary.targets[Target.WINDSURF.value] = self._detect_dir_only([".windsurf", ".devin"])
+        summary.targets[Target.VSCODE.value] = self._detect_app("code", [".github", ".vscode"])
+        summary.targets[Target.ROO.value] = self._detect_dir_only([".roo", ".roorules"])
+        summary.targets[Target.GEMINI.value] = self._detect_app("gemini", [".gemini", "GEMINI.md"])
+        summary.targets[Target.CODEX.value] = self._detect_app("codex", ["AGENTS.md"])
+        summary.targets[Target.JETBRAINS.value] = self._detect_dir_only([".junie"])
+        summary.targets[Target.GOOSE.value] = self._detect_app("goose", [".goosehints", "AGENTS.md"])
+        summary.targets[Target.ZED.value] = self._detect_app("zed", ["AGENTS.md", ".agents"])
+        summary.targets[Target.CONTINUE.value] = self._detect_dir_only([".continue"])
+        summary.targets[Target.AIDER.value] = self._detect_app("aider", [".aider.conf.yml"])
+
+        # Universal (always available)
+        summary.targets[Target.UNIVERSAL.value] = DetectionResult(
+            application_detected=True,
+            project_config_detected=(self.project_root / "AGENTS.md").exists(),
+            adapter_available=True,
+            details="Universal adapter always available",
+        )
+
+        return summary
+
+    def _detect_app(self, command: str, project_markers: list[str]) -> DetectionResult:
+        """Detect application by command and project markers."""
+        app_detected = shutil.which(command) is not None
+        project_config = any((self.project_root / m).exists() for m in project_markers)
+
+        return DetectionResult(
+            application_detected=app_detected,
+            project_config_detected=project_config,
+            adapter_available=True,
+            details=f"App: {'yes' if app_detected else 'no'}, Project: {'yes' if project_config else 'no'}",
+        )
+
+    def _detect_dir_only(self, project_markers: list[str]) -> DetectionResult:
+        """Detect by project markers only (no CLI command)."""
+        project_config = any((self.project_root / m).exists() for m in project_markers)
+
+        return DetectionResult(
+            application_detected=False,
+            project_config_detected=project_config,
+            adapter_available=True,
+            details=f"App: IDE extension, Project: {'yes' if project_config else 'no'}",
+        )
+
+    def _detect_claude(self) -> DetectionResult:
+        """Detect Claude Code."""
+        app_detected = shutil.which("claude") is not None
+        project_config = (self.project_root / ".claude").exists()
+        global_config = (Path.home() / ".claude").exists()
+
+        return DetectionResult(
+            application_detected=app_detected,
+            project_config_detected=project_config,
+            adapter_available=True,
+            details=f"App: {'yes' if app_detected else 'no'}, Project: {'yes' if project_config else 'no'}, Global: {'yes' if global_config else 'no'}"
+        )
+
+    def _detect_cursor(self) -> DetectionResult:
+        """Detect Cursor."""
+        app_detected = shutil.which("cursor") is not None
+        project_config = (self.project_root / ".cursor").exists() or (self.project_root / ".cursorrules").exists()
+
+        return DetectionResult(
+            application_detected=app_detected,
+            project_config_detected=project_config,
+            adapter_available=True,
+            details=f"App: {'yes' if app_detected else 'no'}, Project: {'yes' if project_config else 'no'}"
+        )
+
+    def _detect_kiro(self) -> DetectionResult:
+        """Detect Kiro."""
+        app_detected = shutil.which("kiro") is not None
+        project_config = (self.project_root / ".kiro").exists()
+        global_config = (Path.home() / ".kiro").exists()
+
+        return DetectionResult(
+            application_detected=app_detected,
+            project_config_detected=project_config,
+            adapter_available=True,
+            details=f"App: {'yes' if app_detected else 'no'}, Project: {'yes' if project_config else 'no'}, Global: {'yes' if global_config else 'no'}"
+        )
+
+    def _detect_cline(self) -> DetectionResult:
+        """Detect Cline."""
+        app_detected = False
+        try:
+            result = subprocess.run(
+                ["code", "--list-extensions"],
+                capture_output=True, text=True, timeout=5
+            )
+            if "cline.cline" in result.stdout.lower():
+                app_detected = True
+        except Exception:
+            pass
+
+        project_config = (
+            (self.project_root / ".clinerules").exists() or
+            (self.project_root / ".cline").exists() or
+            (self.project_root / ".agents" / "skills").exists()
+        )
+
+        return DetectionResult(
+            application_detected=app_detected,
+            project_config_detected=project_config,
+            adapter_available=True,
+            details=f"App: {'yes' if app_detected else 'no'}, Project: {'yes' if project_config else 'no'}"
+        )
+
+
+def detect_environment(project_root: Path) -> 'DetectionSummary':
+    """Convenience function to detect all environments."""
+    detector = EnvironmentDetector(project_root)
+    return detector.detect_all()