cubething-occonf 0.1.0__tar.gz

cubething_occonf-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+node_modules
+package.json
+bun.lock
+*.bak
+sandbox/
+out/
+__pycache__
+.ruff_cache
+build.json

cubething_occonf-0.1.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: cubething-occonf
+Version: 0.1.0
+Summary: Standalone installer for ada-x64/opencode-config
+Author: ada-x64
+License: MIT
+Requires-Python: >=3.12

cubething_occonf-0.1.0/build.py

@@ -0,0 +1,409 @@
+#!/usr/bin/env python3
+"""
+build.py — build stamped config from src/ templates into out/.
+
+Copies src/ → out/ (excluding profiles/), then applies all stamps:
+  - model field in opencode.json
+  - model + external_directory in agent frontmatter
+  - {{CONFIG_DIR}} placeholder resolution in agent files
+
+Source files in src/ are NEVER modified.
+
+On first run (build.json absent), prompts for model config interactively
+and writes build.json to the repo root (gitignored — not checked in).
+
+Usage:
+  python3 scripts/build.py                # build using existing build.json
+  python3 scripts/build.py --reconfigure  # re-prompt for model config
+"""
+
+import argparse
+import json
+import re
+import shutil
+import sys
+from pathlib import Path
+from typing import IO, Any
+
+SCRIPT_DIR = Path(__file__).resolve().parent
+REPO_ROOT = SCRIPT_DIR.parent
+SRC_DIR = REPO_ROOT / "src"
+OUT_DIR = REPO_ROOT / "out"
+CONFIG_PATH = REPO_ROOT / "build.json"
+
+# Default config written on first run
+DEFAULT_CONFIG: dict[str, Any] = {
+    "global": {
+        "model": "github-copilot/claude-opus-4.6",
+        "external_directory": [
+            "{env:AGENT_REPOS}/**",
+            "{env:AGENT_VAULT}/**",
+            "{env:OPENCODE_CONFIG_SRC}/**",
+            "/tmp/**",
+        ],
+    },
+    "tiers": {
+        "design": {"model": None},
+        "execute": {"model": "github-copilot/claude-sonnet-4.6"},
+    },
+}
+
+
+# ---------------------------------------------------------------------------
+# TTY prompt helpers
+# ---------------------------------------------------------------------------
+
+
+def open_tty() -> IO[str] | None:
+    """Return a file object for /dev/tty, or None if unavailable."""
+    try:
+        return open("/dev/tty")
+    except OSError:
+        return None
+
+
+def tty_prompt(tty: IO[str], message: str) -> str:
+    """Write prompt to stdout and read a line from tty."""
+    print(message, end="", flush=True)
+    return tty.readline().rstrip("\n")
+
+
+# ---------------------------------------------------------------------------
+# First-run / reconfigure: generate build.json interactively
+# ---------------------------------------------------------------------------
+
+
+def prompt_config(tty: IO[str]) -> dict[str, Any]:
+    """Prompt the user for model configuration and return a build config dict."""
+    config: dict[str, Any] = json.loads(json.dumps(DEFAULT_CONFIG))
+
+    default_global = str(DEFAULT_CONFIG["global"]["model"])
+    val = tty_prompt(tty, f"Global model [{default_global}]: ")
+    if val:
+        config["global"]["model"] = val
+
+    default_execute = str(DEFAULT_CONFIG["tiers"]["execute"]["model"])
+    val = tty_prompt(tty, f"Execute-tier model [{default_execute}]: ")
+    if val:
+        config["tiers"]["execute"]["model"] = val
+
+    print("Design tier inherits global model (no override). Edit build.json to change.")
+
+    return config
+
+
+def ensure_config(reconfigure: bool = False) -> dict[str, Any]:
+    """Load or create build.json. Prompts interactively on first run or --reconfigure."""
+    if CONFIG_PATH.is_file() and not reconfigure:
+        return dict(json.loads(CONFIG_PATH.read_text(encoding="utf-8")))
+
+    # Need interactive prompts
+    tty = open_tty()
+    if tty is None:
+        if CONFIG_PATH.is_file():
+            print("No TTY available, using existing build.json.", file=sys.stderr)
+            return dict(json.loads(CONFIG_PATH.read_text(encoding="utf-8")))
+        # No config and no TTY — write defaults
+        print("No TTY available, writing default build.json.", file=sys.stderr)
+        config = json.loads(json.dumps(DEFAULT_CONFIG))
+        _ = CONFIG_PATH.write_text(
+            json.dumps(config, indent=2) + "\n", encoding="utf-8"
+        )
+        return dict(config)
+
+    try:
+        if reconfigure:
+            print("Reconfiguring build.json...")
+        else:
+            print("No build.json found — running first-time setup.")
+        print()
+        config = prompt_config(tty)
+    finally:
+        tty.close()
+
+    _ = CONFIG_PATH.write_text(json.dumps(config, indent=2) + "\n", encoding="utf-8")
+    print(f"\nWrote {CONFIG_PATH}")
+    return config
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def read_model_from_jsonc(text: str) -> str:
+    """Extract the top-level "model" value from JSONC text."""
+    m = re.search(r'"model"\s*:\s*"([^"]*)"', text)
+    return m.group(1) if m else ""
+
+
+def write_model_to_jsonc(text: str, new_model: str) -> str:
+    """Replace the top-level "model" value in JSONC text, preserving everything else."""
+    return re.sub(
+        r'("model"\s*:\s*)"[^"]*"',
+        lambda _: f'"model": "{new_model}"',
+        text,
+        count=1,
+    )
+
+
+def extract_frontmatter(content: str) -> tuple[str, str] | None:
+    """
+    Extract raw frontmatter text and the rest of the markdown content.
+    Returns (fm_str, rest) or None if no frontmatter found.
+    """
+    m = re.match(r"^---\n(.*?)\n---", content, re.DOTALL)
+    if not m:
+        return None
+    return m.group(1), content[m.end() :]
+
+
+def fm_get(fm_str: str, key: str) -> str | None:
+    """Extract a simple key: value from frontmatter text. Returns None if absent."""
+    m = re.search(rf"^{re.escape(key)}:\s*(.+)$", fm_str, re.MULTILINE)
+    return m.group(1).strip() if m else None
+
+
+def rebuild_content(fm_lines: list[str], rest: str) -> str:
+    """Reconstruct markdown content from a list of frontmatter lines and the body."""
+    return "---\n" + "\n".join(fm_lines) + "\n---" + rest
+
+
+# ---------------------------------------------------------------------------
+# Build: copy src/ → out/ then stamp
+# ---------------------------------------------------------------------------
+
+
+def copy_src_to_out(src_dir: Path, out_dir: Path) -> None:
+    """Copy src/ tree to out/, excluding profiles/."""
+    if out_dir.exists():
+        shutil.rmtree(out_dir)
+    _ = shutil.copytree(
+        src_dir,
+        out_dir,
+        ignore=shutil.ignore_patterns("profiles"),
+    )
+    print(f"Copied {src_dir}/ → {out_dir}/ (excluding profiles/)")
+
+
+def stamp_opencode_json(out_dir: Path, global_model: str) -> None:
+    """Stamp the model field in out/opencode.json."""
+    oc_path = out_dir / "opencode.json"
+    oc_text = oc_path.read_text(encoding="utf-8")
+    current_model = read_model_from_jsonc(oc_text)
+
+    if current_model != global_model:
+        new_text = write_model_to_jsonc(oc_text, global_model)
+        _ = oc_path.write_text(new_text, encoding="utf-8")
+        print(f"opencode.json: model {current_model} → {global_model}")
+    else:
+        print(f"opencode.json: model already {global_model} (no change)")
+
+
+def stamp_agent_models(agents_dir: Path, config: dict[str, Any]) -> dict[Path, str]:
+    """Stamp model fields in agent frontmatter. Returns {path: updated content}."""
+    tiers_config = dict(config.get("tiers", {}))
+
+    for agent_file in sorted(agents_dir.glob("*.md")):
+        agent_name = agent_file.stem
+        content = agent_file.read_text(encoding="utf-8")
+
+        parsed = extract_frontmatter(content)
+        if parsed is None:
+            print(f"{agent_name}: no frontmatter, skipping model")
+            continue
+
+        fm_str, rest = parsed
+        fm_lines = fm_str.splitlines()
+        tier = fm_get(fm_str, "tier")
+
+        if not tier:
+            print(f"{agent_name}: no tier set, skipping model")
+            continue
+
+        tier_entry = tiers_config.get(tier)
+        tier_config = dict(tier_entry) if tier_entry else {}
+        tier_model: str | None = tier_config.get("model")
+        current_model = fm_get(fm_str, "model")
+
+        if tier_model is None:
+            # Tier inherits global — remove model line if present
+            if current_model is not None:
+                fm_lines = [line for line in fm_lines if not line.startswith("model:")]
+                _ = agent_file.write_text(
+                    rebuild_content(fm_lines, rest), encoding="utf-8"
+                )
+                print(
+                    f"{agent_name} (tier: {tier}): removed model override"
+                    + " (inherits global)"
+                )
+            else:
+                print(f"{agent_name} (tier: {tier}): no model override (no change)")
+        elif current_model != tier_model:
+            has_model = any(line.startswith("model:") for line in fm_lines)
+            if has_model:
+                fm_lines = [
+                    f"model: {tier_model}" if line.startswith("model:") else line
+                    for line in fm_lines
+                ]
+            else:
+                inserted: list[str] = []
+                for line in fm_lines:
+                    inserted.append(line)
+                    if line.startswith("tier:"):
+                        inserted.append(f"model: {tier_model}")
+                fm_lines = inserted
+            _ = agent_file.write_text(rebuild_content(fm_lines, rest), encoding="utf-8")
+            print(f"{agent_name} (tier: {tier}): model → {tier_model}")
+        else:
+            print(
+                f"{agent_name} (tier: {tier}): model already"
+                + f" {tier_model} (no change)"
+            )
+
+    return {}
+
+
+def stamp_external_dirs(agents_dir: Path, ext_dirs: list[str]) -> None:
+    """Stamp the external_directory block in all agent frontmatter."""
+    canonical: list[str] = ["  external_directory:"]
+    for d in ext_dirs:
+        canonical.append(f'    "{d}": allow')
+
+    for agent_file in sorted(agents_dir.glob("*.md")):
+        agent_name = agent_file.stem
+        content = agent_file.read_text(encoding="utf-8")
+
+        parsed = extract_frontmatter(content)
+        if parsed is None:
+            print(f"{agent_name}: external_directory no frontmatter")
+            continue
+
+        fm_str, rest = parsed
+        fm_lines = fm_str.splitlines()
+
+        new_lines: list[str] = []
+        skip = False
+        found = False
+
+        for line in fm_lines:
+            if re.match(r"^  external_directory:\s*$", line):
+                found = True
+                skip = True
+                new_lines.extend(canonical)
+                continue
+            if skip:
+                if re.match(r"^    ", line):
+                    continue
+                else:
+                    skip = False
+            new_lines.append(line)
+
+        if not found:
+            insert_idx = len(new_lines)
+            for i, line in enumerate(new_lines):
+                if re.match(r"^  task:", line):
+                    insert_idx = i
+                    break
+            new_lines = new_lines[:insert_idx] + canonical + new_lines[insert_idx:]
+
+        new_content = rebuild_content(new_lines, rest)
+
+        if new_content != content:
+            _ = agent_file.write_text(new_content, encoding="utf-8")
+            result = "updated"
+        else:
+            result = "no change"
+
+        print(f"{agent_name}: external_directory {result}")
+
+
+def resolve_config_dir(agents_dir: Path, config_dir_value: str) -> None:
+    """Resolve {{CONFIG_DIR}} placeholders in all agent files."""
+    count = 0
+    for f in sorted(agents_dir.glob("*.md")):
+        text = f.read_text(encoding="utf-8")
+        if "{{CONFIG_DIR}}" in text:
+            _ = f.write_text(
+                text.replace("{{CONFIG_DIR}}", config_dir_value), encoding="utf-8"
+            )
+            print(f"  resolved: {f.name}")
+            count += 1
+    print(f"  {count} agent file(s) updated.")
+
+
+def build(config: dict[str, Any], config_dir_value: str = "") -> Path:
+    """Full build: copy src/ → out/, apply all stamps. Returns out_dir path.
+
+    Args:
+        config: Loaded build.json dict.
+        config_dir_value: Value to substitute for {{CONFIG_DIR}} in agent files.
+                          If empty, uses OPENCODE_CONFIG_SRC env var, falling
+                          back to the default ~/.config/opencode.
+    """
+    if not config_dir_value:
+        import os
+
+        config_dir_value = os.environ.get(
+            "OPENCODE_CONFIG_SRC", str(Path.home() / ".config" / "opencode")
+        )
+
+    global_section = dict(config["global"])
+    global_model: str = str(global_section["model"])
+    ext_dirs: list[str] = list(global_section["external_directory"])
+
+    # Step 1: Copy
+    copy_src_to_out(SRC_DIR, OUT_DIR)
+
+    agents_dir = OUT_DIR / "agents"
+
+    # Step 2: Stamp opencode.json model
+    stamp_opencode_json(OUT_DIR, global_model)
+
+    # Step 3: Stamp agent models
+    _ = stamp_agent_models(agents_dir, config)
+
+    # Step 4: Stamp agent external_directory
+    stamp_external_dirs(agents_dir, ext_dirs)
+
+    # Step 5: Resolve {{CONFIG_DIR}} placeholders
+    print(f"Resolving {{{{CONFIG_DIR}}}} → {config_dir_value} in agent files...")
+    resolve_config_dir(agents_dir, config_dir_value)
+
+    print()
+    print(f"Done. Build output in {OUT_DIR}/")
+    return OUT_DIR
+
+
+# ---------------------------------------------------------------------------
+# CLI entry point
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Build stamped config from src/ templates into out/."
+    )
+    _ = parser.add_argument(
+        "--reconfigure",
+        action="store_true",
+        help="Re-prompt for model configuration even if build.json exists.",
+    )
+    _ = parser.add_argument(
+        "--config-dir",
+        default="",
+        metavar="<path>",
+        dest="config_dir_value",
+        help=(
+            "Value to substitute for {{CONFIG_DIR}} in agent files."
+            " Defaults to $OPENCODE_CONFIG_SRC or ~/.config/opencode."
+        ),
+    )
+    args = parser.parse_args()
+
+    config = ensure_config(reconfigure=bool(args.reconfigure))
+    _ = build(config, config_dir_value=str(args.config_dir_value))
+
+
+if __name__ == "__main__":
+    main()

