@flydocs/cli 0.6.0-alpha.2 → 0.6.0-alpha.21

package/template/.claude/skills/flydocs-cloud/scripts/flydocs_api.py

@@ -1,210 +0,0 @@
-"""FlyDocs Cloud API — Relay REST client.
-
-Central module for all relay API operations.
-Loads config from .flydocs/config.json and API key from .env files.
-
-Usage:
-    from flydocs_api import get_client
-    client = get_client()
-    result = client.post("/issues", {"title": "New issue", "type": "feature"})
-"""
-
-import json
-import os
-import sys
-import time
-from pathlib import Path
-from typing import Optional
-
-
-class FlyDocsClient:
-    """Client for FlyDocs Relay REST API with retry logic and config awareness."""
-
-    DEFAULT_BASE_URL = "https://app.flydocs.ai/api/relay"
-    LOCAL_BASE_URL = "http://localhost:3000/api/relay"
-    MAX_RETRIES = 3
-    RETRY_DELAY = 2
-
-    def __init__(self):
-        self.project_root = find_project_root()
-        self.config_path = self.project_root / ".flydocs" / "config.json"
-        self.log_path = self.project_root / ".flydocs" / "logs" / "relay-ops.jsonl"
-
-        self.config = self._load_config()
-        self.api_key = self._load_api_key()
-        if not self.api_key:
-            print("ERROR: FLYDOCS_API_KEY not found", file=sys.stderr)
-            print("Set in environment or .env/.env.local file", file=sys.stderr)
-            sys.exit(1)
-
-        self.base_url = self._resolve_base_url()
-
-    def _load_config(self) -> dict:
-        if self.config_path.exists():
-            with open(self.config_path, "r") as f:
-                return json.load(f)
-        return {}
-
-    def _load_api_key(self) -> Optional[str]:
-        if os.environ.get("FLYDOCS_API_KEY"):
-            return os.environ["FLYDOCS_API_KEY"]
-        for name in [".env.local", ".env"]:
-            env_file = self.project_root / name
-            if env_file.exists():
-                key = self._parse_env_file(env_file, "FLYDOCS_API_KEY")
-                if key:
-                    return key
-        return None
-
-    def _parse_env_file(self, path: Path, key: str) -> Optional[str]:
-        with open(path, "r") as f:
-            for line in f:
-                line = line.strip()
-                if line.startswith("#") or "=" not in line:
-                    continue
-                k, _, v = line.partition("=")
-                if k.strip() == key:
-                    v = v.strip().strip("\"'")
-                    return v if v else None
-        return None
-
-    def _resolve_base_url(self) -> str:
-        """Resolve base URL: env var > config > default."""
-        env_url = os.environ.get("FLYDOCS_RELAY_URL")
-        if env_url:
-            return env_url.rstrip("/")
-        config_url = self.config.get("relay", {}).get("url")
-        if config_url:
-            return config_url.rstrip("/")
-        return self.DEFAULT_BASE_URL
-
-    def _request(self, method: str, path: str, body: Optional[dict] = None,
-                 params: Optional[dict] = None) -> dict:
-        """Make an HTTP request to the relay API."""
-        import urllib.request
-        import urllib.error
-        import urllib.parse
-
-        url = f"{self.base_url}{path}"
-        if params:
-            filtered = {k: v for k, v in params.items() if v is not None and v != ""}
-            if filtered:
-                url += "?" + urllib.parse.urlencode(filtered, doseq=True)
-
-        headers = {
-            "Authorization": f"Bearer {self.api_key}",
-            "Content-Type": "application/json",
-            "Accept": "application/json",
-        }
-
-        data = json.dumps(body).encode("utf-8") if body else None
-
-        for attempt in range(self.MAX_RETRIES):
-            try:
-                req = urllib.request.Request(url, data=data, headers=headers, method=method)
-                with urllib.request.urlopen(req, timeout=15) as resp:
-                    response_body = resp.read().decode("utf-8")
-                    result = json.loads(response_body) if response_body else {}
-                    self._log_operation(method, path, resp.status, result)
-                    return result
-            except urllib.error.HTTPError as e:
-                error_body = e.read().decode("utf-8") if e.fp else ""
-                try:
-                    error_data = json.loads(error_body) if error_body else {}
-                except json.JSONDecodeError:
-                    error_data = {"error": error_body}
-                self._log_operation(method, path, e.code, error_data)
-
-                if e.code == 429 and attempt < self.MAX_RETRIES - 1:
-                    delay = self.RETRY_DELAY * (2 ** attempt)
-                    print(f"Rate limited, retrying in {delay}s...", file=sys.stderr)
-                    time.sleep(delay)
-                    continue
-                if e.code >= 500 and attempt < self.MAX_RETRIES - 1:
-                    delay = self.RETRY_DELAY * (2 ** attempt)
-                    print(f"Server error ({e.code}), retrying in {delay}s...", file=sys.stderr)
-                    time.sleep(delay)
-                    continue
-
-                error_msg = error_data.get("error", f"HTTP {e.code}")
-                error_code = error_data.get("code", "UNKNOWN")
-                provider = error_data.get("provider_error", "")
-                msg = f"Relay API error ({error_code}): {error_msg}"
-                if provider:
-                    msg += f" — provider: {provider}"
-                fail(msg)
-            except (urllib.error.URLError, TimeoutError):
-                if attempt < self.MAX_RETRIES - 1:
-                    delay = self.RETRY_DELAY * (2 ** attempt)
-                    print(f"Network error, retrying in {delay}s...", file=sys.stderr)
-                    time.sleep(delay)
-                    continue
-                fail("Network error: unable to reach relay API")
-
-        fail("Max retries exceeded")
-        return {}  # unreachable but satisfies type checker
-
-    def get(self, path: str, params: Optional[dict] = None) -> dict | list:
-        """GET request to relay API."""
-        return self._request("GET", path, params=params)
-
-    def post(self, path: str, body: Optional[dict] = None) -> dict:
-        """POST request to relay API."""
-        return self._request("POST", path, body=body)
-
-    def put(self, path: str, body: Optional[dict] = None) -> dict:
-        """PUT request to relay API."""
-        return self._request("PUT", path, body=body)
-
-    def patch(self, path: str, body: Optional[dict] = None) -> dict:
-        """PATCH request to relay API."""
-        return self._request("PATCH", path, body=body)
-
-    def _log_operation(self, method: str, path: str, status: int, result: dict | list):
-        """Log operation metadata to local log file."""
-        try:
-            from datetime import datetime, timezone
-            self.log_path.parent.mkdir(parents=True, exist_ok=True)
-            entry = {
-                "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
-                "method": method,
-                "path": path,
-                "status": status,
-                "success": 200 <= status < 300,
-            }
-            with open(self.log_path, "a") as f:
-                f.write(json.dumps(entry) + "\n")
-        except Exception:
-            pass  # logging should never break operations
-
-
-def find_project_root() -> Path:
-    """Walk up from cwd to find .flydocs/ directory."""
-    current = Path.cwd()
-    while current != current.parent:
-        if (current / ".flydocs").is_dir():
-            return current
-        current = current.parent
-    return Path.cwd()
-
-
-_client: Optional[FlyDocsClient] = None
-
-
-def get_client() -> FlyDocsClient:
-    """Get or create singleton client."""
-    global _client
-    if _client is None:
-        _client = FlyDocsClient()
-    return _client
-
-
-def output_json(data: dict | list) -> None:
-    """Print JSON to stdout — standard contract output."""
-    print(json.dumps(data))
-
-
-def fail(message: str) -> None:
-    """Print error to stderr and exit 1."""
-    print(message, file=sys.stderr)
-    sys.exit(1)

