boring-cli 0.1.1__tar.gz

boring_cli-0.1.1/.gitignore

@@ -0,0 +1,52 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual environments
+venv/
+ENV/
+env/
+.venv/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+.nox/
+
+# Build
+*.manifest
+*.spec
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project specific
+.boring-agents/

boring_cli-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Boring Agents Team
+
+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.

boring_cli-0.1.1/PKG-INFO

@@ -0,0 +1,150 @@
+Metadata-Version: 2.4
+Name: boring-cli
+Version: 0.1.1
+Summary: CLI tool for managing Lark Suite tasks
+Project-URL: Homepage, https://github.com/anhbinhnguyen/boring-cli
+Project-URL: Repository, https://github.com/anhbinhnguyen/boring-cli
+Project-URL: Issues, https://github.com/anhbinhnguyen/boring-cli/issues
+Author: Boring Agents Team
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cli,lark,productivity,tasks
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Utilities
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0.0
+Requires-Dist: httpx>=0.26.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Boring CLI
+
+[![PyPI version](https://badge.fury.io/py/boring-cli.svg)](https://badge.fury.io/py/boring-cli)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+CLI tool for managing Lark Suite tasks from the command line.
+
+## Installation
+
+```bash
+pip install boring-cli
+```
+
+## Quick Start
+
+### 1. Setup
+
+Configure the CLI and login to Lark:
+
+```bash
+boring setup
+```
+
+This will prompt you for:
+- Server URL (your Boring Agents API server)
+- Bugs output directory (where tasks will be downloaded)
+- Lark task list GUIDs
+- Lark OAuth login
+
+### 2. Download Tasks
+
+Download tasks with Critical/Blocked/High labels to your local folder:
+
+```bash
+boring download
+```
+
+Download with specific labels:
+
+```bash
+boring download --labels "Critical,Blocked"
+```
+
+### 3. Solve Tasks
+
+Move completed tasks (from your bugs folder) to the Solved section in Lark:
+
+```bash
+boring solve
+```
+
+Keep local folders after solving:
+
+```bash
+boring solve --keep
+```
+
+### 4. Check Status
+
+View your current configuration:
+
+```bash
+boring status
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `boring setup` | Configure CLI and login to Lark |
+| `boring download` | Download tasks to local folder |
+| `boring solve` | Move tasks to Solved section |
+| `boring status` | Show current configuration |
+| `boring --version` | Show version |
+| `boring --help` | Show help |
+
+## Configuration
+
+Configuration is stored in `~/.boring-agents/config.yaml`:
+
+```yaml
+server_url: https://boring.omelet.tech/api
+jwt_token: eyJhbGc...
+bugs_dir: /path/to/bugs
+tasklist_guid: xxxx-xxxx-xxxx
+section_guid: xxxx-xxxx-xxxx
+solved_section_guid: xxxx-xxxx-xxxx
+```
+
+## Requirements
+
+- Python 3.9+
+- A running [Boring Agents](https://github.com/anhbinhnguyen/boring-agents) server
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/anhbinhnguyen/boring-cli.git
+cd boring-cli
+
+# Install in development mode
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black src/
+ruff check src/
+```
+
+## License
+
+MIT

boring_cli-0.1.1/README.md

@@ -0,0 +1,116 @@
+# Boring CLI
+
+[![PyPI version](https://badge.fury.io/py/boring-cli.svg)](https://badge.fury.io/py/boring-cli)
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+CLI tool for managing Lark Suite tasks from the command line.
+
+## Installation
+
+```bash
+pip install boring-cli
+```
+
+## Quick Start
+
+### 1. Setup
+
+Configure the CLI and login to Lark:
+
+```bash
+boring setup
+```
+
+This will prompt you for:
+- Server URL (your Boring Agents API server)
+- Bugs output directory (where tasks will be downloaded)
+- Lark task list GUIDs
+- Lark OAuth login
+
+### 2. Download Tasks
+
+Download tasks with Critical/Blocked/High labels to your local folder:
+
+```bash
+boring download
+```
+
+Download with specific labels:
+
+```bash
+boring download --labels "Critical,Blocked"
+```
+
+### 3. Solve Tasks
+
+Move completed tasks (from your bugs folder) to the Solved section in Lark:
+
+```bash
+boring solve
+```
+
+Keep local folders after solving:
+
+```bash
+boring solve --keep
+```
+
+### 4. Check Status
+
+View your current configuration:
+
+```bash
+boring status
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `boring setup` | Configure CLI and login to Lark |
+| `boring download` | Download tasks to local folder |
+| `boring solve` | Move tasks to Solved section |
+| `boring status` | Show current configuration |
+| `boring --version` | Show version |
+| `boring --help` | Show help |
+
+## Configuration
+
+Configuration is stored in `~/.boring-agents/config.yaml`:
+
+```yaml
+server_url: https://boring.omelet.tech/api
+jwt_token: eyJhbGc...
+bugs_dir: /path/to/bugs
+tasklist_guid: xxxx-xxxx-xxxx
+section_guid: xxxx-xxxx-xxxx
+solved_section_guid: xxxx-xxxx-xxxx
+```
+
+## Requirements
+
+- Python 3.9+
+- A running [Boring Agents](https://github.com/anhbinhnguyen/boring-agents) server
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/anhbinhnguyen/boring-cli.git
+cd boring-cli
+
+# Install in development mode
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+
+# Format code
+black src/
+ruff check src/
+```
+
+## License
+
+MIT

boring_cli-0.1.1/pyproject.toml

@@ -0,0 +1,66 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "boring-cli"
+version = "0.1.1"
+description = "CLI tool for managing Lark Suite tasks"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Boring Agents Team" }
+]
+keywords = ["lark", "tasks", "cli", "productivity"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Utilities",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "click>=8.0.0",
+    "httpx>=0.26.0",
+    "pyyaml>=6.0",
+    "rich>=13.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+]
+
+[project.scripts]
+boring = "boring.main:main"
+
+[project.urls]
+Homepage = "https://github.com/anhbinhnguyen/boring-cli"
+Repository = "https://github.com/anhbinhnguyen/boring-cli"
+Issues = "https://github.com/anhbinhnguyen/boring-cli/issues"
+
+[tool.hatch.build.targets.sdist]
+include = [
+    "/src",
+]
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/boring"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.black]
+line-length = 100
+target-version = ["py39"]

boring_cli-0.1.1/src/boring/__init__.py

@@ -0,0 +1,3 @@
+"""Boring CLI - Manage Lark Suite tasks from the command line."""
+
+__version__ = "0.1.0"

boring_cli-0.1.1/src/boring/client.py

@@ -0,0 +1,121 @@
+"""HTTP client for Boring Agents API."""
+
+from typing import Optional
+
+import httpx
+
+from .config import get_jwt_token, get_server_url
+
+
+class APIClient:
+    """Client for interacting with the Boring Agents API."""
+
+    def __init__(self, base_url: Optional[str] = None, token: Optional[str] = None):
+        self.base_url = base_url or get_server_url()
+        self.token = token or get_jwt_token()
+
+    def _headers(self) -> dict:
+        return {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+        }
+
+    def _check_config(self) -> None:
+        if not self.base_url:
+            raise Exception("Server URL not configured. Run 'boring setup' first.")
+        if not self.token:
+            raise Exception("Not logged in. Run 'boring setup' first.")
+
+    def get_login_url(self) -> str:
+        """Get the Lark OAuth login URL."""
+        if not self.base_url:
+            raise Exception("Server URL not configured.")
+        with httpx.Client() as client:
+            response = client.get(f"{self.base_url}/api/v1/auth/login")
+            response.raise_for_status()
+            return response.json().get("auth_url")
+
+    def complete_login(self, code: str) -> dict:
+        """Complete the OAuth login with the authorization code."""
+        if not self.base_url:
+            raise Exception("Server URL not configured.")
+        with httpx.Client() as client:
+            response = client.get(
+                f"{self.base_url}/api/v1/auth/callback", params={"code": code}
+            )
+            response.raise_for_status()
+            return response.json()
+
+    def get_me(self) -> dict:
+        """Get current user information."""
+        self._check_config()
+        with httpx.Client() as client:
+            response = client.get(
+                f"{self.base_url}/api/v1/auth/me", headers=self._headers()
+            )
+            response.raise_for_status()
+            return response.json()
+
+    def get_tasks(
+        self, labels: Optional[str] = None, section_guid: Optional[str] = None
+    ) -> dict:
+        """Get tasks with optional filters."""
+        self._check_config()
+        params = {}
+        if labels:
+            params["labels"] = labels
+        if section_guid:
+            params["section_guid"] = section_guid
+
+        with httpx.Client() as client:
+            response = client.get(
+                f"{self.base_url}/api/v1/tasks/",
+                headers=self._headers(),
+                params=params,
+            )
+            response.raise_for_status()
+            return response.json()
+
+    def get_critical_tasks(self) -> dict:
+        """Get critical and blocked tasks."""
+        self._check_config()
+        with httpx.Client() as client:
+            response = client.get(
+                f"{self.base_url}/api/v1/tasks/critical", headers=self._headers()
+            )
+            response.raise_for_status()
+            return response.json()
+
+    def download_tasks(
+        self, labels: Optional[str] = None, section_guid: Optional[str] = None
+    ) -> dict:
+        """Download tasks as markdown content."""
+        self._check_config()
+        params = {}
+        if labels:
+            params["labels"] = labels
+        if section_guid:
+            params["section_guid"] = section_guid
+
+        with httpx.Client(timeout=120) as client:
+            response = client.get(
+                f"{self.base_url}/api/v1/tasks/download",
+                headers=self._headers(),
+                params=params,
+            )
+            response.raise_for_status()
+            return response.json()
+
+    def solve_task(
+        self, task_guid: str, tasklist_guid: str, section_guid: str
+    ) -> dict:
+        """Move a task to the solved section."""
+        self._check_config()
+        with httpx.Client() as client:
+            response = client.post(
+                f"{self.base_url}/api/v1/tasks/{task_guid}/solve",
+                headers=self._headers(),
+                json={"tasklist_guid": tasklist_guid, "section_guid": section_guid},
+            )
+            response.raise_for_status()
+            return response.json()

boring_cli-0.1.1/src/boring/commands/__init__.py

@@ -0,0 +1 @@
+"""Boring CLI commands."""

boring_cli-0.1.1/src/boring/commands/download.py

@@ -0,0 +1,89 @@
+"""Download command for Boring CLI."""
+
+import base64
+import os
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from .. import config
+from ..client import APIClient
+
+console = Console()
+
+
+@click.command()
+@click.option("--labels", default=None, help="Comma-separated labels to filter")
+def download(labels: str):
+    """Download tasks from Lark and save as markdown files."""
+    if not config.is_configured():
+        console.print("[bold red]CLI not configured.[/bold red] Run 'boring setup' first.")
+        raise click.Abort()
+
+    bugs_dir = config.get_bugs_dir()
+    section_guid = config.get_section_guid()
+
+    if not bugs_dir:
+        console.print("[bold red]Bugs directory not configured.[/bold red] Run 'boring setup' first.")
+        raise click.Abort()
+
+    console.print(f"[bold]Downloading tasks to:[/bold] [cyan]{bugs_dir}[/cyan]")
+    if section_guid:
+        console.print(f"[dim]Filtering by section: {section_guid}[/dim]")
+    if labels:
+        console.print(f"[dim]Filtering by labels: {labels}[/dim]")
+
+    client = APIClient()
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task("Fetching tasks from server...", total=None)
+
+        try:
+            result = client.download_tasks(labels=labels, section_guid=section_guid)
+        except Exception as e:
+            console.print(f"[bold red]Failed to download tasks:[/bold red] {e}")
+            raise click.Abort()
+
+        progress.update(task, description="Processing tasks...")
+
+    tasks = result.get("tasks", [])
+    count = result.get("count", 0)
+
+    if count == 0:
+        console.print("[yellow]No tasks found matching criteria.[/yellow]")
+        return
+
+    console.print(f"\n[bold green]Found {count} task(s)[/bold green]\n")
+
+    os.makedirs(bugs_dir, exist_ok=True)
+
+    for i, task_data in enumerate(tasks, 1):
+        guid = task_data.get("guid")
+        summary = task_data.get("summary", "No title")[:50]
+        console.print(f"[{i}/{count}] Processing: [cyan]{summary}[/cyan]...")
+
+        task_dir = Path(bugs_dir) / guid
+        task_dir.mkdir(parents=True, exist_ok=True)
+
+        md_path = task_dir / "description.md"
+        with open(md_path, "w", encoding="utf-8") as f:
+            f.write(task_data.get("markdown_content", ""))
+
+        for img in task_data.get("images", []):
+            img_index = img.get("index", 1)
+            img_data = img.get("data")
+            if img_data:
+                img_bytes = base64.b64decode(img_data)
+                img_path = task_dir / f"image_{img_index}.jpg"
+                with open(img_path, "wb") as f:
+                    f.write(img_bytes)
+
+        console.print(f"  [dim]Saved to {task_dir}/description.md[/dim]")
+
+    console.print(f"\n[bold green]Done![/bold green] {count} task(s) saved to '{bugs_dir}/'")

boring_cli-0.1.1/src/boring/commands/setup.py

@@ -0,0 +1,132 @@
+"""Setup command for Boring CLI."""
+
+import threading
+import webbrowser
+from http.server import BaseHTTPRequestHandler, HTTPServer
+from urllib.parse import parse_qs, urlparse
+
+import click
+from rich.console import Console
+
+from .. import config
+from ..client import APIClient
+
+console = Console()
+
+
+class OAuthCallbackHandler(BaseHTTPRequestHandler):
+    """Handler for OAuth callback."""
+
+    code = None
+
+    def do_GET(self):
+        query = urlparse(self.path).query
+        params = parse_qs(query)
+        if "code" in params:
+            OAuthCallbackHandler.code = params["code"][0]
+            self.send_response(200)
+            self.send_header("Content-type", "text/html")
+            self.end_headers()
+            self.wfile.write(
+                b"""
+                <html>
+                <body style="font-family: sans-serif; text-align: center; padding: 50px;">
+                    <h1 style="color: #10B981;">Login Successful!</h1>
+                    <p>You can close this window and return to the terminal.</p>
+                </body>
+                </html>
+            """
+            )
+        else:
+            self.send_response(400)
+            self.end_headers()
+            self.wfile.write(b"Missing code parameter")
+
+    def log_message(self, format, *args):
+        pass
+
+
+@click.command()
+@click.option(
+    "--server-url",
+    prompt="Server URL",
+    default=lambda: config.get_server_url() or "https://boring.omelet.tech/api",
+    help="URL of the Boring Agents API server",
+)
+def setup(server_url: str):
+    """Configure the CLI and login to Lark."""
+    console.print("\n[bold blue]Configuring Boring CLI...[/bold blue]")
+    console.print(f"Server URL: [cyan]{server_url}[/cyan]")
+
+    config.set_server_url(server_url)
+
+    bugs_dir = click.prompt(
+        "Bugs output directory", default=config.get_bugs_dir() or "/tmp/bugs"
+    )
+    config.set_bugs_dir(bugs_dir)
+
+    tasklist_guid = click.prompt(
+        "Tasklist GUID (from Lark)", default=config.get_tasklist_guid() or ""
+    )
+    if tasklist_guid:
+        config.set_tasklist_guid(tasklist_guid)
+
+    section_guid = click.prompt(
+        "In-progress Section GUID", default=config.get_section_guid() or ""
+    )
+    if section_guid:
+        config.set_section_guid(section_guid)
+
+    solved_section_guid = click.prompt(
+        "Solved Section GUID", default=config.get_solved_section_guid() or ""
+    )
+    if solved_section_guid:
+        config.set_solved_section_guid(solved_section_guid)
+
+    console.print("\n[bold]Starting Lark OAuth login...[/bold]")
+
+    server = HTTPServer(("localhost", 9876), OAuthCallbackHandler)
+    server_thread = threading.Thread(target=server.handle_request)
+    server_thread.start()
+
+    client = APIClient()
+    try:
+        auth_url = client.get_login_url()
+        full_auth_url = auth_url + "&redirect_uri=http://localhost:9876/callback"
+        console.print("\n[yellow]Opening browser for Lark login...[/yellow]")
+        console.print(f"If browser doesn't open, visit: [link]{full_auth_url}[/link]")
+        webbrowser.open(full_auth_url)
+    except Exception as e:
+        console.print(f"\n[yellow]Note: Could not get auth URL from server: {e}[/yellow]")
+        console.print("Please complete OAuth flow manually and get the code.")
+        code = click.prompt("Enter the OAuth code")
+        OAuthCallbackHandler.code = code
+
+    if not OAuthCallbackHandler.code:
+        console.print("[dim]Waiting for OAuth callback...[/dim]")
+        server_thread.join(timeout=300)
+
+    if OAuthCallbackHandler.code:
+        try:
+            result = client.complete_login(OAuthCallbackHandler.code)
+            token = result.get("token", {}).get("access_token")
+            user = result.get("user", {})
+
+            config.set_jwt_token(token)
+
+            console.print("\n[bold green]Login successful![/bold green]")
+            console.print(
+                f"Logged in as: [cyan]{user.get('name') or user.get('email') or 'User'}[/cyan]"
+            )
+            console.print(f"\nConfiguration saved to: [dim]{config.CONFIG_FILE}[/dim]")
+        except Exception as e:
+            console.print(f"\n[bold red]Login failed: {e}[/bold red]")
+            raise click.Abort()
+    else:
+        console.print("\n[bold red]OAuth flow timed out or failed.[/bold red]")
+        raise click.Abort()
+
+    server.server_close()
+    console.print(
+        "\n[bold green]Setup complete![/bold green] You can now use 'boring download' and 'boring solve'."
+    )

boring_cli-0.1.1/src/boring/commands/solve.py

@@ -0,0 +1,82 @@
+"""Solve command for Boring CLI."""
+
+import os
+import shutil
+
+import click
+from rich.console import Console
+
+from .. import config
+from ..client import APIClient
+
+console = Console()
+
+
+def get_task_folders(bugs_dir: str) -> list:
+    """Get all task folders from the bugs directory."""
+    folders = []
+    if not os.path.exists(bugs_dir):
+        return folders
+    for name in os.listdir(bugs_dir):
+        path = os.path.join(bugs_dir, name)
+        # UUID format check
+        if os.path.isdir(path) and len(name) == 36 and name.count("-") == 4:
+            folders.append((name, path))
+    return folders
+
+
+@click.command()
+@click.option("--keep", is_flag=True, help="Keep local folders after solving")
+def solve(keep: bool):
+    """Move completed tasks to Solved section in Lark."""
+    if not config.is_configured():
+        console.print("[bold red]CLI not configured.[/bold red] Run 'boring setup' first.")
+        raise click.Abort()
+
+    bugs_dir = config.get_bugs_dir()
+    tasklist_guid = config.get_tasklist_guid()
+    solved_section_guid = config.get_solved_section_guid()
+
+    if not bugs_dir:
+        console.print("[bold red]Bugs directory not configured.[/bold red] Run 'boring setup' first.")
+        raise click.Abort()
+
+    if not tasklist_guid or not solved_section_guid:
+        console.print(
+            "[bold red]Tasklist GUID and Solved Section GUID required.[/bold red] "
+            "Run 'boring setup' first."
+        )
+        raise click.Abort()
+
+    task_folders = get_task_folders(bugs_dir)
+
+    if not task_folders:
+        console.print("[yellow]No tasks found in bugs folder.[/yellow]")
+        return
+
+    console.print(f"[bold]Found {len(task_folders)} task(s) to move to Solved[/bold]\n")
+
+    client = APIClient()
+    success_count = 0
+
+    for task_guid, folder_path in task_folders:
+        try:
+            result = client.solve_task(
+                task_guid=task_guid,
+                tasklist_guid=tasklist_guid,
+                section_guid=solved_section_guid,
+            )
+
+            if result.get("success"):
+                console.print(f"[green]OK[/green] - {task_guid}")
+                if not keep:
+                    shutil.rmtree(folder_path)
+                success_count += 1
+            else:
+                console.print(f"[red]FAIL[/red] - {task_guid}: {result.get('message')}")
+        except Exception as e:
+            console.print(f"[red]ERROR[/red] - {task_guid}: {e}")
+
+    console.print(
+        f"\n[bold green]Done![/bold green] Moved {success_count}/{len(task_folders)} task(s) to Solved."
+    )

boring_cli-0.1.1/src/boring/commands/status.py

@@ -0,0 +1,83 @@
+"""Status command for Boring CLI."""
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from .. import config
+
+console = Console()
+
+
+@click.command()
+def status():
+    """Show current configuration status."""
+    cfg = config.load_config()
+
+    table = Table(title="Boring CLI Configuration")
+    table.add_column("Setting", style="cyan")
+    table.add_column("Value", style="green")
+    table.add_column("Status", style="yellow")
+
+    # Server URL
+    server_url = cfg.get("server_url", "")
+    table.add_row(
+        "Server URL",
+        server_url or "[dim]Not set[/dim]",
+        "[green]OK[/green]" if server_url else "[red]Missing[/red]",
+    )
+
+    # JWT Token
+    jwt_token = cfg.get("jwt_token", "")
+    token_display = f"{jwt_token[:20]}..." if jwt_token else "[dim]Not set[/dim]"
+    table.add_row(
+        "JWT Token",
+        token_display,
+        "[green]OK[/green]" if jwt_token else "[red]Missing[/red]",
+    )
+
+    # Bugs Directory
+    bugs_dir = cfg.get("bugs_dir", "")
+    table.add_row(
+        "Bugs Directory",
+        bugs_dir or "[dim]Not set[/dim]",
+        "[green]OK[/green]" if bugs_dir else "[red]Missing[/red]",
+    )
+
+    # Tasklist GUID
+    tasklist_guid = cfg.get("tasklist_guid", "")
+    table.add_row(
+        "Tasklist GUID",
+        tasklist_guid or "[dim]Not set[/dim]",
+        "[green]OK[/green]" if tasklist_guid else "[yellow]Optional[/yellow]",
+    )
+
+    # Section GUID
+    section_guid = cfg.get("section_guid", "")
+    table.add_row(
+        "Section GUID",
+        section_guid or "[dim]Not set[/dim]",
+        "[green]OK[/green]" if section_guid else "[yellow]Optional[/yellow]",
+    )
+
+    # Solved Section GUID
+    solved_section_guid = cfg.get("solved_section_guid", "")
+    table.add_row(
+        "Solved Section GUID",
+        solved_section_guid or "[dim]Not set[/dim]",
+        "[green]OK[/green]" if solved_section_guid else "[yellow]Optional[/yellow]",
+    )
+
+    console.print()
+    console.print(table)
+    console.print()
+
+    if config.is_configured():
+        console.print("[bold green]CLI is properly configured![/bold green]")
+    else:
+        console.print(
+            "[bold yellow]CLI is not fully configured.[/bold yellow] "
+            "Run 'boring setup' to complete configuration."
+        )
+
+    console.print(f"\n[dim]Config file: {config.CONFIG_FILE}[/dim]")

boring_cli-0.1.1/src/boring/config.py

@@ -0,0 +1,97 @@
+"""Configuration management for Boring CLI."""
+
+import os
+from pathlib import Path
+from typing import Optional
+
+import yaml
+
+CONFIG_DIR = Path.home() / ".boring-agents"
+CONFIG_FILE = CONFIG_DIR / "config.yaml"
+
+
+def ensure_config_dir() -> None:
+    """Ensure the config directory exists."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+
+
+def load_config() -> dict:
+    """Load configuration from file."""
+    if not CONFIG_FILE.exists():
+        return {}
+    with open(CONFIG_FILE, "r") as f:
+        return yaml.safe_load(f) or {}
+
+
+def save_config(config: dict) -> None:
+    """Save configuration to file."""
+    ensure_config_dir()
+    with open(CONFIG_FILE, "w") as f:
+        yaml.dump(config, f, default_flow_style=False)
+
+
+def get_value(key: str) -> Optional[str]:
+    """Get a configuration value."""
+    return load_config().get(key)
+
+
+def set_value(key: str, value: str) -> None:
+    """Set a configuration value."""
+    config = load_config()
+    config[key] = value
+    save_config(config)
+
+
+# Convenience accessors
+def get_server_url() -> Optional[str]:
+    return get_value("server_url")
+
+
+def get_jwt_token() -> Optional[str]:
+    return get_value("jwt_token")
+
+
+def get_bugs_dir() -> Optional[str]:
+    return get_value("bugs_dir")
+
+
+def get_tasklist_guid() -> Optional[str]:
+    return get_value("tasklist_guid")
+
+
+def get_section_guid() -> Optional[str]:
+    return get_value("section_guid")
+
+
+def get_solved_section_guid() -> Optional[str]:
+    return get_value("solved_section_guid")
+
+
+def set_server_url(url: str) -> None:
+    set_value("server_url", url)
+
+
+def set_jwt_token(token: str) -> None:
+    set_value("jwt_token", token)
+
+
+def set_bugs_dir(path: str) -> None:
+    set_value("bugs_dir", path)
+
+
+def set_tasklist_guid(guid: str) -> None:
+    set_value("tasklist_guid", guid)
+
+
+def set_section_guid(guid: str) -> None:
+    set_value("section_guid", guid)
+
+
+def set_solved_section_guid(guid: str) -> None:
+    set_value("solved_section_guid", guid)
+
+
+def is_configured() -> bool:
+    """Check if the CLI is properly configured."""
+    config = load_config()
+    return all([config.get("server_url"), config.get("jwt_token"), config.get("bugs_dir")])

boring_cli-0.1.1/src/boring/main.py

@@ -0,0 +1,39 @@
+"""Main entry point for Boring CLI."""
+
+import click
+
+from . import __version__
+from .commands.download import download
+from .commands.setup import setup
+from .commands.solve import solve
+from .commands.status import status
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="boring")
+def cli():
+    """Boring CLI - Manage Lark tasks from the command line.
+
+    \b
+    Quick start:
+      boring setup      Configure and login to Lark
+      boring download   Download tasks to local folder
+      boring solve      Move completed tasks to Solved
+      boring status     Show current configuration
+    """
+    pass
+
+
+cli.add_command(setup)
+cli.add_command(download)
+cli.add_command(solve)
+cli.add_command(status)
+
+
+def main():
+    """Main entry point."""
+    cli()
+
+
+if __name__ == "__main__":
+    main()