erk 0.4.5__py3-none-any.whl

erk/core/health_checks_dogfooder/__init__.py

@@ -0,0 +1,85 @@
+"""Early dogfooder health checks for erk doctor command.
+
+These checks are for temporary issues that affect early dogfooders and
+can be deleted once the issues are resolved. The subpackage structure
+makes it easy to remove individual checks or the entire package.
+
+To delete one check:
+    1. Remove the check's module file
+    2. Remove from imports and EARLY_DOGFOODER_CHECK_NAMES below
+
+To delete all dogfooder checks:
+    1. Delete this directory (src/erk/core/health_checks_dogfooder/)
+    2. Remove import from health_checks.py, remove run_early_dogfooder_checks() call
+    3. Remove early dogfooder category handling from doctor.py
+"""
+
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+from erk.core.health_checks_dogfooder.deprecated_dot_agent_config import (
+    check_deprecated_dot_agent_config,
+)
+from erk.core.health_checks_dogfooder.legacy_claude_docs import (
+    check_legacy_claude_docs,
+)
+from erk.core.health_checks_dogfooder.legacy_config_locations import (
+    check_legacy_config_locations,
+)
+from erk.core.health_checks_dogfooder.legacy_erk_docs_agent import (
+    check_legacy_erk_docs_agent,
+)
+from erk.core.health_checks_dogfooder.legacy_erk_kits_folder import (
+    check_legacy_erk_kits_folder,
+)
+from erk.core.health_checks_dogfooder.legacy_hook_settings import (
+    check_legacy_hook_settings,
+)
+from erk.core.health_checks_dogfooder.legacy_kit_yaml import (
+    check_legacy_kit_yaml,
+)
+from erk.core.health_checks_dogfooder.legacy_kits_toml import (
+    check_legacy_kits_toml,
+)
+from erk.core.health_checks_dogfooder.outdated_erk_skill import (
+    check_outdated_erk_skill,
+)
+
+# Names of all early dogfooder checks - used by doctor.py for category grouping
+EARLY_DOGFOODER_CHECK_NAMES: set[str] = {
+    "deprecated-dot-agent-config",
+    "legacy-claude-docs",
+    "legacy-config",
+    "legacy-erk-docs",
+    "legacy-erk-kits-folder",
+    "legacy-hook-settings",
+    "legacy-kit-yaml",
+    "legacy-kits-toml",
+    "outdated-erk-skill",
+}
+
+
+def run_early_dogfooder_checks(
+    repo_root: Path,
+    metadata_dir: Path | None,
+) -> list[CheckResult]:
+    """Run all early dogfooder health checks.
+
+    Args:
+        repo_root: Path to the repository root
+        metadata_dir: Path to ~/.erk/repos/<repo>/ metadata directory, if known
+
+    Returns:
+        List of CheckResult objects from all dogfooder checks
+    """
+    return [
+        check_deprecated_dot_agent_config(repo_root),
+        check_legacy_claude_docs(repo_root),
+        check_legacy_config_locations(repo_root, metadata_dir),
+        check_legacy_erk_docs_agent(repo_root),
+        check_legacy_erk_kits_folder(repo_root),
+        check_legacy_hook_settings(repo_root),
+        check_legacy_kit_yaml(repo_root),
+        check_legacy_kits_toml(repo_root),
+        check_outdated_erk_skill(repo_root),
+    ]

erk/core/health_checks_dogfooder/deprecated_dot_agent_config.py

@@ -0,0 +1,64 @@
+"""Check for deprecated [tool.dot-agent] config in pyproject.toml.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have migrated to [tool.erk].
+"""
+
+from pathlib import Path
+
+import tomli
+
+from erk.core.health_checks import CheckResult
+
+
+def check_deprecated_dot_agent_config(repo_root: Path) -> CheckResult:
+    """Check for deprecated [tool.dot-agent] config in pyproject.toml.
+
+    This check detects the old configuration format and suggests migration
+    to [tool.erk].
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        CheckResult indicating whether deprecated config was found
+    """
+    pyproject_path = repo_root / "pyproject.toml"
+    if not pyproject_path.exists():
+        return CheckResult(
+            name="deprecated-dot-agent-config",
+            passed=True,
+            message="No deprecated [tool.dot-agent] config found",
+        )
+
+    with open(pyproject_path, "rb") as f:
+        data = tomli.load(f)
+
+    # Check for [tool.dot-agent] section
+    if "tool" not in data:
+        return CheckResult(
+            name="deprecated-dot-agent-config",
+            passed=True,
+            message="No deprecated [tool.dot-agent] config found",
+        )
+    if "dot-agent" not in data["tool"]:
+        return CheckResult(
+            name="deprecated-dot-agent-config",
+            passed=True,
+            message="No deprecated [tool.dot-agent] config found",
+        )
+
+    # Found deprecated config - return failure with remediation
+    return CheckResult(
+        name="deprecated-dot-agent-config",
+        passed=False,
+        message="Deprecated [tool.dot-agent] config in pyproject.toml",
+        details=(
+            "The [tool.dot-agent] section is deprecated.\n"
+            "\n"
+            "Remediation:\n"
+            "  1. Edit pyproject.toml\n"
+            "  2. Remove the [tool.dot-agent] section\n"
+            "  3. Use [tool.erk] for any erk configuration"
+        ),
+    )

