Harness Engineering Playbook

interface:
  display_name: "Harness Engineering Playbook"
  short_description: "OpenAI harness patterns for agent workflows"
  default_prompt: "Analyze this repository and set up harness engineering workflows, docs, and automation following OpenAI Harness Engineering principles."

name: Harness CI

on:
  push:
    branches: [main]
  pull_request:

jobs:
  harness:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      # Add language/runtime setup steps as needed for this repository.
      # Examples:
      # - actions/setup-node@v4
      # - actions/setup-python@v5
      # - dtolnay/rust-toolchain@stable

      - name: Run harness pipeline
        run: make ci

name: Nightly Harness Audit

on:
  schedule:
    - cron: "0 4 * * *"
  workflow_dispatch:

jobs:
  audit:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      # Add runtime setup steps required for this repository.

      - name: Baseline harness audit
        run: scripts/audit_harness.sh .

      - name: Entropy check
        run: scripts/harness/entropy_check.sh

version: 1
setpoints:
  pr_pass_at_1:
    target: 0.70
    alert_below: 0.55
  merge_cycle_time_hours:
    target: 24
    alert_above: 48
  revert_rate:
    target: 0.03
    alert_above: 0.08
  human_intervention_rate:
    target: 0.20
    alert_above: 0.40
  time_to_actionable_failure_minutes:
    target: 10
    alert_above: 30

measurements:
  - name: pr_pass_at_1
    source: ci
  - name: merge_cycle_time_hours
    source: scm
  - name: revert_rate
    source: scm
  - name: human_intervention_rate
    source: review
  - name: time_to_actionable_failure_minutes
    source: ci

.PHONY: smoke test lint typecheck check ci

smoke:
	@./scripts/harness/smoke.sh

test:
	@./scripts/harness/test.sh

lint:
	@./scripts/harness/lint.sh

typecheck:
	@./scripts/harness/typecheck.sh

check: lint typecheck

ci: smoke check test

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'EOF'
Usage: scripts/audit_harness.sh [repo_path]

Audit a repository for baseline harness engineering artifacts.
EOF
}

target_path="${1:-.}"
if [ "$target_path" = "-h" ] || [ "$target_path" = "--help" ]; then
  usage
  exit 0
fi

if [ ! -d "$target_path" ]; then
  echo "error: target path does not exist: $target_path" >&2
  exit 1
fi

target_path=$(cd "$target_path" && pwd)
failures=0

ok() {
  echo "[ok]      $1"
}

fail() {
  echo "[missing] $1"
  failures=$((failures + 1))
}

check_file() {
  local relative="$1"
  if [ -f "$target_path/$relative" ]; then
    ok "$relative"
  else
    fail "$relative"
  fi
}

check_contains() {
  local relative="$1"
  local pattern="$2"
  local label="$3"
  local full="$target_path/$relative"

  if [ ! -f "$full" ]; then
    fail "$label (file missing: $relative)"
    return
  fi

  if grep -Eq "$pattern" "$full"; then
    ok "$label"
  else
    fail "$label"
  fi
}

echo "Auditing harness artifacts in: $target_path"
echo

check_file "AGENTS.md"
check_file "PLANS.md"
check_file "docs/ARCHITECTURE.md"
check_file "docs/OBSERVABILITY.md"
check_file "Makefile.harness"
check_file "scripts/audit_harness.sh"
check_file "scripts/harness/smoke.sh"
check_file "scripts/harness/test.sh"
check_file "scripts/harness/lint.sh"
check_file "scripts/harness/typecheck.sh"
check_file ".github/workflows/harness.yml"

echo
check_contains "AGENTS.md" "Harness Commands" "AGENTS.md: Harness Commands section"
check_contains "AGENTS.md" "Execution Plans" "AGENTS.md: Execution Plans section"
check_contains "docs/ARCHITECTURE.md" "Boundaries" "ARCHITECTURE.md: boundary guidance"
check_contains "docs/OBSERVABILITY.md" "Required Event Fields" "OBSERVABILITY.md: required fields"
check_contains "Makefile.harness" "^smoke:" "Makefile.harness: smoke target"
check_contains "Makefile.harness" "^test:" "Makefile.harness: test target"
check_contains "Makefile.harness" "^lint:" "Makefile.harness: lint target"
check_contains "Makefile.harness" "^typecheck:" "Makefile.harness: typecheck target"
check_contains "Makefile.harness" "^ci:" "Makefile.harness: ci target"
check_contains ".github/workflows/harness.yml" "make ci" "CI workflow executes make ci"