package/template/.claude/skills/flydocs-cloud/scripts/get_issue.py

@@ -1,24 +0,0 @@
-#!/usr/bin/env python3
-"""Get full details for an issue via the FlyDocs Relay API."""
-
-import argparse
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json, fail
-
-parser = argparse.ArgumentParser(description="Get issue details")
-parser.add_argument("ref", help="Issue reference (e.g., ENG-123)")
-parser.add_argument("--fields", choices=["basic", "full"], default="full",
-                    help="basic = no comments, full = with comments (default)")
-args = parser.parse_args()
-
-params: dict = {}
-if args.fields == "basic":
-    params["fields"] = "basic"
-
-client = get_client()
-result = client.get(f"/issues/{args.ref}", params=params)
-
-output_json(result)

package/template/.claude/skills/flydocs-cloud/scripts/link.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-"""Create a link between two issues via the FlyDocs Relay API."""
-
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json, fail
-
-if len(sys.argv) < 4:
-    fail("Usage: link.py <ref> <related_ref> <type>")
-
-ref, related_ref, link_type = sys.argv[1], sys.argv[2], sys.argv[3]
-
-valid_types = ("blocks", "related", "duplicate")
-if link_type not in valid_types:
-    fail(f"Link type must be one of: {', '.join(valid_types)}")
-
-client = get_client()
-result = client.post(f"/issues/{ref}/link", {
-    "relatedRef": related_ref,
-    "type": link_type,
-})
-
-output_json({
-    "success": result.get("success", True),
-    "type": result.get("type", link_type),
-})