erk/core/health_checks_dogfooder/legacy_claude_docs.py

@@ -0,0 +1,69 @@
+"""Check for legacy .claude/docs/ directory.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have migrated their docs to skills.
+"""
+
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+
+
+def check_legacy_claude_docs(repo_root: Path) -> CheckResult:
+    """Check for legacy .claude/docs/ directory.
+
+    Detects .claude/docs/ which is no longer supported. Standalone docs
+    should be converted to skills under .claude/skills/<name>/SKILL.md.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        CheckResult with warning if legacy docs directory found
+    """
+    docs_path = repo_root / ".claude" / "docs"
+
+    if not docs_path.exists():
+        return CheckResult(
+            name="legacy-claude-docs",
+            passed=True,
+            message="No legacy .claude/docs/ found",
+        )
+
+    # Check if it's a directory with markdown files
+    if not docs_path.is_dir():
+        return CheckResult(
+            name="legacy-claude-docs",
+            passed=True,
+            message="No legacy .claude/docs/ found",
+        )
+
+    # Find markdown files
+    md_files = list(docs_path.glob("*.md"))
+    if not md_files:
+        return CheckResult(
+            name="legacy-claude-docs",
+            passed=True,
+            message="No legacy .claude/docs/ found (empty directory)",
+        )
+
+    # Build details with file list
+    details_lines: list[str] = [
+        "Standalone docs in .claude/docs/ no longer supported.",
+        "",
+        "Files found:",
+    ]
+    for md_file in md_files[:5]:  # Limit display to first 5
+        details_lines.append(f"  - {md_file.name}")
+    if len(md_files) > 5:
+        details_lines.append(f"  ... and {len(md_files) - 5} more")
+    details_lines.append("")
+    details_lines.append("Convert to skills under .claude/skills/<name>/SKILL.md")
+
+    return CheckResult(
+        name="legacy-claude-docs",
+        passed=True,  # Warning only, doesn't fail
+        warning=True,
+        message=f"Found {len(md_files)} doc(s) in .claude/docs/",
+        details="\n".join(details_lines),
+    )

erk/core/health_checks_dogfooder/legacy_config_locations.py

