@softspark/ai-toolkit 4.24.0 → 4.25.0

package/scripts/uninstall.py

@@ -1249,6 +1249,9 @@ def _transaction_specs(
     claude: Path,
     codex: list[CodexSurface],
     copilot: list[CopilotSurface],
+    *,
+    target: Path,
+    scope: str,
 ) -> list[tuple[Path, bool, Path]]:
     specs: dict[Path, tuple[bool, Path]] = {}
 
@@ -1299,6 +1302,11 @@ def _transaction_specs(
             (root / "hooks", True),
         ):
             add(path, recursive, trusted_root)
+    for config_root in _opencode_config_roots(target, scope):
+        root = config_root if config_root is not None else target / ".opencode"
+        add(root / "skills", True, target)
+    for root in _cline_transaction_roots(target, scope):
+        add(root, True, target)
     return [
         (path, recursive, trusted_root)
         for path, (recursive, trusted_root) in specs.items()
@@ -1308,8 +1316,9 @@ def _transaction_specs(
 def _parse_args(argv: list[str]) -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         description=(
-            "Remove only ai-toolkit-managed Claude, Codex, Copilot, and "
-            "leftover v4.16.x recovery data while preserving user-owned content."
+            "Remove only ai-toolkit-managed Claude, Codex, Copilot, Cline, OpenCode, "
+            "and leftover v4.16.x recovery data while preserving user-owned "
+            "content."
         ),
         epilog=(
             "Global Codex and Copilot locations honor CODEX_HOME and "
@@ -1329,15 +1338,131 @@ def _parse_args(argv: list[str]) -> argparse.Namespace:
     return args
 
 
-def _remove_editor_hook_configs(target: Path) -> None:
-    """Strip toolkit hook entries from editor configs that have no other cleanup.
+def _opencode_config_roots(target: Path, scope: str) -> list[Path | None]:
+    roots: list[Path | None] = []
+    if scope in {"local", "both"}:
+        roots.append(None)
+    if scope in {"global", "both"}:
+        roots.append(target / ".config" / "opencode")
+    return roots
+
+
+def _cline_transaction_roots(target: Path, scope: str) -> list[Path]:
+    roots = {target / ".cline" / "skills"}
+    if scope in {"local", "both"}:
+        roots.update(
+            {
+                target / ".cline" / "rules",
+                target / ".cline" / "hooks",
+                target / ".clinerules",
+            }
+        )
+    if scope in {"global", "both"}:
+        roots.update(
+            {
+                target / ".cline" / "rules",
+                target / ".cline" / "hooks",
+                target / "Documents" / "Cline" / "Rules",
+                target / "Documents" / "Cline" / "Hooks",
+            }
+        )
+    return sorted(roots)
+
+
+def _discover_opencode_skills(
+    target: Path,
+    scope: str,
+) -> list[tuple[str, str]]:
+    from generate_opencode_skills import discover
+
+    found: list[tuple[str, str]] = []
+    for config_root in _opencode_config_roots(target, scope):
+        count = discover(target, config_root=config_root)
+        if count:
+            location = config_root or target / ".opencode"
+            found.append(
+                (f"Managed: {location / 'skills'} ({count} OpenCode skills)",
+                 "opencode-skills")
+            )
+    return found
+
+
+def _discover_cline_surfaces(target: Path, scope: str) -> list[tuple[str, str]]:
+    from generate_cline_hooks import discover as discover_cline_hooks
+    from generate_cline_rules import managed_files as managed_cline_rules
+    from generate_cline_skills import discover as discover_cline_skills
+
+    count = 0
+    if scope in {"local", "both"}:
+        count += len(managed_cline_rules(target))
+        count += discover_cline_hooks(target)
+    if scope in {"global", "both"}:
+        global_rules = (
+            target / ".cline" / "rules",
+            target / "Documents" / "Cline" / "Rules",
+        )
+        count += len(
+            managed_cline_rules(
+                target,
+                output_roots=global_rules,
+                include_workflows=False,
+            )
+        )
+        if scope == "global":
+            count += discover_cline_hooks(
+                target,
+                hooks_root=target / ".cline" / "hooks",
+            )
+        count += discover_cline_hooks(
+            target,
+            hooks_root=target / "Documents" / "Cline" / "Hooks",
+        )
+    count += discover_cline_skills(target)
+    if not count:
+        return []
+    return [(f"Managed: Cline native surfaces ({count} artifacts)", "cline")]
+
+
+def _cleanup_cline_surfaces(target: Path, scope: str) -> None:
+    from generate_cline_hooks import cleanup as cleanup_cline_hooks
+    from generate_cline_rules import cleanup as cleanup_cline_rules
+    from generate_cline_skills import cleanup as cleanup_cline_skills
 
-    Best effort by design: a missing generator or an unreadable config must not
-    abort an uninstall that has already removed the primary surfaces.
+    if scope in {"local", "both"}:
+        cleanup_cline_rules(target)
+        cleanup_cline_hooks(target)
+    if scope in {"global", "both"}:
+        global_rule_roots = [target / "Documents" / "Cline" / "Rules"]
+        if scope == "global":
+            global_rule_roots.insert(0, target / ".cline" / "rules")
+        cleanup_cline_rules(
+            target,
+            output_roots=tuple(global_rule_roots),
+            include_workflows=False,
+        )
+        if scope == "global":
+            cleanup_cline_hooks(
+                target,
+                hooks_root=target / ".cline" / "hooks",
+            )
+        cleanup_cline_hooks(
+            target,
+            hooks_root=target / "Documents" / "Cline" / "Hooks",
+        )
+    cleanup_cline_skills(target)
+
+
+def _remove_editor_managed_surfaces(target: Path, scope: str) -> None:
+    """Strip managed editor surfaces that have no primary uninstall path.
+
+    Cursor, Gemini, and OpenCode compatibility cleanup remains best effort.
+    Cline cleanup is transactional and fail-closed so the outer uninstall can
+    roll every managed Cline root back after a partial failure.
     """
-    for module_name, label in (
-        ("generate_cursor_hooks", "Cursor"),
-        ("generate_gemini_hooks", "Gemini"),
+    for module_name, label, surface in (
+        ("generate_cursor_hooks", "Cursor", "hook entries"),
+        ("generate_gemini_hooks", "Gemini", "hook entries"),
+        ("generate_gemini_agents", "Gemini", "agents"),
     ):
         try:
             module = importlib.import_module(module_name)
@@ -1346,9 +1471,22 @@ def _remove_editor_hook_configs(target: Path) -> None:
                 continue
             cleanup(target)
         except (ImportError, OSError, RuntimeError, ValueError) as error:
-            print(f"  WARN could not clean {label} hooks: {error}")
+            print(f"  WARN could not clean {label} {surface}: {error}")
         else:
-            print(f"  Cleaned: {label} hook entries")
+            print(f"  Cleaned: {label} {surface}")
+
+    from generate_opencode_skills import cleanup as cleanup_opencode_skills
+
+    for config_root in _opencode_config_roots(target, scope):
+        try:
+            cleanup_opencode_skills(target, config_root=config_root)
+        except (OSError, RuntimeError, ValueError) as error:
+            print(f"  WARN could not clean OpenCode skills: {error}")
+        else:
+            print("  Cleaned: OpenCode skills")
+
+    _cleanup_cline_surfaces(target, scope)
+    print("  Cleaned: Cline native surfaces")
 
 
 def main(argv: list[str] | None = None) -> None:
@@ -1380,6 +1518,8 @@ def main(argv: list[str] | None = None) -> None:
             components.extend(_discover_codex(surface))
         for surface in copilot:
             components.extend(_discover_copilot(surface))
+        components.extend(_discover_opencode_skills(target, scope))
+        components.extend(_discover_cline_surfaces(target, scope))
         recovery_root = (
             target / ".softspark" / "ai-toolkit" / "sessions"
             if scope in {"global", "both"}
@@ -1429,7 +1569,13 @@ def main(argv: list[str] | None = None) -> None:
     transaction: _UninstallTransaction | None = None
     try:
         transaction = _UninstallTransaction(
-            _transaction_specs(claude, codex, copilot)
+            _transaction_specs(
+                claude,
+                codex,
+                copilot,
+                target=target,
+                scope=scope,
+            )
         )
         _preflight(target, claude, codex, copilot)
         remove_components(claude, target)
@@ -1439,12 +1585,10 @@ def main(argv: list[str] | None = None) -> None:
         for surface in copilot:
             _preflight(target, claude, [], [surface])
             _remove_copilot(surface)
-        # Cursor and Gemini hook configs were never cleaned: uninstall knew
-        # only Codex and Copilot, so `.cursor/hooks.json` and the hooks block in
-        # `.gemini/settings.json` survived an uninstall. Both cleanups strip
-        # only entries tagged `ai-toolkit`, leaving user-authored and
-        # plugin-pack entries and any unrelated settings in place.
-        _remove_editor_hook_configs(target)
+        # Cursor and Gemini configs have no primary uninstall branch. These
+        # cleanups strip only managed hook entries and Gemini agent files,
+        # leaving user-authored, plugin-owned, and unrelated settings intact.
+        _remove_editor_managed_surfaces(target, scope)
         if recovery_root is not None and recovery_components:
             # The recovery API preflights its complete tree before the first
             # unlink. A later I/O fault can still leave recovery partially

package/scripts/validate.py

@@ -21,6 +21,7 @@ from __future__ import annotations
 import json
 import re
 import sys
+import tempfile
 from pathlib import Path
 
 sys.path.insert(0, str(Path(__file__).resolve().parent))
@@ -74,25 +75,35 @@ VALID_HOOK_TYPES = frozenset({
     "mcp_tool",
 })
 
+PROMPT_AGENT_HOOK_EVENTS = frozenset({
+    "PermissionDenied",
+    "PermissionRequest",
+    "PostToolBatch",
+    "PostToolUse",
+    "PostToolUseFailure",
+    "PreToolUse",
+    "Stop",
+    "SubagentStop",
+    "TaskCompleted",
+    "TaskCreated",
+    "TeammateIdle",
+    "UserPromptExpansion",
+    "UserPromptSubmit",
+})
+
+HTTP_HOOK_EVENTS = VALID_HOOK_EVENTS - {"SessionStart", "Setup"}
+
 HOOK_TYPE_EVENTS = {
-    "agent": frozenset({"Stop", "SubagentStop"}),
-    "prompt": frozenset({
-        "PreToolUse",
-        "PostToolUse",
-        "PostToolUseFailure",
-        "PostToolBatch",
-        "UserPromptSubmit",
-        "UserPromptExpansion",
-        "Stop",
-        "SubagentStop",
-    }),
+    "agent": PROMPT_AGENT_HOOK_EVENTS,
+    "http": HTTP_HOOK_EVENTS,
+    "prompt": PROMPT_AGENT_HOOK_EVENTS,
 }
 
 HOOK_REQUIRED_FIELDS = {
     "command": ("command",),
     "http": ("url",),
     "prompt": ("prompt",),
-    "agent": ("agent",),
+    "agent": ("prompt",),
     "mcp_tool": ("server", "tool", "arguments"),
 }
 
@@ -736,6 +747,25 @@ def validate_planned_assets(tk_dir: Path, vr: ValidationResult) -> None:
     except (OSError, ValueError, json.JSONDecodeError) as exc:
         vr.error(f"Invalid Claude app generated assets: {exc}")
 
+    # Validate a clean native Codex plugin stage without touching user state.
+    if tk_dir.resolve() == default_toolkit_dir.resolve():
+        try:
+            from codex_plugin import PLUGIN_NAME, stage_plugin, validate_staged_plugin
+
+            with tempfile.TemporaryDirectory(
+                prefix="ai-toolkit-codex-plugin-validation-"
+            ) as temporary:
+                staged = Path(temporary) / PLUGIN_NAME
+                stage_plugin(staged)
+                errors = validate_staged_plugin(staged)
+            if errors:
+                for error in errors:
+                    vr.error(f"Invalid native Codex plugin: {error}")
+            else:
+                print("  OK: native Codex plugin stage is schema-valid and self-contained")
+        except (OSError, ValueError, json.JSONDecodeError) as exc:
+            vr.error(f"Invalid native Codex plugin generated assets: {exc}")
+
     # Validate benchmark dashboard JSON
     benchmark_dashboard = tk_dir / "benchmarks" / "ecosystem-dashboard.json"
     if benchmark_dashboard.is_file():