package/template/.claude/skills/flydocs-cloud/scripts/list_cycles.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-"""List cycles via the FlyDocs Relay API."""
-
-import argparse
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json
-
-
-def main():
-    parser = argparse.ArgumentParser(description="List cycles")
-    parser.add_argument("--active", action="store_true")
-    args = parser.parse_args()
-
-    params: dict = {}
-    if args.active:
-        params["active"] = "true"
-
-    client = get_client()
-    result = client.get("/cycles", params=params)
-
-    output_json(result)
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/list_issues.py

@@ -1,44 +0,0 @@
-#!/usr/bin/env python3
-"""List issues with optional filters via the FlyDocs Relay API."""
-
-import argparse
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json
-
-
-def main():
-    parser = argparse.ArgumentParser(description="List issues")
-    parser.add_argument("--status", default="", help="Single status or comma-separated: READY,IMPLEMENTING,BLOCKED")
-    parser.add_argument("--active", action="store_true", help="All non-terminal states")
-    parser.add_argument("--project", default="")
-    parser.add_argument("--assignee", default="")
-    parser.add_argument("--milestone", default="", help="Filter by milestone ID")
-    parser.add_argument("--mine", action="store_true")
-    parser.add_argument("--limit", type=int, default=50)
-    args = parser.parse_args()
-
-    params: dict = {"limit": str(args.limit)}
-    if args.status:
-        params["status"] = args.status.upper()
-    if args.active:
-        params["active"] = "true"
-    if args.project:
-        params["project"] = args.project
-    if args.assignee:
-        params["assignee"] = args.assignee
-    if args.milestone:
-        params["milestone"] = args.milestone
-    if args.mine:
-        params["mine"] = "true"
-
-    client = get_client()
-    result = client.get("/issues", params=params)
-
-    output_json(result)
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/list_labels.py

@@ -1,19 +0,0 @@
-#!/usr/bin/env python3
-"""List available team labels via the FlyDocs Relay API."""
-
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json
-
-
-def main():
-    client = get_client()
-    result = client.get("/labels")
-
-    output_json(result)
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/list_milestones.py

@@ -1,28 +0,0 @@
-#!/usr/bin/env python3
-"""List milestones via the FlyDocs Relay API."""
-
-import argparse
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json
-
-
-def main():
-    parser = argparse.ArgumentParser(description="List milestones")
-    parser.add_argument("--all", action="store_true", dest="show_all")
-    args = parser.parse_args()
-
-    params: dict = {}
-    if args.show_all:
-        params["all"] = "true"
-
-    client = get_client()
-    result = client.get("/milestones", params=params)
-
-    output_json(result)
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/list_projects.py

@@ -1,31 +0,0 @@
-#!/usr/bin/env python3
-"""List projects via the FlyDocs Relay API."""
-
-import argparse
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json
-
-
-def main():
-    parser = argparse.ArgumentParser(description="List projects")
-    parser.add_argument("--active", action="store_true")
-    parser.add_argument("--all", action="store_true", dest="show_all")
-    args = parser.parse_args()
-
-    params: dict = {}
-    if args.active:
-        params["active"] = "true"
-    if args.show_all:
-        params["all"] = "true"
-
-    client = get_client()
-    result = client.get("/projects", params=params)
-
-    output_json(result)
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/list_teams.py

@@ -1,19 +0,0 @@
-#!/usr/bin/env python3
-"""List available teams via the FlyDocs Relay API."""
-
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json
-
-
-def main():
-    client = get_client()
-    result = client.get("/teams")
-
-    output_json(result)
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/priority.py

@@ -1,29 +0,0 @@
-#!/usr/bin/env python3
-"""Set priority on an issue via the FlyDocs Relay API."""
-
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json, fail
-
-if len(sys.argv) < 3:
-    fail("Usage: priority.py <ref> <0-4>")
-
-ref = sys.argv[1]
-try:
-    priority = int(sys.argv[2])
-except ValueError:
-    fail("Priority must be a number (0-4)")
-
-if priority not in range(5):
-    fail("Priority must be 0 (none), 1 (urgent), 2 (high), 3 (medium), or 4 (low)")
-
-client = get_client()
-result = client.put(f"/issues/{ref}/priority", {"priority": priority})
-
-output_json({
-    "success": result.get("success", True),
-    "issue": result.get("issue", ref),
-    "priority": result.get("priority", priority),
-})

package/template/.claude/skills/flydocs-cloud/scripts/project_update.py