@@ -0,0 +1,122 @@
+"""Check for legacy config.toml files that should be migrated.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have migrated their config to .erk/config.toml.
+"""
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+
+
+@dataclass(frozen=True)
+class LegacyConfigLocation:
+    """Information about a legacy config.toml location."""
+
+    path: Path
+    description: str
+
+
+def detect_legacy_config_locations(
+    repo_root: Path,
+    metadata_dir: Path | None,
+) -> list[LegacyConfigLocation]:
+    """Detect legacy config.toml files at old locations.
+
+    Checks for config files at:
+    - repo_root/config.toml (legacy location)
+    - metadata_dir/config.toml (legacy location)
+
+    Args:
+        repo_root: Path to the repository root
+        metadata_dir: Path to ~/.erk/repos/<repo>/ metadata directory, if known
+
+    Returns:
+        List of LegacyConfigLocation objects for any legacy configs found
+    """
+    legacy_locations: list[LegacyConfigLocation] = []
+
+    # Check for config at repo root (legacy location)
+    repo_root_config = repo_root / "config.toml"
+    if repo_root_config.exists():
+        legacy_locations.append(
+            LegacyConfigLocation(
+                path=repo_root_config,
+                description="repo root (legacy location)",
+            )
+        )
+
+    # Check for dot-agent.toml at repo root (legacy config location)
+    repo_root_dot_agent = repo_root / "dot-agent.toml"
+    if repo_root_dot_agent.exists():
+        legacy_locations.append(
+            LegacyConfigLocation(
+                path=repo_root_dot_agent,
+                description="repo root (legacy config)",
+            )
+        )
+
+    # Check for config in ~/.erk/repos/<repo>/ (legacy location)
+    if metadata_dir is not None:
+        metadata_dir_config = metadata_dir / "config.toml"
+        if metadata_dir_config.exists():
+            legacy_locations.append(
+                LegacyConfigLocation(
+                    path=metadata_dir_config,
+                    description="~/.erk/repos/ metadata dir (legacy location)",
+                )
+            )
+
+    return legacy_locations
+
+
+def check_legacy_config_locations(
+    repo_root: Path,
+    metadata_dir: Path | None,
+) -> CheckResult:
+    """Check for legacy config.toml files that should be migrated.
+
+    Detects config files at old locations (repo root, metadata dir) that should
+    be moved to .erk/config.toml. This is a warning-level check for early dogfooders.
+
+    Args:
+        repo_root: Path to the repository root
+        metadata_dir: Path to ~/.erk/repos/<repo>/ metadata directory, if known
+
+    Returns:
+        CheckResult with warning if legacy configs found
+    """
+    # Skip if primary location exists (config already migrated)
+    primary_path = repo_root / ".erk" / "config.toml"
+    if primary_path.exists():
+        return CheckResult(
+            name="legacy-config",
+            passed=True,
+            message="Config at primary location (.erk/config.toml)",
+        )
+
+    # Detect any legacy configs
+    legacy_locations = detect_legacy_config_locations(repo_root, metadata_dir)
+
+    if not legacy_locations:
+        return CheckResult(
+            name="legacy-config",
+            passed=True,
+            message="No legacy config files found",
+        )
+
+    # Build details with migration instructions
+    details_lines: list[str] = ["Legacy config files found:"]
+    for loc in legacy_locations:
+        details_lines.append(f"  - {loc.path} ({loc.description})")
+    details_lines.append("")
+    details_lines.append(f"Move to: {primary_path}")
+
+    return CheckResult(
+        name="legacy-config",
+        passed=True,  # Warning only - doesn't fail the check
+        warning=True,
+        message=f"Found {len(legacy_locations)} legacy config file(s)",
+        details="\n".join(details_lines),
+    )

erk/core/health_checks_dogfooder/legacy_erk_docs_agent.py

@@ -0,0 +1,61 @@
+"""Check for legacy .erk/docs/agent/ directory.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have migrated their docs to docs/learned/.
+"""
+
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+
+
+def check_legacy_erk_docs_agent(repo_root: Path) -> CheckResult:
+    """Check for legacy .erk/docs/agent/ directory.
+
+    Detects .erk/docs/agent/ which should be moved to docs/learned/.
+    This is an erk-specific documentation location change.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        CheckResult with warning if legacy docs directory found
+    """
+    agent_docs_path = repo_root / ".erk" / "docs" / "agent"
+
+    if not agent_docs_path.exists():
+        return CheckResult(
+            name="legacy-erk-docs",
+            passed=True,
+            message="No legacy .erk/docs/agent/ found",
+        )
+
+    if not agent_docs_path.is_dir():
+        return CheckResult(
+            name="legacy-erk-docs",
+            passed=True,
+            message="No legacy .erk/docs/agent/ found",
+        )
+
+    # Count files in the directory
+    files = list(agent_docs_path.glob("**/*"))
+    file_count = len([f for f in files if f.is_file()])
+
+    if file_count == 0:
+        return CheckResult(
+            name="legacy-erk-docs",
+            passed=True,
+            message="No legacy .erk/docs/agent/ found (empty directory)",
+        )
+
+    return CheckResult(
+        name="legacy-erk-docs",
+        passed=True,  # Warning only, doesn't fail
+        warning=True,
+        message=f"Legacy docs location found ({file_count} file(s))",
+        details=(
+            f"Directory: {agent_docs_path}\n"
+            "Documentation has moved from .erk/docs/agent/ to docs/learned/.\n"
+            "Move your documentation files to docs/learned/."
+        ),
+    )

erk/core/health_checks_dogfooder/legacy_erk_kits_folder.py

