Dev10x 0.64.0__py3-none-any.whl

dev10x/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.46.0.dev0"

dev10x/cli.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import importlib
+from typing import Any
+
+import click
+
+
+class LazyGroup(click.Group):
+    def __init__(
+        self,
+        *args: Any,
+        lazy_subcommands: dict[str, str] | None = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__(*args, **kwargs)
+        self._lazy_subcommands: dict[str, str] = lazy_subcommands or {}
+
+    def list_commands(self, ctx: click.Context) -> list[str]:
+        base = super().list_commands(ctx)
+        lazy = sorted(self._lazy_subcommands.keys())
+        return base + lazy
+
+    def get_command(
+        self,
+        ctx: click.Context,
+        cmd_name: str,
+    ) -> click.BaseCommand | None:
+        if cmd_name in self._lazy_subcommands:
+            return self._load_lazy(cmd_name)
+        return super().get_command(ctx, cmd_name)
+
+    def _load_lazy(self, cmd_name: str) -> click.BaseCommand:
+        import_path = self._lazy_subcommands[cmd_name]
+        module_path, attr_name = import_path.rsplit(".", 1)
+        module = importlib.import_module(module_path)
+        return getattr(module, attr_name)  # type: ignore[no-any-return]
+
+
+@click.group(
+    cls=LazyGroup,
+    lazy_subcommands={
+        "hook": "dev10x.commands.hook.hook",
+        "init": "dev10x.commands.init.init",
+        "permission": "dev10x.commands.permission.permission",
+        "platform": "dev10x.commands.platform.platform",
+        "validate": "dev10x.commands.validate.validate",
+        "skill": "dev10x.commands.skill.skill",
+    },
+)
+@click.version_option(package_name="Dev10x")
+def cli() -> None:
+    pass

dev10x/commands/hook.py

@@ -0,0 +1,276 @@
+from __future__ import annotations
+
+import json
+import os
+import sys
+import traceback
+from pathlib import Path
+
+import click
+
+_DEBUG = os.environ.get("HOOK_DEBUG", "") != ""
+
+
+@click.group()
+def hook() -> None:
+    """Hook entry points (validate-bash, validate-edit, plan-sync, session)."""
+
+
+@hook.command(name="validate-bash")
+def validate_bash() -> None:
+    """Validate Bash commands via the unified validator registry.
+
+    Reads JSON from stdin, dispatches to registered validators.
+    Exit codes: 0=allow, 2=block.
+    """
+    from dev10x.domain import HookInput
+    from dev10x.validators import get_validators
+
+    inp = HookInput.from_stdin()
+    if inp.tool_name != "Bash":
+        sys.exit(0)
+    if not inp.command:
+        sys.exit(0)
+
+    for validator in get_validators():
+        try:
+            if validator.should_run(inp=inp):
+                result = validator.validate(inp=inp)
+                if result is not None:
+                    result.emit()
+        except Exception:
+            if _DEBUG:
+                print(
+                    f"[HOOK_DEBUG] {validator.name} raised:",
+                    file=sys.stderr,
+                )
+                traceback.print_exc(file=sys.stderr)
+            continue
+
+    sys.exit(0)
+
+
+@hook.group(name="plan")
+def plan() -> None:
+    """Plan synchronization commands."""
+
+
+@plan.command(name="sync")
+def plan_sync() -> None:
+    """Sync task state from stdin (PostToolUse hook mode)."""
+    from dev10x.hooks.task_plan_sync import cmd_hook
+
+    cmd_hook()
+
+
+@plan.command(name="summary")
+def plan_summary() -> None:
+    """Read plan YAML, output JSON summary."""
+    from dev10x.hooks.task_plan_sync import cmd_json_summary
+
+    cmd_json_summary()
+
+
+@plan.command(name="set-context")
+@click.argument("pairs", nargs=-1, required=True)
+def plan_set_context(pairs: tuple[str, ...]) -> None:
+    """Store plan-level context metadata (K=V pairs, dot-paths supported)."""
+    from dev10x.hooks.task_plan_sync import cmd_set_context
+
+    cmd_set_context(args=list(pairs))
+
+
+@plan.command(name="archive")
+def plan_archive() -> None:
+    """Archive completed plan to .claude/session/archive/."""
+    from dev10x.hooks.task_plan_sync import cmd_archive
+
+    cmd_archive()
+
+
+@hook.command(name="permission-denied")
+def permission_denied() -> None:
+    """Handle PermissionDenied events via the validator registry.
+
+    Reads JSON from stdin, dispatches to validators that implement
+    correct(). Returns retry=true with corrective guidance when a
+    validator recognizes the denied command.
+
+    Also runs permission diagnostics to explain *why* a pre-approved
+    tool was prompted (settings override semantics, missing rules).
+    Exit codes: 0 always (retry decision is in JSON output).
+    """
+    from dev10x.domain import HookInput
+    from dev10x.validators import get_validators
+    from dev10x.validators.base import Corrector
+
+    inp = HookInput.from_stdin()
+
+    if inp.command:
+        for validator in get_validators():
+            try:
+                if not validator.should_run(inp=inp):
+                    continue
+                if not isinstance(validator, Corrector):
+                    continue
+                result = validator.correct(inp=inp)
+                if result is not None:
+                    result.emit()
+            except Exception:
+                if _DEBUG:
+                    print(
+                        f"[HOOK_DEBUG] {validator.name} correct() raised:",
+                        file=sys.stderr,
+                    )
+                    traceback.print_exc(file=sys.stderr)
+                continue
+
+    _run_permission_diagnostics(raw=inp.raw, cwd=inp.cwd)
+    sys.exit(0)
+
+
+def _run_permission_diagnostics(*, raw: dict, cwd: str) -> None:
+    try:
+        from dev10x.hooks.permission_diagnostics import diagnose, format_diagnostic
+
+        result = diagnose(raw=raw, cwd=cwd)
+        if result is None:
+            return
+        message = format_diagnostic(result=result)
+        if message:
+            print(
+                json.dumps({"systemMessage": message}),
+                file=sys.stderr,
+            )
+    except Exception:
+        if _DEBUG:
+            print("[HOOK_DEBUG] permission_diagnostics raised:", file=sys.stderr)
+            traceback.print_exc(file=sys.stderr)
+
+
+@hook.command(name="validate-edit")
+@click.option(
+    "--config",
+    "config_path",
+    type=click.Path(exists=True, path_type=Path),
+    default=None,
+)
+@click.option("--debug", is_flag=True)
+def validate_edit(config_path: Path | None, debug: bool) -> None:
+    """Validate Edit/Write tool calls against sensitive file rules.
+
+    Reads JSON from stdin, checks file paths against rules.
+    Exit codes: 0=allow, 2=block.
+    """
+    import json
+
+    from dev10x.hooks.edit_validator import validate_edit_write
+
+    try:
+        data = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        sys.exit(0)
+
+    validate_edit_write(
+        data=data,
+        yaml_path=config_path,
+        debug=debug,
+    )
+
+
+@hook.group(name="session")
+def session() -> None:
+    """Session lifecycle commands."""
+
+
+@session.command(name="reload")
+def session_reload_cmd() -> None:
+    """Reload prior session state (SessionStart hook)."""
+    from dev10x.hooks.session import session_reload
+
+    session_reload()
+
+
+@session.command(name="compact")
+def session_compact_cmd() -> None:
+    """Inject context summary before compaction (PreCompact hook)."""
+    from dev10x.hooks.session import context_compact
+
+    context_compact()
+
+
+@session.command(name="tmpdir")
+def session_tmpdir_cmd() -> None:
+    """Create session scratch directory and install mktmp.sh (SessionStart hook)."""
+    from dev10x.hooks.session import session_tmpdir
+
+    session_tmpdir()
+
+
+@session.command(name="guidance")
+def session_guidance_cmd() -> None:
+    """Output session-guidance.md as additionalContext (SessionStart hook)."""
+    from dev10x.hooks.session import session_guidance
+
+    session_guidance()
+
+
+@session.command(name="git-aliases")
+def session_git_aliases_cmd() -> None:
+    """Check git branch-comparison aliases and report status (SessionStart hook)."""
+    from dev10x.hooks.session import session_git_aliases
+
+    session_git_aliases()
+
+
+@session.command(name="migrate-permissions")
+def session_migrate_permissions_cmd() -> None:
+    """Migrate stale plugin permission rules to current version (SessionStart hook)."""
+    from dev10x.hooks.session import session_migrate_permissions
+
+    session_migrate_permissions()
+
+
+@session.command(name="persist")
+def session_persist_cmd() -> None:
+    """Persist session state to disk for next-session reload (SessionStop hook)."""
+    from dev10x.hooks.session import session_persist
+
+    session_persist()
+
+
+@session.command(name="goodbye")
+def session_goodbye_cmd() -> None:
+    """Output goodbye message with community link and resume hint (SessionStop hook)."""
+    from dev10x.hooks.session import session_goodbye
+
+    session_goodbye()
+
+
+@hook.group(name="skill")
+def skill() -> None:
+    """Skill lifecycle commands."""
+
+
+@skill.command(name="tmpdir")
+def skill_tmpdir_cmd() -> None:
+    """Create scratch directory for skill (PreToolUse hook)."""
+    from dev10x.hooks.skill import skill_tmpdir
+
+    skill_tmpdir()
+
+
+@skill.command(name="metrics")
+def skill_metrics_cmd() -> None:
+    """Append skill invocation metric to JSONL file (PostToolUse hook)."""
+    from dev10x.hooks.skill import skill_metrics
+
+    skill_metrics()
+
+
+@hook.command(name="ruff-format")
+def ruff_format_cmd() -> None:
+    """Auto-format Python files with ruff after Edit/Write (PostToolUse hook)."""
+    from dev10x.hooks.skill import ruff_format
+
+    ruff_format()

dev10x/commands/init.py

@@ -0,0 +1,187 @@
+"""`dev10x init` — guided onboarding for new users.
+
+Creates a starter `.claude/Dev10x/` config tree in the current project
+and prints a quick-start card covering the top 5 workflows.
+"""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+QUICK_START_WORKFLOWS = [
+    (
+        "git-commit",
+        "/Dev10x:git-commit",
+        "JTBD-style commit messages with gitmoji + ticket ID",
+    ),
+    (
+        "pr-create",
+        "/Dev10x:gh-pr-create",
+        "Draft PR with Job Story body and Fixes: link",
+    ),
+    (
+        "review",
+        "/Dev10x:review",
+        "Self-review your branch before requesting a human reviewer",
+    ),
+    (
+        "testing",
+        "/test",
+        "Run pytest with coverage enforcement",
+    ),
+    (
+        "architecture",
+        "/Dev10x:adr",
+        "Author Architecture Decision Records with diagrams",
+    ),
+]
+
+STARTER_WORK_ON_PLAYBOOK = """# Starter work-on playbook for this project.
+#
+# Customize with /Dev10x:playbook edit work-on <play>
+# See skills/playbook/references/playbook.yaml for the full schema.
+
+# active_modes controls per-step behavior adaptations. Uncomment any
+# that apply to this project:
+#
+# active_modes:
+#   - solo-maintainer   # skip reviewer assignment + Slack notifications
+#   - open-source       # prefer issue templates and public-safe language
+
+overrides: []
+"""
+
+STARTER_GITMOJI_YAML = """# Gitmoji strategy override for this project.
+#
+# Leave default-strategy empty to use plugin defaults.
+# See skills/git-commit/references/gitmoji-defaults.yaml for the base map.
+
+default-strategy: null
+projects: []
+"""
+
+
+def _session_yaml_template() -> str:
+    return (
+        "# Dev10x session config — consumed by work-on, verify-acc-dod, and\n"
+        "# the PreCompact recovery hook.\n"
+        "friction_level: guided  # strict | guided | adaptive\n"
+        "active_modes: []\n"
+    )
+
+
+def _write_if_missing(path: Path, content: str) -> bool:
+    if path.exists():
+        return False
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(content)
+    return True
+
+
+def _seed_project(project_root: Path) -> list[Path]:
+    """Create starter config files. Returns list of paths written."""
+    written: list[Path] = []
+
+    targets = [
+        (project_root / ".claude" / "Dev10x" / "session.yaml", _session_yaml_template()),
+        (
+            project_root / ".claude" / "Dev10x" / "playbooks" / "work-on.yaml",
+            STARTER_WORK_ON_PLAYBOOK,
+        ),
+    ]
+    for path, content in targets:
+        if _write_if_missing(path, content):
+            written.append(path)
+
+    return written
+
+
+def _print_card(*, project_root: Path) -> None:
+    click.echo("")
+    click.echo("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+    click.echo(" Dev10x — Next 5 commands")
+    click.echo("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+    for i, (workflow, command, description) in enumerate(QUICK_START_WORKFLOWS, start=1):
+        click.echo(f" {i}. {command:<28} {workflow}")
+        click.echo(f"    {description}")
+    click.echo("")
+    click.echo(f" Config: {project_root}/.claude/Dev10x/")
+    click.echo(" Customize: /Dev10x:playbook edit work-on <play>")
+    click.echo(" Discovery: /Dev10x:onboarding")
+    click.echo("━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━")
+    click.echo("")
+
+
+@click.command()
+@click.option(
+    "--setup",
+    is_flag=True,
+    help="Force interactive setup even when config already exists.",
+)
+@click.option(
+    "--non-interactive",
+    is_flag=True,
+    help="Skip interactive prompts; write starter config and print card only.",
+)
+@click.option(
+    "--path",
+    "project_path",
+    type=click.Path(file_okay=False, path_type=Path),
+    default=None,
+    help="Project root (defaults to current directory).",
+)
+def init(*, setup: bool, non_interactive: bool, project_path: Path | None) -> None:
+    """Create a starter .claude/Dev10x/ config and print the quick-start card."""
+    project_root = (project_path or Path.cwd()).resolve()
+
+    if not project_root.is_dir():
+        click.echo(f"Project path does not exist: {project_root}", err=True)
+        sys.exit(1)
+
+    existing = (project_root / ".claude" / "Dev10x" / "session.yaml").exists()
+    if existing and not setup:
+        click.echo(f"Dev10x config already present at {project_root}/.claude/Dev10x/")
+        _print_card(project_root=project_root)
+        return
+
+    if non_interactive:
+        written = _seed_project(project_root)
+        for path in written:
+            click.echo(f"  + {path.relative_to(project_root)}")
+        _print_card(project_root=project_root)
+        return
+
+    click.echo("")
+    click.echo(f"Setting up Dev10x in {project_root}")
+    click.echo("")
+
+    friction_level = click.prompt(
+        "Friction level",
+        type=click.Choice(["strict", "guided", "adaptive"], case_sensitive=False),
+        default="guided",
+    )
+    solo = click.confirm(
+        "Solo maintainer mode? (skips reviewer assignment and Slack notifications)",
+        default=False,
+    )
+
+    session_yaml_path = project_root / ".claude" / "Dev10x" / "session.yaml"
+    modes = ["solo-maintainer"] if solo else []
+    session_yaml_path.parent.mkdir(parents=True, exist_ok=True)
+    session_yaml_path.write_text(
+        "# Dev10x session config\n"
+        f"friction_level: {friction_level.lower()}\n"
+        f"active_modes: {modes!r}\n"
+    )
+    click.echo(f"  + {session_yaml_path.relative_to(project_root)}")
+
+    playbook_path = project_root / ".claude" / "Dev10x" / "playbooks" / "work-on.yaml"
+    if not playbook_path.exists():
+        playbook_path.parent.mkdir(parents=True, exist_ok=True)
+        playbook_path.write_text(STARTER_WORK_ON_PLAYBOOK)
+        click.echo(f"  + {playbook_path.relative_to(project_root)}")
+
+    _print_card(project_root=project_root)