dbtips-curate 0.2.0__py3-none-any.whl

dbtips_curate/cli/dev.py

@@ -0,0 +1,358 @@
+"""`dbtips-curate dev ...` group — install + maintenance commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import typer
+
+from dbtips_curate.cli._output import emit_error, emit_ok
+from dbtips_curate.core.config import write_default_config
+
+app = typer.Typer(help="Developer + setup commands.", no_args_is_help=True)
+
+
+# ---------------------------------------------------------------------------
+# Harness registry — where each supported agent CLI reads skills from.
+#
+# Both agentskills.io reference (agentskills.io) and each vendor's own
+# docs were checked; every entry here reads plain SKILL.md with YAML
+# frontmatter (the same file we ship). Zero conversion — just different
+# install paths.
+#
+# - Claude Code: docs.claude.com/en/docs/claude-code/skills
+# - OpenAI Codex: developers.openai.com/codex/skills
+# - Google Antigravity: antigravity.google/docs/skills
+#
+# Codex and Antigravity SHARE .agents/skills/ at workspace scope, so a
+# single project install serves both.
+# ---------------------------------------------------------------------------
+
+
+@dataclass(frozen=True)
+class Harness:
+    key: str            # short id for --targets
+    label: str          # human-readable label for prints / prompts
+    user_dir: Path      # global path — always installs into <user_dir>/<skill>/SKILL.md
+    project_subdir: str  # project-scope path relative to project_root
+
+
+HARNESSES: dict[str, Harness] = {
+    "claude": Harness(
+        key="claude",
+        label="Claude Code",
+        user_dir=Path.home() / ".claude" / "skills",
+        project_subdir=".claude/skills",
+    ),
+    "codex": Harness(
+        key="codex",
+        label="OpenAI Codex",
+        user_dir=Path.home() / ".agents" / "skills",
+        project_subdir=".agents/skills",
+    ),
+    "antigravity": Harness(
+        key="antigravity",
+        label="Google Antigravity",
+        user_dir=Path.home() / ".gemini" / "config" / "skills",
+        # antigravity + codex share .agents/skills/ at workspace scope
+        project_subdir=".agents/skills",
+    ),
+}
+
+# Preset bundles for the bootstrap menu.
+PRESETS: dict[str, list[str]] = {
+    "claude": ["claude"],
+    "codex": ["codex"],
+    "antigravity": ["antigravity"],
+    "claude+codex": ["claude", "codex"],
+    "all": ["claude", "codex", "antigravity"],
+}
+
+
+def _skill_root() -> Path:
+    """Absolute path to the packaged skill/ tree (shipped inside the wheel)."""
+    return Path(__file__).resolve().parent.parent / "skill"
+
+
+def _discover_skills(only: str | None = None) -> list[Path]:
+    root = _skill_root()
+    candidates = sorted(
+        p for p in root.iterdir()
+        if p.is_dir() and not p.name.startswith("_") and (p / "SKILL.md").exists()
+    )
+    if only:
+        candidates = [p for p in candidates if p.name == only]
+    return candidates
+
+
+def _copy_skills(skills: list[Path], dest_root: Path) -> list[dict]:
+    """Copy every SKILL.md into dest_root/<skill-name>/SKILL.md. Idempotent."""
+    dest_root.mkdir(parents=True, exist_ok=True)
+    written: list[dict] = []
+    for src_dir in skills:
+        src = src_dir / "SKILL.md"
+        dst_dir = dest_root / src_dir.name
+        dst_dir.mkdir(parents=True, exist_ok=True)
+        dst = dst_dir / "SKILL.md"
+        dst.write_text(src.read_text())
+        written.append({
+            "skill": src_dir.name,
+            "path": str(dst),
+            "bytes": dst.stat().st_size,
+        })
+    return written
+
+
+def _parse_targets(raw: str) -> list[str]:
+    """Turn a --targets value into a list of harness keys.
+
+    Accepts presets ('all', 'claude+codex'), commas ('claude,codex'),
+    and single keys. Errors on unknown keys.
+    """
+    raw = (raw or "").strip().lower()
+    if not raw:
+        return []
+    if raw in PRESETS:
+        return PRESETS[raw]
+    parts = [p.strip() for p in raw.split(",") if p.strip()]
+    unknown = [p for p in parts if p not in HARNESSES]
+    if unknown:
+        raise ValueError(
+            f"unknown target(s): {unknown}. "
+            f"Valid: {sorted(HARNESSES)} or presets: {sorted(PRESETS)}"
+        )
+    return parts
+
+
+def _interactive_pick_targets() -> list[str]:
+    """Show a numbered menu; return the chosen preset's harness list."""
+    from rich.console import Console
+    from rich.prompt import Prompt
+
+    console = Console()
+    console.print()
+    console.print("[bold]Choose which AI coding harnesses to install skills into[/bold]")
+    console.print()
+    console.print("  [cyan]1[/cyan]) claude only              — Claude Code")
+    console.print("  [cyan]2[/cyan]) claude + codex           — Anthropic + OpenAI")
+    console.print("  [cyan]3[/cyan]) all                      — Claude + Codex + Antigravity")
+    console.print("  [cyan]4[/cyan]) claude + antigravity     — Anthropic + Google")
+    console.print("  [cyan]5[/cyan]) codex only")
+    console.print("  [cyan]6[/cyan]) antigravity only")
+    console.print()
+    choice = Prompt.ask("Enter choice", choices=["1", "2", "3", "4", "5", "6"], default="1")
+    mapping = {
+        "1": ["claude"],
+        "2": ["claude", "codex"],
+        "3": ["claude", "codex", "antigravity"],
+        "4": ["claude", "antigravity"],
+        "5": ["codex"],
+        "6": ["antigravity"],
+    }
+    return mapping[choice]
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+
+@app.command("init")
+def init(
+    ctx: typer.Context,
+    path: Path = typer.Option(Path.cwd() / "curation", "--path",
+                              help="Where to create the curation/ folder"),
+) -> None:
+    """Initialize a curation/ folder with a default .dbtips-curate.toml.
+
+    \b
+    Examples:
+      dbtips-curate dev init
+      dbtips-curate dev init --path ./backend/.../scripts/curation
+    """
+    json_mode = ctx.obj.get("json", False)
+    cfg_path = write_default_config(path)
+    emit_ok({"created": str(cfg_path), "existed": cfg_path.read_text() != ""},
+            json_mode=json_mode,
+            human=f"✓ Wrote default config at {cfg_path}\n"
+                  f"  Edit it to register additional sections, then run 'dbtips-curate entity track <id>'")
+
+
+@app.command("install-skill")
+def install_skill(
+    ctx: typer.Context,
+    home: Path = typer.Option(
+        None, "--home",
+        help="Override the skills directory. Default: the selected target's global user path.",
+    ),
+    target: str = typer.Option(
+        "claude", "--target",
+        help=f"Which harness to install for. One of: {sorted(HARNESSES)}. Default: claude.",
+    ),
+    only: str = typer.Option(
+        None, "--only",
+        help="Install only this skill (e.g. 'dbtips-curate-antibodies').",
+    ),
+) -> None:
+    """Install every SKILL.md into one harness's skills directory.
+
+    This is the single-target primitive. For a multi-target install with a
+    menu, use `dbtips-curate dev bootstrap` instead.
+
+    \b
+    Examples:
+      dbtips-curate dev install-skill                              # claude, global
+      dbtips-curate dev install-skill --target codex               # codex, global
+      dbtips-curate dev install-skill --target antigravity         # antigravity, global
+      dbtips-curate dev install-skill --home ./.claude/skills      # override path
+      dbtips-curate dev install-skill --only dbtips-curate-antibodies
+    """
+    json_mode = ctx.obj.get("json", False)
+    if target not in HARNESSES:
+        emit_error(
+            "UNKNOWN_TARGET",
+            f"--target must be one of {sorted(HARNESSES)}, got {target!r}",
+            json_mode=json_mode,
+        )
+        raise typer.Exit(code=2)
+    harness = HARNESSES[target]
+    dest = home or harness.user_dir
+
+    skills = _discover_skills(only=only)
+    if only and not skills:
+        emit_ok(
+            {"installed": [], "skipped_reason": f"no skill named {only!r}"},
+            json_mode=json_mode,
+            human=f"✗ No skill matches --only {only!r}. "
+                  f"Available: {[p.name for p in _discover_skills()]}",
+        )
+        return
+
+    written = _copy_skills(skills, dest)
+
+    human = [f"✓ Installed {len(written)} skill(s) to {harness.label} at {dest}:"]
+    for entry in written:
+        human.append(f"  · {entry['skill']:38s}  {entry['bytes']:>6d} bytes")
+    human.append("")
+    human.append(f"  Open {harness.label} and say 'QC ACVR2A target for antibodies' to activate.")
+    emit_ok(
+        {"installed": written, "target": target, "home": str(dest)},
+        json_mode=json_mode,
+        human="\n".join(human),
+    )
+
+
+@app.command("bootstrap")
+def bootstrap(
+    ctx: typer.Context,
+    targets: str = typer.Option(
+        None, "--targets",
+        help=(
+            "Which harnesses to install for. Accepts presets ('all', 'claude+codex') "
+            "or a comma-separated list ('claude,codex,antigravity'). "
+            "Interactive menu if omitted."
+        ),
+    ),
+    project: Path = typer.Option(
+        None, "--project",
+        help=(
+            "Also install into <project>/<harness-project-subdir>/ (e.g. .claude/skills, "
+            ".agents/skills). Skipped if not given."
+        ),
+    ),
+    only: str = typer.Option(
+        None, "--only",
+        help="Install only this skill by name (e.g. 'dbtips-curate-antibodies').",
+    ),
+) -> None:
+    """One-shot install of all skills across selected AI coding harnesses.
+
+    Discovers every SKILL.md packaged with dbtips-curate and copies it into the
+    right skills directory for each chosen target. All targets read the same
+    agentskills.io SKILL.md format — no conversion.
+
+    Path matrix:
+
+    \b
+      claude       ~/.claude/skills/<name>/           and  <project>/.claude/skills/<name>/
+      codex        ~/.agents/skills/<name>/           and  <project>/.agents/skills/<name>/
+      antigravity  ~/.gemini/config/skills/<name>/    and  <project>/.agents/skills/<name>/
+                                                          (codex + antigravity share .agents/ at workspace scope)
+
+    \b
+    Examples:
+      dbtips-curate dev bootstrap                       # interactive menu
+      dbtips-curate dev bootstrap --targets all         # claude + codex + antigravity
+      dbtips-curate dev bootstrap --targets claude,codex --project .
+      uvx dbtips-curate dev bootstrap                   # one-shot, no persistent install
+    """
+    json_mode = ctx.obj.get("json", False)
+
+    # Resolve targets — non-interactive if --targets given, else prompt.
+    try:
+        target_list = _parse_targets(targets) if targets else _interactive_pick_targets()
+    except ValueError as e:
+        emit_error("BAD_TARGETS", str(e), json_mode=json_mode)
+        raise typer.Exit(code=2)
+    if not target_list:
+        emit_error(
+            "NO_TARGETS",
+            "no targets selected; pass --targets or use the interactive prompt",
+            json_mode=json_mode,
+        )
+        raise typer.Exit(code=2)
+
+    skills = _discover_skills(only=only)
+    if only and not skills:
+        emit_error(
+            "SKILL_NOT_FOUND",
+            f"no skill named {only!r} — available: {[p.name for p in _discover_skills()]}",
+            json_mode=json_mode,
+        )
+        raise typer.Exit(code=2)
+
+    results: list[dict] = []
+    for tkey in target_list:
+        harness = HARNESSES[tkey]
+        # Global scope — always writes.
+        user_written = _copy_skills(skills, harness.user_dir)
+        results.append({
+            "target": tkey,
+            "scope": "global",
+            "path": str(harness.user_dir),
+            "count": len(user_written),
+        })
+        # Project scope — only when --project given.
+        if project is not None:
+            proj_dest = project.resolve() / harness.project_subdir
+            proj_written = _copy_skills(skills, proj_dest)
+            results.append({
+                "target": tkey,
+                "scope": "project",
+                "path": str(proj_dest),
+                "count": len(proj_written),
+            })
+
+    # Human-readable summary.
+    human = [f"✓ Installed {len(skills)} skill(s) into {len(target_list)} target(s):"]
+    for r in results:
+        label = HARNESSES[r["target"]].label
+        scope = r["scope"]
+        human.append(f"  · {label:22s} ({scope:7s})  {r['path']}")
+    human.append("")
+    human.append(
+        "  Open your harness (Claude Code / Codex / Antigravity) and try:"
+    )
+    human.append('     "QC ACVR2A target for antibodies"')
+    if project is None:
+        human.append("")
+        human.append(
+            "  Tip: pass --project . to also install into the current repo's "
+            "workspace-scope skills folder."
+        )
+    emit_ok(
+        {"targets": target_list, "results": results, "skill_count": len(skills)},
+        json_mode=json_mode,
+        human="\n".join(human),
+    )