echo
if [ "$failures" -gt 0 ]; then
  echo "Harness audit failed: $failures issue(s) detected."
  exit 1
fi

echo "Harness audit passed."

#!/usr/bin/env bash
set -euo pipefail

root_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)
cd "$root_dir"

failures=0

check_exists() {
  local rel="$1"
  if [ -e "$rel" ]; then
    echo "[ok]      $rel"
  else
    echo "[missing] $rel"
    failures=$((failures + 1))
  fi
}

check_not_contains() {
  local rel="$1"
  local pattern="$2"
  local label="$3"
  if [ ! -f "$rel" ]; then
    echo "[missing] $label (file missing: $rel)"
    failures=$((failures + 1))
    return
  fi
  if grep -En "$pattern" "$rel" >/dev/null 2>&1; then
    echo "[drift]   $label"
    failures=$((failures + 1))
  else
    echo "[ok]      $label"
  fi
}

echo "Entropy check: $root_dir"
echo

check_exists "AGENTS.md"
check_exists "PLANS.md"
check_exists "docs/ARCHITECTURE.md"
check_exists "docs/OBSERVABILITY.md"
check_exists "Makefile.harness"

check_not_contains "AGENTS.md" "<project-name>|<runtime>|<entrypoints>" "AGENTS.md placeholders removed"
check_not_contains "docs/ARCHITECTURE.md" "^# Architecture$" "ARCHITECTURE customized"
check_not_contains "docs/OBSERVABILITY.md" "^# Observability$" "OBSERVABILITY customized"

echo
if [ "$failures" -gt 0 ]; then
  echo "Entropy check failed: $failures issue(s)."
  exit 1
fi
echo "Entropy check passed."

#!/usr/bin/env bash
set -euo pipefail

root_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)

if [ -n "${HARNESS_LINT_CMD:-}" ]; then
  cd "$root_dir"
  eval "$HARNESS_LINT_CMD"
  exit 0
fi

if [ -f "$root_dir/Cargo.toml" ] && command -v cargo >/dev/null 2>&1; then
  cd "$root_dir"
  cargo clippy --all-targets --all-features -- -D warnings
  exit 0
fi

if [ -f "$root_dir/package.json" ] && command -v node >/dev/null 2>&1 && command -v npm >/dev/null 2>&1; then
  cd "$root_dir"
  if node -e 'const p=require("./package.json"); process.exit(p.scripts&&p.scripts.lint?0:1)' >/dev/null 2>&1; then
    npm run -s lint
    exit 0
  fi
fi

if [ -f "$root_dir/pyproject.toml" ]; then
  cd "$root_dir"
  if command -v ruff >/dev/null 2>&1; then
    ruff check .
    exit 0
  fi
  if command -v flake8 >/dev/null 2>&1; then
    flake8 .
    exit 0
  fi
fi

echo "No default lint command detected."
echo "Set HARNESS_LINT_CMD or customize scripts/harness/lint.sh."
exit 1

#!/usr/bin/env bash
set -euo pipefail

root_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)

if [ -n "${HARNESS_SMOKE_CMD:-}" ]; then
  cd "$root_dir"
  eval "$HARNESS_SMOKE_CMD"
  exit 0
fi

if [ -f "$root_dir/Cargo.toml" ] && command -v cargo >/dev/null 2>&1; then
  cd "$root_dir"
  cargo check --quiet
  exit 0
fi

if [ -f "$root_dir/package.json" ] && command -v node >/dev/null 2>&1 && command -v npm >/dev/null 2>&1; then
  cd "$root_dir"
  if node -e 'const p=require("./package.json"); process.exit(p.scripts&&p.scripts.smoke?0:1)' >/dev/null 2>&1; then
    npm run -s smoke
    exit 0
  fi
  if node -e 'const p=require("./package.json"); process.exit(p.scripts&&p.scripts.build?0:1)' >/dev/null 2>&1; then
    npm run -s build
    exit 0
  fi
fi