@@ -0,0 +1,60 @@
+"""Check for legacy .erk/kits/ directory.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have removed their kits folder.
+"""
+
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+
+
+def check_legacy_erk_kits_folder(repo_root: Path) -> CheckResult:
+    """Check for legacy .erk/kits/ directory.
+
+    Detects .erk/kits/ which is no longer used. The kit system has been
+    removed entirely from erk.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        CheckResult with warning if legacy kits folder found
+    """
+    kits_path = repo_root / ".erk" / "kits"
+
+    if not kits_path.exists():
+        return CheckResult(
+            name="legacy-erk-kits-folder",
+            passed=True,
+            message="No legacy .erk/kits/ found",
+        )
+
+    if not kits_path.is_dir():
+        return CheckResult(
+            name="legacy-erk-kits-folder",
+            passed=True,
+            message="No legacy .erk/kits/ found",
+        )
+
+    # Count items in the directory
+    items = list(kits_path.iterdir())
+
+    if not items:
+        return CheckResult(
+            name="legacy-erk-kits-folder",
+            passed=True,
+            message="No legacy .erk/kits/ found (empty directory)",
+        )
+
+    return CheckResult(
+        name="legacy-erk-kits-folder",
+        passed=True,  # Warning only, doesn't fail
+        warning=True,
+        message=f"Legacy kits folder found ({len(items)} item(s))",
+        details=(
+            f"Directory: {kits_path}\n"
+            "The kit system has been removed from erk.\n"
+            "You can safely delete the .erk/kits/ directory."
+        ),
+    )

erk/core/health_checks_dogfooder/legacy_hook_settings.py

@@ -0,0 +1,104 @@
+"""Check for legacy hook settings using erk kit exec commands.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have migrated their hooks to the unified hook script.
+"""
+
+import json
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+
+
+def detect_legacy_hook_commands(repo_root: Path) -> list[str]:
+    """Detect legacy 'erk kit exec' hook commands in Claude settings.
+
+    Checks .claude/settings.json for any hooks that use the old
+    'erk kit exec' or 'uvx erk' patterns.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        List of legacy hook command strings found
+    """
+    settings_path = repo_root / ".claude" / "settings.json"
+    if not settings_path.exists():
+        return []
+
+    content = settings_path.read_text(encoding="utf-8")
+    settings = json.loads(content)
+
+    hooks_section = settings.get("hooks", {})
+    legacy_commands: list[str] = []
+
+    # Check all hook types (UserPromptSubmit, etc.)
+    for hook_entries in hooks_section.values():
+        if not isinstance(hook_entries, list):
+            continue
+        for hook_entry in hook_entries:
+            if not isinstance(hook_entry, dict):
+                continue
+            # Handle nested structure: {matcher: ..., hooks: [...]}
+            nested_hooks = hook_entry.get("hooks", [])
+            if nested_hooks:
+                for hook in nested_hooks:
+                    if not isinstance(hook, dict):
+                        continue
+                    command = hook.get("command", "")
+                    if _is_legacy_hook_command(command):
+                        legacy_commands.append(command)
+            # Handle flat structure: {type: command, command: ...}
+            command = hook_entry.get("command", "")
+            if _is_legacy_hook_command(command):
+                legacy_commands.append(command)
+
+    return legacy_commands
+
+
+def _is_legacy_hook_command(command: str) -> bool:
+    """Check if a hook command uses legacy erk kit exec patterns."""
+    if not command:
+        return False
+    # Check for 'erk kit exec' or 'uvx erk' patterns
+    return "erk kit exec" in command or ("uvx" in command and "erk@" in command)
+
+
+def check_legacy_hook_settings(repo_root: Path) -> CheckResult:
+    """Check for legacy hook settings using erk kit exec commands.
+
+    Detects .claude/settings.json hooks that use old 'erk kit exec' or
+    'uvx erk@X.Y.Z kit exec' patterns. These won't work with current erk.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        CheckResult with failure if legacy hooks found
+    """
+    legacy_commands = detect_legacy_hook_commands(repo_root)
+
+    if not legacy_commands:
+        return CheckResult(
+            name="legacy-hook-settings",
+            passed=True,
+            message="No legacy hook commands found",
+        )
+
+    # Build details with migration instructions
+    details_lines: list[str] = ["Legacy hook commands found:"]
+    for cmd in legacy_commands[:5]:  # Limit display to first 5
+        # Truncate long commands
+        truncated = cmd[:80] + "..." if len(cmd) > 80 else cmd
+        details_lines.append(f"  - {truncated}")
+    if len(legacy_commands) > 5:
+        details_lines.append(f"  ... and {len(legacy_commands) - 5} more")
+    details_lines.append("")
+    details_lines.append("Run 'erk init' to update hook configuration")
+
+    return CheckResult(
+        name="legacy-hook-settings",
+        passed=False,  # Failure - hooks won't work
+        message=f"Found {len(legacy_commands)} legacy hook command(s)",
+        details="\n".join(details_lines),
+    )