@@ -1,45 +0,0 @@
-#!/usr/bin/env python3
-"""Post a project update via the FlyDocs Relay API."""
-
-import argparse
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json, fail
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Post project update")
-    parser.add_argument("--health", required=True, choices=["onTrack", "atRisk", "offTrack"])
-    parser.add_argument("--body", default=None)
-    parser.add_argument("--body-file", default=None, dest="body_file")
-    args = parser.parse_args()
-
-    # Resolve body: --body-file > stdin > --body
-    body = args.body
-    if args.body_file:
-        try:
-            body = Path(args.body_file).read_text()
-        except FileNotFoundError:
-            fail(f"File not found: {args.body_file}")
-    elif body is None and not sys.stdin.isatty():
-        body = sys.stdin.read().strip()
-
-    if not body:
-        fail("Provide body via --body, --body-file, or stdin")
-
-    client = get_client()
-    result = client.post("/projects/update", {
-        "health": args.health,
-        "body": body,
-    })
-
-    output_json({
-        "success": result.get("success", True),
-        "id": result.get("id", ""),
-    })
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/set_labels.py

@@ -1,68 +0,0 @@
-#!/usr/bin/env python3
-"""Set label config on the relay API key.
-
-Configures default labels and type-to-label mapping for automatic label
-application during issue creation.
-
-Usage:
-    set_labels.py --defaults '["app"]' --type-map '{"feature":["Feature"],...}'
-    echo '{"defaults":["app"],"typeMap":{...}}' | set_labels.py
-"""
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json, fail
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Set label config on relay")
-    parser.add_argument("--defaults", default=None, help="JSON array of default label names")
-    parser.add_argument("--type-map", default=None, dest="type_map", help="JSON object mapping issue types to label arrays")
-    args = parser.parse_args()
-
-    # Build body from flags or stdin
-    if args.defaults is not None or args.type_map is not None:
-        body: dict = {}
-        if args.defaults is not None:
-            try:
-                body["defaults"] = json.loads(args.defaults)
-            except json.JSONDecodeError:
-                fail("Invalid JSON for --defaults")
-        if args.type_map is not None:
-            try:
-                body["typeMap"] = json.loads(args.type_map)
-            except json.JSONDecodeError:
-                fail("Invalid JSON for --type-map")
-    elif not sys.stdin.isatty():
-        try:
-            body = json.loads(sys.stdin.read().strip())
-        except json.JSONDecodeError:
-            fail("Invalid JSON on stdin")
-    else:
-        fail("Provide --defaults/--type-map flags or pipe JSON via stdin")
-
-    client = get_client()
-    result = client.post("/auth/labels", body)
-
-    # Store label config in local config as reference
-    config_path = client.config_path
-    if config_path.exists():
-        with open(config_path, "r") as f:
-            config = json.load(f)
-        config["labels"] = {
-            "defaults": body.get("defaults", []),
-            "typeMap": body.get("typeMap", {}),
-        }
-        with open(config_path, "w") as f:
-            json.dump(config, f, indent=2)
-            f.write("\n")
-
-    output_json(result)
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/set_team.py

@@ -1,41 +0,0 @@
-#!/usr/bin/env python3
-"""Set team preference via the FlyDocs Relay API.
-
-Stores the team preference on the relay (for server-side scoping)
-and updates the local config (for display/reference).
-"""
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json, fail
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Set team preference")
-    parser.add_argument("team_id", help="Linear team UUID")
-    args = parser.parse_args()
-
-    client = get_client()
-    result = client.post("/auth/team", {"teamId": args.team_id})
-
-    # Update local config with team ID
-    config_path = client.config_path
-    if config_path.exists():
-        with open(config_path, "r") as f:
-            config = json.load(f)
-        if "provider" not in config:
-            config["provider"] = {"type": "linear", "teamId": None}
-        config["provider"]["teamId"] = args.team_id
-        with open(config_path, "w") as f:
-            json.dump(config, f, indent=2)
-            f.write("\n")
-
-    output_json(result)
-
-
-if __name__ == "__main__":
-    main()

package/template/.claude/skills/flydocs-cloud/scripts/transition.py

@@ -1,26 +0,0 @@
-#!/usr/bin/env python3
-"""Transition an issue to a new status with a required comment."""
-
-import sys
-from pathlib import Path
-
-sys.path.insert(0, str(Path(__file__).parent))
-from flydocs_api import get_client, output_json, fail
-
-if len(sys.argv) < 4:
-    fail("Usage: transition.py <ref> <STATUS> <comment>")
-
-ref, status, comment = sys.argv[1], sys.argv[2].upper(), sys.argv[3]
-client = get_client()
-
-result = client.post(f"/issues/{ref}/transition", {
-    "status": status,
-    "comment": comment,
-})
-
-output_json({
-    "success": result.get("success", True),
-    "issue": result.get("issue", ref),
-    "previousStatus": result.get("previousStatus", ""),
-    "newStatus": result.get("newStatus", status),
-})