if [ -f "$root_dir/pyproject.toml" ] && command -v pytest >/dev/null 2>&1; then
  cd "$root_dir"
  pytest -q -k smoke || pytest -q -k "not integration and not e2e"
  exit 0
fi

echo "No default smoke command detected."
echo "Set HARNESS_SMOKE_CMD or customize scripts/harness/smoke.sh."
exit 1

#!/usr/bin/env bash
set -euo pipefail

root_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)

if [ -n "${HARNESS_TEST_CMD:-}" ]; then
  cd "$root_dir"
  eval "$HARNESS_TEST_CMD"
  exit 0
fi

if [ -f "$root_dir/Cargo.toml" ] && command -v cargo >/dev/null 2>&1; then
  cd "$root_dir"
  cargo test --quiet
  exit 0
fi

if [ -f "$root_dir/package.json" ] && command -v node >/dev/null 2>&1 && command -v npm >/dev/null 2>&1; then
  cd "$root_dir"
  if node -e 'const p=require("./package.json"); process.exit(p.scripts&&p.scripts.test?0:1)' >/dev/null 2>&1; then
    npm run -s test
    exit 0
  fi
fi

if [ -f "$root_dir/pyproject.toml" ] && command -v pytest >/dev/null 2>&1; then
  cd "$root_dir"
  pytest -q
  exit 0
fi

echo "No default test command detected."
echo "Set HARNESS_TEST_CMD or customize scripts/harness/test.sh."
exit 1

#!/usr/bin/env bash
set -euo pipefail

root_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)

if [ -n "${HARNESS_TYPECHECK_CMD:-}" ]; then
  cd "$root_dir"
  eval "$HARNESS_TYPECHECK_CMD"
  exit 0
fi

if [ -f "$root_dir/Cargo.toml" ] && command -v cargo >/dev/null 2>&1; then
  cd "$root_dir"
  cargo check --quiet
  exit 0
fi

if [ -f "$root_dir/package.json" ] && command -v node >/dev/null 2>&1 && command -v npm >/dev/null 2>&1; then
  cd "$root_dir"
  if node -e 'const p=require("./package.json"); process.exit(p.scripts&&p.scripts.typecheck?0:1)' >/dev/null 2>&1; then
    npm run -s typecheck
    exit 0
  fi
  if node -e 'const p=require("./package.json"); process.exit(p.scripts&&p.scripts.tsc?0:1)' >/dev/null 2>&1; then
    npm run -s tsc
    exit 0
  fi
fi

if [ -f "$root_dir/pyproject.toml" ]; then
  cd "$root_dir"
  if command -v pyright >/dev/null 2>&1; then
    pyright
    exit 0
  fi
  if command -v mypy >/dev/null 2>&1; then
    mypy .
    exit 0
  fi
fi

echo "No default typecheck command detected."
echo "Set HARNESS_TYPECHECK_CMD or customize scripts/harness/typecheck.sh."
exit 1

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'EOF'
Usage: audit_harness.sh [repo_path]

Audit a repository for baseline harness engineering artifacts.
EOF
}

target_path="${1:-.}"
if [ "$target_path" = "-h" ] || [ "$target_path" = "--help" ]; then
  usage
  exit 0
fi

if [ ! -d "$target_path" ]; then
  echo "error: target path does not exist: $target_path" >&2
  exit 1
fi

target_path=$(cd "$target_path" && pwd)
failures=0

ok() {
  echo "[ok]      $1"
}

fail() {
  echo "[missing] $1"
  failures=$((failures + 1))
}

check_file() {
  local relative="$1"
  if [ -f "$target_path/$relative" ]; then
    ok "$relative"
  else
    fail "$relative"
  fi
}

check_contains() {
  local relative="$1"
  local pattern="$2"
  local label="$3"
  local full="$target_path/$relative"

  if [ ! -f "$full" ]; then
    fail "$label (file missing: $relative)"
    return
  fi

  if grep -Eq "$pattern" "$full"; then
    ok "$label"
  else
    fail "$label"
  fi
}

echo "Auditing harness artifacts in: $target_path"
echo