erk/core/health_checks_dogfooder/legacy_kit_yaml.py

@@ -0,0 +1,78 @@
+"""Check for legacy kit.yaml files.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have removed their kit.yaml files.
+"""
+
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+
+
+def find_legacy_kit_yaml_files(repo_root: Path) -> list[Path]:
+    """Find legacy kit.yaml files in the repository.
+
+    Searches for kit.yaml files in:
+    - .claude/**
+    - .erk/kits/**
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        List of paths to kit.yaml files found
+    """
+    kit_yaml_files: list[Path] = []
+
+    # Check .claude/ directory
+    claude_dir = repo_root / ".claude"
+    if claude_dir.exists():
+        kit_yaml_files.extend(claude_dir.glob("**/kit.yaml"))
+
+    # Check .erk/kits/ directory
+    erk_kits_dir = repo_root / ".erk" / "kits"
+    if erk_kits_dir.exists():
+        kit_yaml_files.extend(erk_kits_dir.glob("**/kit.yaml"))
+
+    return kit_yaml_files
+
+
+def check_legacy_kit_yaml(repo_root: Path) -> CheckResult:
+    """Check for legacy kit.yaml files.
+
+    Detects kit.yaml files which are no longer used. Frontmatter-based
+    discovery is now used instead of kit manifests.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        CheckResult with warning if legacy kit.yaml files found
+    """
+    kit_yaml_files = find_legacy_kit_yaml_files(repo_root)
+
+    if not kit_yaml_files:
+        return CheckResult(
+            name="legacy-kit-yaml",
+            passed=True,
+            message="No legacy kit.yaml files found",
+        )
+
+    # Build details with file list
+    details_lines: list[str] = ["Legacy kit.yaml manifests found:"]
+    for kit_yaml in kit_yaml_files[:5]:  # Limit display to first 5
+        relative_path = kit_yaml.relative_to(repo_root)
+        details_lines.append(f"  - {relative_path}")
+    if len(kit_yaml_files) > 5:
+        details_lines.append(f"  ... and {len(kit_yaml_files) - 5} more")
+    details_lines.append("")
+    details_lines.append("Kit manifests are no longer used (frontmatter discovery is now used).")
+    details_lines.append("You can safely delete these files.")
+
+    return CheckResult(
+        name="legacy-kit-yaml",
+        passed=True,  # Warning only, doesn't fail
+        warning=True,
+        message=f"Found {len(kit_yaml_files)} legacy kit.yaml file(s)",
+        details="\n".join(details_lines),
+    )

erk/core/health_checks_dogfooder/legacy_kits_toml.py

@@ -0,0 +1,43 @@
+"""Check for legacy .erk/kits.toml file.
+
+This is a temporary check for early dogfooders. Delete this file once
+all users have removed their kits.toml files.
+"""
+
+from pathlib import Path
+
+from erk.core.health_checks import CheckResult
+
+
+def check_legacy_kits_toml(repo_root: Path) -> CheckResult:
+    """Check for legacy .erk/kits.toml file.
+
+    Detects .erk/kits.toml which is no longer used. Managed project
+    detection now uses .erk/config.toml instead.
+
+    Args:
+        repo_root: Path to the repository root
+
+    Returns:
+        CheckResult with warning if legacy kits.toml found
+    """
+    kits_toml_path = repo_root / ".erk" / "kits.toml"
+
+    if not kits_toml_path.exists():
+        return CheckResult(
+            name="legacy-kits-toml",
+            passed=True,
+            message="No legacy kits.toml found",
+        )
+
+    return CheckResult(
+        name="legacy-kits-toml",
+        passed=True,  # Warning only, doesn't fail
+        warning=True,
+        message="Legacy kits.toml found",
+        details=(
+            f"File: {kits_toml_path}\n"
+            "This file is no longer used. Managed project detection now uses .erk/config.toml.\n"
+            "You can safely delete this file."
+        ),
+    )