cubething_occonf-0.1.0/install.py

@@ -0,0 +1,236 @@
+#!/usr/bin/env python3
+"""install.py — deploy built config from out/ to the target config directory
+
+Usage:
+  python3 scripts/install.py [--profile <name>] [--config-dir <path>] [--help]
+
+Options:
+  --profile <name>     Profile to use (default: host). Loads src/profiles/<name>.env.
+  --config-dir <path>  Override CONFIG_DIR from the profile.
+  --help               Show this help message and exit.
+
+Prerequisites:
+  Run build.py first to produce the out/ directory:
+    python3 scripts/build.py [--config-dir <path>]
+
+What it does:
+  1. Loads the selected profile to set CONFIG_DIR and OPENCODE_CONFIG_SRC.
+  2. Verifies out/ exists (must run build.py first).
+  3. Refuses to run if out/ == CONFIG_DIR (would be a no-op or destructive).
+  4. rsyncs out/ contents to CONFIG_DIR.
+  5. Deploys AoE config (resolving {{AGENT_VAULT}} and {{OPENCODE_CONFIG_SRC}})
+     from src/aoe-config.toml.
+  6. Prints a deployment summary.
+
+Separation of concerns:
+  - build.py:   src/ → out/ copy + all stamping (model, external_directory, {{CONFIG_DIR}})
+  - install.py: out/ → CONFIG_DIR rsync + AoE config deployment
+  - Source files in src/ are NEVER modified.
+"""
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# .env parser
+# ---------------------------------------------------------------------------
+
+
+def parse_env_file(env_path: Path) -> dict[str, str]:
+    """Parse a shell-style KEY=value env file into a dict.
+
+    Handles:
+    - Comment lines (starting with #) and blank lines — skipped.
+    - ``export KEY=value`` — ``export`` prefix is stripped.
+    - Single- and double-quoted values — outer quotes are removed.
+    - $VAR / ${VAR} references — expanded via os.path.expandvars().
+    - ~ prefix — expanded via os.path.expanduser().
+    """
+    result: dict[str, str] = {}
+
+    for raw_line in env_path.read_text().splitlines():
+        line = raw_line.strip()
+
+        if not line or line.startswith("#"):
+            continue
+
+        if line.startswith("export "):
+            line = line[len("export ") :]
+
+        if "=" not in line:
+            continue
+
+        key, _, raw_value = line.partition("=")
+        key = key.strip()
+
+        value = raw_value.strip()
+        if (value.startswith('"') and value.endswith('"')) or (
+            value.startswith("'") and value.endswith("'")
+        ):
+            value = value[1:-1]
+
+        value = os.path.expandvars(value)
+        value = os.path.expanduser(value)
+
+        result[key] = value
+
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Argument parsing
+# ---------------------------------------------------------------------------
+
+
+def build_arg_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="install.py",
+        description=__doc__,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=True,
+    )
+    _ = parser.add_argument(
+        "--profile",
+        default="host",
+        metavar="<name>",
+        help="Profile to use (default: host). Loads src/profiles/<name>.env.",
+    )
+    _ = parser.add_argument(
+        "--config-dir",
+        default="",
+        metavar="<path>",
+        dest="config_dir_override",
+        help="Override CONFIG_DIR from the profile.",
+    )
+    return parser
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    parser = build_arg_parser()
+    args = parser.parse_args()
+
+    script_dir = Path(__file__).resolve().parent
+    repo_root = script_dir.parent
+    src_dir = repo_root / "src"
+    out_dir = repo_root / "out"
+
+    profile: str = str(args.profile)
+    config_dir_override: str = str(args.config_dir_override)
+
+    # --- Load profile ---
+    profile_file = src_dir / "profiles" / f"{profile}.env"
+    if not profile_file.is_file():
+        print(f"Error: profile file not found: {profile_file}", file=sys.stderr)
+        print("Available profiles:", file=sys.stderr)
+        profiles_dir = src_dir / "profiles"
+        for p in sorted(profiles_dir.glob("*.env")):
+            print(f"  {p.stem}", file=sys.stderr)
+        sys.exit(1)
+
+    env_vars = parse_env_file(profile_file)
+
+    config_dir_str: str = env_vars.get("CONFIG_DIR", "")
+    opencode_config_src: str = env_vars.get("OPENCODE_CONFIG_SRC", "")
+    agent_vault: str = env_vars.get("AGENT_VAULT", os.environ.get("AGENT_VAULT", ""))
+
+    if not config_dir_str:
+        print("Error: CONFIG_DIR not set in profile.", file=sys.stderr)
+        sys.exit(1)
+
+    if not opencode_config_src:
+        print("Error: OPENCODE_CONFIG_SRC not set in profile.", file=sys.stderr)
+        sys.exit(1)
+
+    # --- Apply --config-dir override ---
+    if config_dir_override:
+        config_dir_str = config_dir_override
+
+    # --- Expand ~ ---
+    config_dir = Path(os.path.expanduser(config_dir_str)).resolve()
+    opencode_config_src = os.path.expanduser(opencode_config_src)
+
+    # --- Check out/ exists ---
+    if not out_dir.is_dir():
+        print("Error: out/ directory not found.", file=sys.stderr)
+        print("Run build.py first to produce the build output:", file=sys.stderr)
+        print(f"  python3 {script_dir / 'build.py'}", file=sys.stderr)
+        sys.exit(1)
+
+    # --- Safety: refuse if out/ == CONFIG_DIR ---
+    try:
+        resolved_out = out_dir.resolve()
+        resolved_config = config_dir.resolve()
+    except Exception:
+        resolved_out = out_dir
+        resolved_config = config_dir
+
+    if resolved_out == resolved_config:
+        print("Error: out/ directory equals target CONFIG_DIR.", file=sys.stderr)
+        print("", file=sys.stderr)
+        print(f"  out/:       {resolved_out}", file=sys.stderr)
+        print(f"  CONFIG_DIR: {resolved_config}", file=sys.stderr)
+        print("", file=sys.stderr)
+        print(
+            "Rsyncing out/ onto itself would be destructive. Check your profile.",
+            file=sys.stderr,
+        )
+        sys.exit(1)
+
+    # --- Rsync out/ to CONFIG_DIR ---
+    print(f"Deploying to: {config_dir}")
+    print(f"Profile:      {profile} ({profile_file})")
+    print(f"Source:       {out_dir}")
+    print()
+
+    config_dir.mkdir(parents=True, exist_ok=True)
+
+    rsync_cmd = [
+        "rsync",
+        "-a",
+        "--delete",
+        f"{out_dir}/",
+        f"{config_dir}/",
+    ]
+    _ = subprocess.run(rsync_cmd, check=True)
+    print("Rsync complete.")
+
+    # --- Deploy AoE config ---
+    aoe_src = src_dir / "aoe-config.toml"
+    aoe_dest = Path.home() / ".config" / "aoe" / "config.toml"
+    if aoe_src.is_file():
+        if agent_vault:
+            aoe_dest.parent.mkdir(parents=True, exist_ok=True)
+            content = aoe_src.read_text()
+            content = content.replace("{{AGENT_VAULT}}", agent_vault)
+            content = content.replace("{{OPENCODE_CONFIG_SRC}}", opencode_config_src)
+            _ = aoe_dest.write_text(content)
+            print(f"AoE config deployed to: {aoe_dest}")
+        else:
+            print(
+                "Warning: AGENT_VAULT not set — skipping AoE config deployment.",
+                file=sys.stderr,
+            )
+
+    # --- Summary ---
+    print()
+    print("Done.")
+    print()
+    print(f"  Profile:             {profile}")
+    print(f"  Source:              {out_dir}")
+    print(f"  Target directory:    {config_dir}")
+    print(f"  OPENCODE_CONFIG_SRC: {opencode_config_src}")
+    print()
+    print("To use this config, ensure OPENCODE_CONFIG_SRC is set in your environment:")
+    print(f'  export OPENCODE_CONFIG_SRC="{opencode_config_src}"')
+
+
+if __name__ == "__main__":
+    main()