check_file "AGENTS.md"
check_file "PLANS.md"
check_file "docs/ARCHITECTURE.md"
check_file "docs/OBSERVABILITY.md"
check_file "Makefile.harness"
check_file "scripts/audit_harness.sh"
check_file "scripts/harness/smoke.sh"
check_file "scripts/harness/test.sh"
check_file "scripts/harness/lint.sh"
check_file "scripts/harness/typecheck.sh"
check_file ".github/workflows/harness.yml"

echo
check_contains "AGENTS.md" "Harness Commands" "AGENTS.md: Harness Commands section"
check_contains "AGENTS.md" "Execution Plans" "AGENTS.md: Execution Plans section"
check_contains "docs/ARCHITECTURE.md" "Boundaries" "ARCHITECTURE.md: boundary guidance"
check_contains "docs/OBSERVABILITY.md" "Required Event Fields" "OBSERVABILITY.md: required fields"
check_contains "Makefile.harness" "^smoke:" "Makefile.harness: smoke target"
check_contains "Makefile.harness" "^test:" "Makefile.harness: test target"
check_contains "Makefile.harness" "^lint:" "Makefile.harness: lint target"
check_contains "Makefile.harness" "^typecheck:" "Makefile.harness: typecheck target"
check_contains "Makefile.harness" "^ci:" "Makefile.harness: ci target"
check_contains ".github/workflows/harness.yml" "make ci" "CI workflow executes make ci"

echo
if [ "$failures" -gt 0 ]; then
  echo "Harness audit failed: $failures issue(s) detected."
  exit 1
fi

echo "Harness audit passed."

#!/usr/bin/env bash
set -euo pipefail

usage() {
  cat <<'EOF'
Usage: bootstrap_harness.sh [repo_path] [--force]

Install harness templates into a target repository.

Arguments:
  repo_path   Target repository path (default: current directory)
  --force     Overwrite existing template-managed files
EOF
}

target_path="."
force=0

while [ $# -gt 0 ]; do
  case "$1" in
    --force)
      force=1
      ;;
    -h|--help)
      usage
      exit 0
      ;;
    *)
      if [ "$target_path" != "." ]; then
        echo "error: multiple repo paths provided" >&2
        usage
        exit 1
      fi
      target_path="$1"
      ;;
  esac
  shift
done

if [ ! -d "$target_path" ]; then
  echo "error: target path does not exist: $target_path" >&2
  exit 1
fi

target_path=$(cd "$target_path" && pwd)
script_dir=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
skill_dir=$(cd "$script_dir/.." && pwd)
template_dir="$skill_dir/assets/templates"

if [ ! -d "$template_dir" ]; then
  echo "error: template directory missing: $template_dir" >&2
  exit 1
fi

copy_template() {
  local relative="$1"
  local source="$template_dir/$relative"
  local destination="$target_path/$relative"

  if [ ! -f "$source" ]; then
    echo "[error] missing template: $relative" >&2
    exit 1
  fi

  mkdir -p "$(dirname "$destination")"

  if [ -f "$destination" ] && [ "$force" -ne 1 ]; then
    echo "[skip]  $relative (exists)"
    return 0
  fi

  cp "$source" "$destination"
  echo "[write] $relative"
}

templates=(
  "AGENTS.md"
  "PLANS.md"
  "docs/ARCHITECTURE.md"
  "docs/OBSERVABILITY.md"
  "Makefile.harness"
  "scripts/audit_harness.sh"
  "scripts/harness/smoke.sh"
  "scripts/harness/test.sh"
  "scripts/harness/lint.sh"
  "scripts/harness/typecheck.sh"
  ".github/workflows/harness.yml"
)

for relative in "${templates[@]}"; do
  copy_template "$relative"
done

makefile="$target_path/Makefile"
if [ ! -f "$makefile" ]; then
  cat > "$makefile" <<'EOF'
-include Makefile.harness
EOF
  echo "[write] Makefile"
elif ! grep -Eq '(^|[[:space:]])-?include[[:space:]]+Makefile\.harness([[:space:]]|$)' "$makefile"; then
  cat >> "$makefile" <<'EOF'

# Harness engineering targets
-include Makefile.harness
EOF
  echo "[update] Makefile (+ include Makefile.harness)"
else
  echo "[skip]  Makefile already includes Makefile.harness"
fi

chmod +x \
  "$target_path/scripts/audit_harness.sh" \
  "$target_path/scripts/harness/smoke.sh" \
  "$target_path/scripts/harness/test.sh" \
  "$target_path/scripts/harness/lint.sh" \
  "$target_path/scripts/harness/typecheck.sh"

