typefully-cli 0.1.0__py3-none-any.whl

typefully_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Typefully CLI -- manage drafts, threads, and publishing from the terminal."""
+
+__version__ = "0.1.0"

typefully_cli/__main__.py

@@ -0,0 +1,5 @@
+"""Allow running as `python -m typefully_cli`."""
+
+from typefully_cli.cli import cli
+
+cli()

typefully_cli/auth.py

@@ -0,0 +1,57 @@
+"""API key resolution chain."""
+
+from __future__ import annotations
+
+import subprocess
+
+from typefully_cli.config import Config
+from typefully_cli.exceptions import AuthError
+
+
+def resolve_api_key(
+    cli_flag: str | None,
+    env_var: str | None,
+    config: Config,
+) -> str:
+    """Resolve API key from the priority chain.
+
+    1. --api-key CLI flag
+    2. TYPEFULLY_API_KEY env var
+    3. Config file [auth] api_key
+    4. 1Password (if configured)
+    """
+    if cli_flag:
+        return cli_flag
+    if env_var:
+        return env_var
+    if config.api_key:
+        return config.api_key
+    if config.onepassword_item:
+        return _fetch_from_1password(config.onepassword_item)
+    raise AuthError()
+
+
+def _fetch_from_1password(item_name: str) -> str:
+    """Fetch API key from 1Password CLI."""
+    try:
+        result = subprocess.run(
+            ["op", "item", "get", item_name, "--fields", "password", "--reveal"],
+            capture_output=True,
+            text=True,
+            timeout=30,
+        )
+    except FileNotFoundError:
+        raise AuthError(
+            "1Password CLI (op) not found",
+            hint="Install 1Password CLI or use a different auth method",
+        )
+    except subprocess.TimeoutExpired:
+        raise AuthError("1Password CLI timed out")
+
+    key = result.stdout.strip()
+    if not key or result.returncode != 0:
+        raise AuthError(
+            f"Could not retrieve key from 1Password item '{item_name}'",
+            hint="Check that the item exists and 1Password CLI is unlocked",
+        )
+    return key

typefully_cli/batch.py

@@ -0,0 +1,126 @@
+"""Batch file parser for the ---/=== format."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+from typefully_cli.exceptions import BatchParseError
+
+METADATA_KEYS = {"schedule", "tag", "title", "scratchpad", "media"}
+
+
+@dataclass
+class BatchEntry:
+    posts: list[str]
+    schedule: str | None = None
+    tags: list[str] = field(default_factory=list)
+    title: str | None = None
+    scratchpad: str | None = None
+    media_ids: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        d: dict = {"posts": self.posts}
+        if self.schedule:
+            d["schedule"] = self.schedule
+        if self.tags:
+            d["tags"] = self.tags
+        if self.title:
+            d["title"] = self.title
+        if self.scratchpad:
+            d["scratchpad"] = self.scratchpad
+        if self.media_ids:
+            d["media_ids"] = self.media_ids
+        d["type"] = "thread" if len(self.posts) > 1 else "single"
+        d["post_count"] = len(self.posts)
+        return d
+
+
+def parse_batch_file(content: str) -> list[BatchEntry]:
+    """Parse a batch file into entries.
+
+    Format:
+    - Blocks separated by --- on its own line
+    - Thread posts separated by === on its own line within a block
+    - Metadata lines at top of each block: schedule:, tag:, title:, scratchpad:, media:
+    """
+    blocks = re.split(r"\n---\n", content.strip())
+    entries: list[BatchEntry] = []
+
+    for block in blocks:
+        block = block.strip()
+        if not block:
+            continue
+
+        lines = block.split("\n")
+        schedule = None
+        tags: list[str] = []
+        title = None
+        scratchpad = None
+        media_ids: list[str] = []
+        post_lines: list[str] = []
+
+        in_header = True
+        for line in lines:
+            stripped = line.strip()
+            if in_header:
+                match = re.match(r"^(\w+):\s*(.+)$", stripped)
+                if match and match.group(1).lower() in METADATA_KEYS:
+                    key = match.group(1).lower()
+                    val = match.group(2).strip()
+                    if key == "schedule":
+                        schedule = val
+                    elif key == "tag":
+                        tags.append(val)
+                    elif key == "title":
+                        title = val
+                    elif key == "scratchpad":
+                        scratchpad = val
+                    elif key == "media":
+                        media_ids = [m.strip() for m in val.split(",") if m.strip()]
+                    continue
+                else:
+                    in_header = False
+            post_lines.append(line)
+
+        post_text = "\n".join(post_lines).strip()
+        if not post_text:
+            continue
+
+        thread_parts = re.split(r"\n===\n", post_text)
+        posts = [p.strip() for p in thread_parts if p.strip()]
+
+        if not posts:
+            continue
+
+        entries.append(
+            BatchEntry(
+                posts=posts,
+                schedule=schedule,
+                tags=tags,
+                title=title,
+                scratchpad=scratchpad,
+                media_ids=media_ids,
+            )
+        )
+
+    if not entries:
+        raise BatchParseError("No valid entries found in batch file")
+
+    return entries
+
+
+def merge_defaults(
+    entries: list[BatchEntry],
+    default_schedule: str | None = None,
+    default_tags: tuple[str, ...] = (),
+) -> None:
+    """Apply command-line defaults to entries missing metadata."""
+    for entry in entries:
+        if not entry.schedule and default_schedule:
+            entry.schedule = default_schedule
+        if default_tags:
+            existing = {t.lower() for t in entry.tags}
+            for t in default_tags:
+                if t.lower() not in existing:
+                    entry.tags.append(t)