cubething_occonf-0.1.0/lint.sh

@@ -0,0 +1,84 @@
+#!/usr/bin/env bash
+# lint.sh -- run the same checks as CI (.github/workflows/lint.yml)
+# Exit codes: 0 = all passed, 1 = one or more checks failed
+set -euo pipefail
+
+cd "$(git rev-parse --show-toplevel)"
+
+failed=()
+
+header() { printf '\n\033[1;34m==> %s\033[0m\n' "$1"; }
+
+# -- shfmt -------------------------------------------------------------------
+header "shfmt"
+mapfile -t sh_files < <(find . -name '*.sh' -not -path '*/node_modules/*')
+if [[ ${#sh_files[@]} -gt 0 ]]; then
+	if ! shfmt -d "${sh_files[@]}"; then
+		failed+=(shfmt)
+	fi
+else
+	echo "(no .sh files found)"
+fi
+
+# -- shellcheck ---------------------------------------------------------------
+header "shellcheck"
+if [[ ${#sh_files[@]} -gt 0 ]]; then
+	if ! shellcheck "${sh_files[@]}"; then
+		failed+=(shellcheck)
+	fi
+else
+	echo "(no .sh files found)"
+fi
+
+# -- prettier -----------------------------------------------------------------
+# Detect a way to run prettier: direct binary, then package-runner CLIs
+prettier_cmd=()
+if command -v prettier &>/dev/null; then
+	prettier_cmd=(prettier)
+elif command -v bunx &>/dev/null; then
+	prettier_cmd=(bunx prettier)
+elif command -v pnpx &>/dev/null; then
+	prettier_cmd=(pnpx prettier)
+elif command -v npx &>/dev/null; then
+	prettier_cmd=(npx prettier)
+elif command -v deno &>/dev/null; then
+	prettier_cmd=(deno run npm:prettier --)
+else
+	prettier_cmd=()
+fi
+
+header "prettier"
+if [[ ${#prettier_cmd[@]} -eq 0 ]]; then
+	echo "SKIP: no prettier, bunx, pnpx, npx, or deno found"
+	failed+=(prettier)
+elif ! "${prettier_cmd[@]}" --check .; then
+	failed+=(prettier)
+fi
+
+# -- ruff format --------------------------------------------------------------
+header "ruff format"
+if ! uvx ruff format --check scripts/; then
+	failed+=(ruff-format)
+fi
+
+# -- ruff check ---------------------------------------------------------------
+header "ruff check"
+if ! uvx ruff check scripts/; then
+	failed+=(ruff-check)
+fi
+
+# -- basedpyright -------------------------------------------------------------
+# Run from scripts/ so basedpyright finds pyproject.toml config
+header "basedpyright"
+if ! (cd scripts && uvx basedpyright .); then
+	failed+=(basedpyright)
+fi
+
+# -- summary ------------------------------------------------------------------
+echo
+if [[ ${#failed[@]} -gt 0 ]]; then
+	printf '\033[1;31mFailed: %s\033[0m\n' "${failed[*]}"
+	exit 1
+else
+	printf '\033[1;32mAll checks passed.\033[0m\n'
+fi

cubething_occonf-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cubething-occonf"
+version = "0.1.0"
+description = "Standalone installer for ada-x64/opencode-config"
+requires-python = ">=3.12"
+license = { text = "MIT" }
+authors = [{ name = "ada-x64" }]
+
+[project.scripts]
+cubething-occonf = "scripts.setup:main"
+
+[tool.hatch.build.targets.wheel]
+include = ["scripts/setup.py"]
+
+[tool.ruff]
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "W", "I", "UP", "B", "RUF"]
+ignore = [
+  "E501", # line too long — formatter handles this
+]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+
+[tool.basedpyright]
+pythonVersion = "3.12"
+typeCheckingMode = "standard"
+include = ["scripts"]
+ignore = ["**/__pycache__"]
+
+# json.loads returns Any; these flow from it and can't be avoided without
+# wrapping every call in a TypedDict — not worth it for a build script
+reportAny = "none"
+reportUnknownVariableType = "none"
+reportUnknownParameterType = "none"
+reportUnknownMemberType = "none"
+reportUnknownArgumentType = "none"

cubething_occonf-0.1.0/setup.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+"""setup.py — standalone installer for opencode-config
+
+Bootstrapper entry point. Prompts for environment paths, downloads the
+release tarball to a staging directory, runs build.py to produce stamped
+output, then rsyncs out/ to ~/.config/opencode and writes shell env vars.
+
+Usage:
+  # Recommended — via uv (no install required):
+  uvx cubething-occonf
+
+  # Or via pipx:
+  pipx run cubething-occonf
+
+  # Directly from a GitHub release (no PyPI needed):
+  uvx --from https://github.com/ada-x64/opencode-config/releases/latest/download/opencode-config.tar.gz cubething-occonf
+
+  # Pipe from curl (classic):
+  curl -fsSL https://github.com/ada-x64/opencode-config/releases/latest/download/setup.py | python3
+
+  # Or run the downloaded script directly:
+  python3 setup.py
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import IO
+
+# ---------------------------------------------------------------------------
+# Config
+# ---------------------------------------------------------------------------
+
+CONFIG_DIR = Path.home() / ".config" / "opencode"
+REPO = "ada-x64/opencode-config"
+TARBALL_URL = (
+    f"https://github.com/{REPO}/releases/latest/download/opencode-config.tar.gz"
+)
+
+# ---------------------------------------------------------------------------
+# Color helpers
+# ---------------------------------------------------------------------------
+
+
+def info(msg: str) -> None:
+    print(f"\033[1;32m==>\033[0m \033[1m{msg}\033[0m")
+
+
+def warn(msg: str) -> None:
+    print(f"\033[1;33mWarning:\033[0m {msg}", file=sys.stderr)
+
+
+# ---------------------------------------------------------------------------
+# Interactive prompts
+# When piped via curl | python3, stdin is the script, not the terminal.
+# Open /dev/tty explicitly so input() can interact with the user.
+# ---------------------------------------------------------------------------
+
+
+def open_tty() -> IO[str] | None:
+    """Return a file object for /dev/tty, or None if unavailable."""
+    try:
+        return open("/dev/tty")
+    except OSError:
+        return None
+
+
+def prompt(tty: IO[str], message: str) -> str:
+    """Write prompt to stdout and read a line from tty."""
+    print(message, end="", flush=True)
+    return tty.readline().rstrip("\n")
+
+
+def prompt_required(tty: IO[str], label: str, env_key: str) -> str:
+    """Prompt for a required value, looping until non-empty. Honours env default."""
+    default = os.environ.get(env_key, "")
+    while True:
+        if default:
+            value = prompt(tty, f"{label} [{default}]: ")
+        else:
+            value = prompt(tty, f"{label} (required): ")
+        result = value or default
+        if result:
+            return result
+        warn(f"{env_key} is required.")
+
+
+def prompt_optional(tty: IO[str], label: str) -> str:
+    """Prompt for an optional value. Returns empty string if skipped."""
+    return prompt(tty, f"{label} (optional, Enter to skip): ")
+
+
+# ---------------------------------------------------------------------------
+# Shell profile helpers
+# ---------------------------------------------------------------------------
+
+
+def find_shell_profile() -> Path:
+    zdotdir = os.environ.get("ZDOTDIR", "")
+    if zdotdir:
+        return Path(zdotdir) / ".zshrc"
+    zshrc = Path.home() / ".zshrc"
+    if zshrc.exists():
+        return zshrc
+    return Path.home() / ".bashrc"
+
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+
+def main() -> None:
+    print()
+    print("  cubething-occonf setup")
+    print("  =====================")
+    print()
+
+    # --- Open /dev/tty for interactive prompts ---
+    tty = open_tty()
+    if tty is None:
+        warn("No interactive terminal available.")
+        warn(
+            "Set AGENT_VAULT and AGENT_REPOS in your environment and re-run setup.py directly:"
+        )
+        warn("  AGENT_VAULT=~/obsidian/agent.obs python3 setup.py")
+        sys.exit(1)
+
+    try:
+        agent_vault = prompt_required(tty, "Where is your agent vault?", "AGENT_VAULT")
+        agent_repos = prompt_required(tty, "Where do you keep repos?", "AGENT_REPOS")
+        ntfy_topic = prompt_optional(tty, "ntfy.sh topic for push notifications")
+    finally:
+        tty.close()
+
+    print()
+
+    # --- Download tarball to staging directory ---
+    info("Downloading opencode-config...")
+    staging = Path(tempfile.mkdtemp(prefix="opencode-config-"))
+    try:
+        tarball_path = staging / "opencode-config.tar.gz"
+        _, _ = urllib.request.urlretrieve(TARBALL_URL, tarball_path)
+
+        info("Extracting...")
+        with tarfile.open(tarball_path, "r:gz") as tf:
+            tf.extractall(staging)
+
+        # The tarball may contain a top-level directory — find the repo root
+        # (look for scripts/build.py to identify it)
+        repo_root = staging
+        for candidate in staging.iterdir():
+            if candidate.is_dir() and (candidate / "scripts" / "build.py").is_file():
+                repo_root = candidate
+                break
+
+        # --- Set up environment for child processes ---
+        env = os.environ.copy()
+        env["OPENCODE_CONFIG_SRC"] = str(CONFIG_DIR)
+        env["AGENT_VAULT"] = agent_vault
+        env["AGENT_REPOS"] = agent_repos
+        if ntfy_topic:
+            env["NTFY_TOPIC"] = ntfy_topic
+
+        # --- Run build.py (generates build.json, copies src/ → out/, stamps everything) ---
+        info("Running build.py...")
+        build_py = repo_root / "scripts" / "build.py"
+        _ = subprocess.run(
+            [sys.executable, str(build_py), "--config-dir", str(CONFIG_DIR)],
+            check=True,
+            env=env,
+            cwd=str(repo_root),
+        )
+
+        # --- Run install.py (rsyncs out/ → CONFIG_DIR, deploys AoE config) ---
+        info("Running install.py...")
+        install_py = repo_root / "scripts" / "install.py"
+        _ = subprocess.run(
+            [sys.executable, str(install_py), "--config-dir", str(CONFIG_DIR)],
+            check=True,
+            env=env,
+            cwd=str(repo_root),
+        )
+
+    finally:
+        # Clean up staging directory
+        shutil.rmtree(staging, ignore_errors=True)
+
+    # --- Write environment variables to shell profile ---
+    profile = find_shell_profile()
+    try:
+        existing = profile.read_text() if profile.exists() else ""
+    except OSError:
+        existing = ""
+
+    if "OPENCODE_CONFIG_SRC" in existing:
+        warn(
+            "Shell profile already contains OPENCODE_CONFIG_SRC — skipping env block."
+            + f" Update {profile} manually if needed."
+        )
+    else:
+        with profile.open("a") as fh:
+            _ = fh.write("\n# opencode-config\n")
+            _ = fh.write(f'export OPENCODE_CONFIG_SRC="{CONFIG_DIR}"\n')
+            _ = fh.write(f'export AGENT_VAULT="{agent_vault}"\n')
+            _ = fh.write(f'export AGENT_REPOS="{agent_repos}"\n')
+            if ntfy_topic:
+                _ = fh.write(f'export NTFY_TOPIC="{ntfy_topic}"\n')
+        info(f"Environment variables written to {profile}")
+
+    # --- Summary ---
+    print()
+    info("Setup complete!")
+    print()
+    print(f"  Config:    {CONFIG_DIR}")
+    print("  AoE:       ~/.config/aoe/config.toml")
+    print(f"  Vault:     {agent_vault}")
+    print(f"  Repos:     {agent_repos}")
+    print()
+    print(f"Restart your shell or run: source ~/{profile.name}")
+    print()
+
+
+if __name__ == "__main__":
+    main()