echo
echo "Bootstrap complete."
echo "Next:"
echo "  1) Customize commands in scripts/harness/*.sh"
echo "  2) Update AGENTS.md and docs/* placeholders"
echo "  3) cd \"$target_path\" && scripts/audit_harness.sh ."

#!/usr/bin/env python3
"""Harness Engineering wizard CLI.

This command-line tool bootstraps and upgrades repositories so they are
harness/control-system ready for autonomous agent workflows.
"""

from __future__ import annotations

import subprocess
from enum import Enum
from pathlib import Path
from typing import Dict, Iterable, List, Tuple

import typer

app = typer.Typer(help="Harness engineering wizard for repository setup and control primitives.")
primitive_app = typer.Typer(help="Add or inspect control-system primitives.")
app.add_typer(primitive_app, name="primitive")


SCRIPT_DIR = Path(__file__).resolve().parent
SKILL_DIR = SCRIPT_DIR.parent
TEMPLATE_DIR = SKILL_DIR / "assets" / "templates"
BOOTSTRAP_SCRIPT = SCRIPT_DIR / "bootstrap_harness.sh"
AUDIT_SCRIPT = SCRIPT_DIR / "audit_harness.sh"

BASELINE_FILES: Tuple[str, ...] = (
    "AGENTS.md",
    "PLANS.md",
    "docs/ARCHITECTURE.md",
    "docs/OBSERVABILITY.md",
    "Makefile.harness",
    "scripts/audit_harness.sh",
    "scripts/harness/smoke.sh",
    "scripts/harness/test.sh",
    "scripts/harness/lint.sh",
    "scripts/harness/typecheck.sh",
    ".github/workflows/harness.yml",
)


class Primitive(str, Enum):
    loop = "loop"
    setpoint = "setpoint"
    sensors = "sensors"
    controller = "controller"
    actuators = "actuators"
    feedback = "feedback"
    stability = "stability"
    entropy = "entropy"


class Profile(str, Enum):
    baseline = "baseline"
    control = "control"
    full = "full"


PRIMITIVE_FILES: Dict[Primitive, Tuple[str, ...]] = {
    Primitive.loop: ("docs/control/CONTROL_SYSTEM.md",),
    Primitive.setpoint: (
        "docs/control/SETPOINTS.md",
        "evals/control-loop-metrics.yaml",
    ),
    Primitive.sensors: ("docs/control/SENSORS.md",),
    Primitive.controller: ("docs/control/CONTROLLER.md",),
    Primitive.actuators: ("docs/control/ACTUATORS.md",),
    Primitive.feedback: ("docs/control/FEEDBACK_LOOP.md",),
    Primitive.stability: ("docs/control/STABILITY.md",),
    Primitive.entropy: (
        "docs/control/ENTROPY.md",
        "scripts/harness/entropy_check.sh",
        ".github/workflows/nightly-harness-audit.yml",
    ),
}

CONTROL_PROFILE: Tuple[Primitive, ...] = (
    Primitive.loop,
    Primitive.setpoint,
    Primitive.sensors,
    Primitive.controller,
    Primitive.actuators,
    Primitive.feedback,
    Primitive.stability,
)

FULL_PROFILE: Tuple[Primitive, ...] = CONTROL_PROFILE + (Primitive.entropy,)


def _resolve_repo(repo_path: Path) -> Path:
    repo = repo_path.expanduser().resolve()
    if not repo.exists() or not repo.is_dir():
        typer.secho(f"error: repo path does not exist: {repo}", fg=typer.colors.RED, err=True)
        raise typer.Exit(code=2)
    return repo


def _run(script: Path, args: List[str]) -> None:
    if not script.exists():
        typer.secho(f"error: script not found: {script}", fg=typer.colors.RED, err=True)
        raise typer.Exit(code=2)
    command = [str(script), *args]
    result = subprocess.run(command, check=False)
    if result.returncode != 0:
        raise typer.Exit(code=result.returncode)


