raidlock 0.1.0__py3-none-any.whl

raidlock/commands_install.py

@@ -0,0 +1,114 @@
+import contextlib
+import os
+
+from .core.errors import Precondition
+
+MARKER = "raidlock-managed: install-commands"
+CONTENT = f"""---
+name: raid
+description: Run a raidlock board command (up, who, claimable, show <id>, claim <id>)
+argument-hint: up | who | claimable | show <id> | claim <id>
+allowed-tools: Bash(raidlock *)
+disable-model-invocation: true
+{MARKER}
+---
+
+!`raidlock $ARGUMENTS`
+
+Relay the output above in one or two lines, keeping its `Next:` step. Run nothing else.
+"""
+
+
+def config_dir(env=None):
+    env = os.environ if env is None else env
+    return env.get("CLAUDE_CONFIG_DIR") or os.path.join(os.path.expanduser("~"), ".claude")
+
+
+def commands_dir(env=None):
+    return os.path.join(config_dir(env), "skills", "raid")
+
+
+def target(env=None):
+    return os.path.join(commands_dir(env), "SKILL.md")
+
+
+def legacy_target(env=None):
+    return os.path.join(config_dir(env), "commands", "raid.md")
+
+
+def _read(path):
+    try:
+        with open(path, encoding="utf-8") as f:
+            return f.read()
+    except FileNotFoundError:
+        return None
+
+
+def _ours(text):
+    head = text.split("\n---", 1)[0] if text.startswith("---") else ""
+    return MARKER in head.splitlines()
+
+
+def _drop_legacy(env):
+    path = legacy_target(env)
+    current = _read(path)
+    if current is not None and _ours(current):
+        os.remove(path)
+
+
+def install(env=None):
+    _drop_legacy(env)
+    path = target(env)
+    current = _read(path)
+    if current is not None and not _ours(current):
+        raise Precondition(
+            f"{path} exists and was not written by raidlock; left untouched",
+            path=path,
+            hint="move it away, then run raidlock install-commands",
+        )
+    if current == CONTENT:
+        return {"action": "unchanged", "path": path}
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    tmp = f"{path}.{os.getpid()}.tmp"
+    with open(tmp, "w", encoding="utf-8", newline="\n") as f:
+        f.write(CONTENT)
+    os.replace(tmp, path)
+    return {"action": "updated" if current is not None else "installed", "path": path}
+
+
+def uninstall(env=None):
+    _drop_legacy(env)
+    path = target(env)
+    current = _read(path)
+    if current is None:
+        return {"action": "absent", "path": path}
+    if not _ours(current):
+        raise Precondition(f"{path} was not written by raidlock; left untouched", path=path)
+    os.remove(path)
+    with contextlib.suppress(OSError):
+        os.rmdir(os.path.dirname(path))
+    return {"action": "removed", "path": path}
+
+
+TEXT = {
+    "installed": "Installed /raid at {path}. Next: type /raid who in Claude Code",
+    "updated": "Updated /raid at {path}. Next: type /raid who in Claude Code",
+    "unchanged": "/raid is already installed at {path}.",
+    "removed": "Removed /raid ({path}).",
+    "absent": "/raid is not installed ({path}).",
+}
+
+
+def _setup(parser):
+    parser.add_argument("--uninstall", action="store_true", help="remove the /raid command this installed")
+
+
+def _handler(ctx, args):
+    result = uninstall() if args.uninstall else install()
+    return result, TEXT[result["action"]].format(path=result["path"])
+
+
+def register_cli(add_command):
+    add_command(
+        "install-commands", "add a personal /raid skill to Claude Code (--uninstall removes it)", _setup, _handler
+    )

raidlock/core/__init__.py

@@ -0,0 +1,26 @@
+"""raidlock core: the only writer of `.board/`. CLI, hooks, runners, the web UI and the MCP server import from here."""
+
+from .board import Board, find_board_dir
+from .cost import Usage
+from .errors import Denied, IdentityError, Precondition, RaidlockError, Timeout
+from .identity import Caller
+from .paths import canonical, contains, overlaps
+from .registry import synced_folder
+from .transcript import redact
+
+__all__ = [
+    "Board",
+    "Caller",
+    "Usage",
+    "RaidlockError",
+    "Denied",
+    "Precondition",
+    "Timeout",
+    "IdentityError",
+    "find_board_dir",
+    "canonical",
+    "contains",
+    "overlaps",
+    "redact",
+    "synced_folder",
+]

raidlock/core/advisories.py

@@ -0,0 +1,16 @@
+"""Best-effort pre-claim advice that cannot veto a claim."""
+
+from importlib import import_module
+
+PRE_CLAIM = (("raidlock.foresight", "pre_claim"),)
+
+
+def pre_claim_warnings(board, card_id, checkout=None):
+    warnings = []
+    for module, name in PRE_CLAIM:
+        try:
+            hook = getattr(import_module(module), name)
+            warnings.extend(hook(board, card_id, checkout=checkout))
+        except Exception as exc:
+            warnings.append(f"Warning: {module} advice skipped: {exc}")
+    return warnings

raidlock/core/billing.py

@@ -0,0 +1,54 @@
+import json
+import os
+
+MODES = ("api", "plan", "unknown")
+
+
+def _read_json(path):
+    try:
+        with open(path, encoding="utf-8") as f:
+            data = json.load(f)
+        return data if isinstance(data, dict) else {}
+    except (OSError, ValueError):
+        return {}
+
+
+def _codex(env):
+    if env.get("OPENAI_API_KEY") or env.get("CODEX_API_KEY"):
+        return "api", "env"
+    base = env.get("CODEX_HOME") or os.path.join(os.path.expanduser("~"), ".codex")
+    auth = _read_json(os.path.join(base, "auth.json"))
+    mode = str(auth.get("auth_mode", "")).lower()
+    if mode == "chatgpt" or auth.get("tokens"):
+        return "plan", "config"
+    if mode in ("apikey", "api_key") or auth.get("OPENAI_API_KEY"):
+        return "api", "config"
+    return "unknown", "unknown"
+
+
+def _claude(env):
+    if env.get("ANTHROPIC_API_KEY") or env.get("CLAUDE_CODE_USE_BEDROCK") or env.get("CLAUDE_CODE_USE_VERTEX"):
+        return "api", "env"
+    base = env.get("CLAUDE_CONFIG_DIR")
+    state = os.path.join(base, ".claude.json") if base else os.path.join(os.path.expanduser("~"), ".claude.json")
+    if _read_json(state).get("oauthAccount"):
+        return "plan", "config"
+    return "unknown", "unknown"
+
+
+def _gemini(env):
+    if env.get("GEMINI_API_KEY") or env.get("GOOGLE_API_KEY") or env.get("GOOGLE_GENAI_USE_VERTEXAI"):
+        return "api", "env"
+    return "unknown", "unknown"
+
+
+def detect(runtime, declared=None, env=None):
+    """Billing mode of an agent: api (pay per token), plan (subscription, $0 marginal) or unknown.
+    Order: declared, RAIDLOCK_BILLING, runtime credentials (never read beyond the auth mode)."""
+    env = os.environ if env is None else env
+    for value, source in ((declared, "declared"), (env.get("RAIDLOCK_BILLING"), "env")):
+        if value in MODES:
+            return {"billing": value, "billing_source": source}
+    detector = {"codex-cli": _codex, "claude-code": _claude, "gemini-cli": _gemini}.get(runtime)
+    mode, source = detector(env) if detector else ("unknown", "unknown")
+    return {"billing": mode, "billing_source": source}