def _copy_template(relative_path: str, repo: Path, force: bool) -> str:
    source = TEMPLATE_DIR / relative_path
    target = repo / relative_path
    if not source.exists():
        typer.secho(f"error: missing template file: {source}", fg=typer.colors.RED, err=True)
        raise typer.Exit(code=2)

    target.parent.mkdir(parents=True, exist_ok=True)
    if target.exists() and not force:
        return "skip"

    target.write_bytes(source.read_bytes())
    if target.suffix == ".sh":
        target.chmod(0o755)
    return "write"


def _add_primitives(repo: Path, primitives: Iterable[Primitive], force: bool) -> None:
    for primitive in primitives:
        typer.secho(f"\n[{primitive.value}]")
        for relative_path in PRIMITIVE_FILES[primitive]:
            state = _copy_template(relative_path, repo, force)
            verb = "write" if state == "write" else "skip "
            typer.echo(f"  [{verb}] {relative_path}")


def _check_exists(repo: Path, relative_path: str) -> bool:
    return (repo / relative_path).exists()


def _primitive_status(repo: Path, primitive: Primitive) -> Tuple[int, int]:
    files = PRIMITIVE_FILES[primitive]
    present = sum(1 for rel in files if _check_exists(repo, rel))
    return present, len(files)


@app.command()
def init(
    repo_path: Path = typer.Argument(Path("."), help="Target repository path."),
    profile: Profile = typer.Option(
        Profile.control,
        "--profile",
        "-p",
        help="Setup profile: baseline, control, or full.",
    ),
    force: bool = typer.Option(False, "--force", help="Overwrite existing files."),
) -> None:
    """Initialize harness artifacts and optionally apply control primitives."""
    repo = _resolve_repo(repo_path)
    typer.secho(f"Initializing harness in {repo}", fg=typer.colors.CYAN)

    args = [str(repo)]
    if force:
        args.append("--force")
    _run(BOOTSTRAP_SCRIPT, args)

    if profile == Profile.baseline:
        return

    primitives = CONTROL_PROFILE if profile == Profile.control else FULL_PROFILE
    _add_primitives(repo, primitives, force=force)
    typer.secho("\nInitialization complete.", fg=typer.colors.GREEN)


@app.command()
def audit(
    repo_path: Path = typer.Argument(Path("."), help="Target repository path."),
) -> None:
    """Run baseline harness audit."""
    repo = _resolve_repo(repo_path)
    _run(AUDIT_SCRIPT, [str(repo)])


@app.command()
def status(
    repo_path: Path = typer.Argument(Path("."), help="Target repository path."),
) -> None:
    """Show harness and primitive coverage status."""
    repo = _resolve_repo(repo_path)
    typer.secho(f"Harness status for {repo}", fg=typer.colors.CYAN)
    typer.echo()

    baseline_present = sum(1 for rel in BASELINE_FILES if _check_exists(repo, rel))
    baseline_total = len(BASELINE_FILES)
    typer.echo(f"baseline: {baseline_present}/{baseline_total}")
    for rel in BASELINE_FILES:
        mark = "OK " if _check_exists(repo, rel) else "MISS"
        typer.echo(f"  [{mark}] {rel}")

    typer.echo()
    typer.echo("control primitives:")
    for primitive in Primitive:
        present, total = _primitive_status(repo, primitive)
        mark = "OK " if present == total else "PARTIAL" if present > 0 else "MISS"
        typer.echo(f"  [{mark}] {primitive.value}: {present}/{total}")


@primitive_app.command("list")
def primitive_list() -> None:
    """List available control primitives and their files."""
    for primitive in Primitive:
        typer.echo(f"{primitive.value}")
        for rel in PRIMITIVE_FILES[primitive]:
            typer.echo(f"  - {rel}")


@primitive_app.command("add")
def primitive_add(
    primitives: List[Primitive] = typer.Argument(..., help="Primitive names to add."),
    repo_path: Path = typer.Option(Path("."), "--repo", "-r", help="Target repository path."),
    force: bool = typer.Option(False, "--force", help="Overwrite existing primitive files."),
) -> None:
    """Add specific control primitives to a repository."""
    repo = _resolve_repo(repo_path)
    _add_primitives(repo, primitives, force=force)
    typer.secho("\nPrimitive update complete.", fg=typer.colors.GREEN)


if __name__ == "__main__":
    app()

MIT License

Copyright (c) 2026 Carlos Escobar (BroomVA)

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.