brandly-cli 0.3.2__tar.gz → 0.3.4__tar.gz

brandly_cli-0.3.4/.github/workflows/ci.yml

@@ -0,0 +1,71 @@
+name: CI
+
+on:
+  pull_request:
+    types: [opened, synchronize, reopened]
+  push:
+    branches: [main]
+
+# Cancel superseded runs on the same ref (for PRs); keep main runs to
+# avoid clobbering a long build when a new commit lands mid-run.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+jobs:
+  quality:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install FFmpeg
+        run: sudo apt-get update && sudo apt-get install -y ffmpeg
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]" build twine
+
+      - name: Lint
+        run: ruff check src/ tests/
+
+      - name: Type check
+        run: mypy src/
+
+      - name: Syntax check
+        run: python -m py_compile src/brandly_cli/*.py
+
+      - name: Run tests
+        run: |
+          python -m pytest tests/ -v --tb=short \
+            --cov=brandly_cli --cov-report=xml --cov-report=term-missing
+
+      - name: Build package
+        run: python -m build
+
+      - name: Check build
+        run: python -m twine check dist/*
+
+      - name: Upload dist
+        if: ${{ matrix.python-version == '3.12' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+          if-no-files-found: error
+
+      - name: Upload coverage
+        if: ${{ matrix.python-version == '3.12' }}
+        uses: actions/upload-artifact@v4
+        with:
+          name: coverage
+          path: coverage.xml
+          if-no-files-found: warn

{brandly_cli-0.3.2 → brandly_cli-0.3.4}/.github/workflows/release.yml

@@ -29,5 +29,15 @@ jobs:
       - name: Build package
         run: python -m build
 
+      - name: Check build
+        run: python -m twine check dist/*
+
+      - name: Upload dist
+        uses: actions/upload-artifact@v4
+        with:
+          name: dist-${{ github.event.release.tag_name }}
+          path: dist/
+          if-no-files-found: error
+
       - name: Release to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1

{brandly_cli-0.3.2 → brandly_cli-0.3.4}/.gitignore

@@ -48,3 +48,5 @@ skills_output/
 
 # Pre-commit
 .pre-commit-cache/
+.agnes/
+debates/

{brandly_cli-0.3.2 → brandly_cli-0.3.4}/.pre-commit-config.yaml

@@ -3,7 +3,7 @@ repos:
     hooks:
       - id: ruff-lint
         name: ruff-lint
-        entry: python3 -m ruff check src/
+        entry: python3 -m ruff check src/ tests/
         language: system
         types: [python]
         pass_filenames: false

brandly_cli-0.3.4/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dream Pixels Forge
+
+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.

{brandly_cli-0.3.2 → brandly_cli-0.3.4}/Makefile

@@ -1,14 +1,14 @@
 # Brandly CLI — Makefile
 
 PYTHON   := python3
-PNPM     := pnpm
 PIP      := $(PYTHON) -m pip
 PYTEST   := $(PYTHON) -m pytest
 RUFF     := $(PYTHON) -m ruff
+MYPY     := $(PYTHON) -m mypy
 ROOT     ?= .
 
-.PHONY: help install dev test lint type-check build clean \
-        pre-commit ci e2e upgrade sync
+.PHONY: help install dev test cov lint lint-fix check-syntax type-check \
+        build clean pre-commit ci e2e upgrade sync
 
 ## Show this help
 help:
@@ -19,6 +19,10 @@ help:
 install: ## install
 	$(PIP) install -e ".[dev]"
 
+## Install full dev environment (package + build tooling, mirrors CI)
+dev: ## dev
+	$(PIP) install -e ".[dev]" build twine
+
 ## Install pre-commit hooks
 pre-commit: ## pre-commit
 	$(PIP) install pre-commit
@@ -34,18 +38,27 @@ cov: ## cov
 
 ## Run linter
 lint: ## lint
-	$(RUFF) check src/
+	$(RUFF) check src/ tests/
 
 ## Fix lint issues automatically
 lint-fix: ## lint-fix
-	$(RUFF) check src/ --fix
+	$(RUFF) check src/ tests/ --fix
+
+## Type check
+type-check: ## type-check
+	$(MYPY) src/
 
 ## Syntax check all modules
 check-syntax: ## check-syntax
 	$(PYTHON) -m py_compile src/brandly_cli/*.py
 
-## Run all quality gates (test + lint + syntax)
-ci: check-syntax lint test ## ci
+## Build sdist + wheel (run 'make dev' first to install build/twine)
+build: ## build
+	$(PYTHON) -m build
+	$(PYTHON) -m twine check dist/*
+
+## Run all quality gates (lint + type-check + test + build)
+ci: lint type-check test build ## ci
 	@echo "All quality gates passed."
 
 ## End-to-end CLI smoke test

{brandly_cli-0.3.2 → brandly_cli-0.3.4}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.5
 Name: brandly-cli
-Version: 0.3.2
+Version: 0.3.4
 Summary: AI product video orchestrator — add image, video, and sound generation to any AI tool
 Project-URL: Homepage, https://github.com/Dream-Pixels-Forge/brandly-cli
 Project-URL: Repository, https://github.com/Dream-Pixels-Forge/brandly-cli
 Project-URL: Issues, https://github.com/Dream-Pixels-Forge/brandly-cli/issues
 Author-email: Dream Pixels Forge <contact@dreampixelsforge.com>
 License-Expression: MIT
+License-File: LICENSE
 Keywords: agent,ai,cli,generation,image,orchestrator,video
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers

{brandly_cli-0.3.2 → brandly_cli-0.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "brandly-cli"
-version = "0.3.2"
+version = "0.3.4"
 description = "AI product video orchestrator — add image, video, and sound generation to any AI tool"
 readme = "README.md"
 license = "MIT"

{brandly_cli-0.3.2 → brandly_cli-0.3.4}/src/brandly_cli/__about__.py

@@ -1,3 +1,3 @@
 """Package metadata."""
 
-__version__ = "0.3.2"
+__version__ = "0.3.4"

brandly_cli-0.3.4/src/brandly_cli/agent_tools.py

@@ -0,0 +1,312 @@
+"""Built-in tool handlers for the Agnes AI agent loop.
+
+Each tool is a Python callable that takes only JSON-serializable arguments
+and returns a JSON-serializable result. The tool *descriptor* (name + JSON
+schema) is exposed to the Agnes model via the OpenAI-compatible
+``tools`` field, and this module provides the handler that actually
+executes it on the client side.
+
+Tools are intentionally small and read-only: they mirror the state the
+brandly CLI already exposes (project data, Agnes jobs, model catalog)
+so an agent can answer questions like "which projects have failed
+videos?" without any new user input.
+"""
+
+from __future__ import annotations
+
+import json
+from collections.abc import Awaitable, Callable
+from pathlib import Path
+from typing import Any
+
+from rich.console import Console
+
+console = Console()
+
+# ---------------------------------------------------------------------------
+# Tool handler type
+#
+# A handler is a function (sync or async) that takes keyword arguments and
+# returns a JSON-serializable value.  ``agent_tool_loop`` will await the
+# result if it's a coroutine, and stringify non-strings with ``json.dumps``.
+# ---------------------------------------------------------------------------
+
+ToolHandler = Callable[..., Any] | Callable[..., Awaitable[Any]]
+
+
+# ---------------------------------------------------------------------------
+# Tool: list_projects
+# ---------------------------------------------------------------------------
+
+def _list_projects(
+    status: str | None = None,
+    limit: int = 20,
+    root: str | None = None,
+) -> dict[str, Any]:
+    """List brandly projects on disk, optionally filtered by status."""
+    import asyncio
+
+    try:
+        from brandly_cli.project_manager import ProjectManager
+
+        pm = ProjectManager(Path(root or "."))
+        projects = asyncio.run(pm.list_with_status())
+        if status:
+            projects = [p for p in projects if p.get("status") == status]
+        projects = projects[:limit]
+        return {
+            "count": len(projects),
+            "projects": [
+                {
+                    "id": p.get("id", ""),
+                    "name": p.get("name", ""),
+                    "status": p.get("status", ""),
+                    "updated_at": p.get("updated_at", ""),
+                }
+                for p in projects
+            ],
+        }
+    except Exception as e:  # pragma: no cover - safety net
+        return {"error": f"list_projects: {e}"}
+
+
+# ---------------------------------------------------------------------------
+# Tool: get_project
+# ---------------------------------------------------------------------------
+
+def _get_project(project_id: str, root: str | None = None) -> dict[str, Any]:
+    """Fetch a single project by ID from the project manager."""
+    import asyncio
+
+    try:
+        from brandly_cli.project_manager import ProjectManager
+
+        pm = ProjectManager(Path(root or "."))
+        data = asyncio.run(pm.read(project_id))
+        if not data:
+            return {"error": f"project {project_id} not found"}
+        model_dump = getattr(data, "model_dump", None)
+        return model_dump() if callable(model_dump) else {"id": project_id}
+    except Exception as e:
+        return {"error": f"get_project: {e}"}
+
+
+# ---------------------------------------------------------------------------
+# Tool: list_jobs (Agnes video jobs)
+# ---------------------------------------------------------------------------
+
+def _list_jobs(
+    status: str | None = None,
+    limit: int = 10,
+) -> dict[str, Any]:
+    """List recent Agnes video-generation jobs (read-only)."""
+    import asyncio
+
+    try:
+        from brandly_cli.agnes_client import list_jobs
+
+        return {"jobs": asyncio.run(list_jobs(status=status, limit=limit))}
+    except Exception as e:
+        return {"error": f"list_jobs: {e}"}
+
+
+# ---------------------------------------------------------------------------
+# Tool: generate_image
+# ---------------------------------------------------------------------------
+
+def _generate_image(
+    prompt: str,
+    model: str = "agnes-image-2.5-flash",
+    size: str = "2K",
+    ratio: str = "16:9",
+) -> dict[str, Any]:
+    """Generate a single Agnes image.  Synchronous wrapper over async."""
+    import asyncio
+
+    try:
+        from brandly_cli.agnes_client import generate_image
+
+        return asyncio.run(
+            generate_image(prompt, model=model, size=size, ratio=ratio)
+        )
+    except Exception as e:
+        return {"error": f"generate_image: {e}"}
+
+
+# ---------------------------------------------------------------------------
+# Tool: list_models
+# ---------------------------------------------------------------------------
+
+def _list_models(category: str | None = None) -> dict[str, Any]:
+    """List available model IDs across image / video / audio / text."""
+    try:
+        from brandly_cli.constants import get_all_models
+
+        all_models = get_all_models()
+        if category and category in all_models:
+            return {"category": category, "models": all_models[category]}
+        return all_models
+    except Exception as e:
+        return {"error": f"list_models: {e}"}
+
+
+# ---------------------------------------------------------------------------
+# Tool registry
+# ---------------------------------------------------------------------------
+
+BUILTIN_TOOLS: dict[str, dict[str, Any]] = {
+    "list_projects": {
+        "handler": _list_projects,
+        "schema": {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "string",
+                    "description": (
+                        "Optional status filter (e.g. pending, running, failed)."
+                    ) ,
+                },
+                "limit": {
+                    "type": "integer",
+                    "default": 20,
+                    "description": "Max projects to return.",
+                },
+                "root": {
+                    "type": "string",
+                    "description": "Project root directory (defaults to cwd).",
+                },
+            },
+        },
+        "description": "List brandly projects on disk, optionally filtered by status.",
+    },
+    "get_project": {
+        "handler": _get_project,
+        "schema": {
+            "type": "object",
+            "properties": {
+                "project_id": {
+                    "type": "string",
+                    "description": "UUID or slug of the project to fetch.",
+                },
+                "root": {
+                    "type": "string",
+                    "description": "Project root directory.",
+                },
+            },
+            "required": ["project_id"],
+        },
+        "description": "Fetch a single project by ID, including phases and cost tracking.",
+    },
+    "list_jobs": {
+        "handler": _list_jobs,
+        "schema": {
+            "type": "object",
+            "properties": {
+                "status": {
+                    "type": "string",
+                    "description": "Optional status filter.",
+                },
+                "limit": {
+                    "type": "integer",
+                    "default": 10,
+                },
+            },
+        },
+        "description": "List recent Agnes video-generation jobs (read-only).",
+    },
+    "generate_image": {
+        "handler": _generate_image,
+        "schema": {
+            "type": "object",
+            "properties": {
+                "prompt": {
+                    "type": "string",
+                    "description": "Text description of the image to generate.",
+                },
+                "model": {
+                    "type": "string",
+                    "default": "agnes-image-2.5-flash",
+                    "description": "Agnes image model ID.",
+                },
+                "size": {
+                    "type": "string",
+                    "default": "2K",
+                    "description": "Image size tier (1K/2K/3K/4K).",
+                },
+                "ratio": {
+                    "type": "string",
+                    "default": "16:9",
+                    "description": "Aspect ratio (16:9, 9:16, 1:1, 4:3, 4:5).",
+                },
+            },
+            "required": ["prompt"],
+        },
+        "description": "Generate a single Agnes image from a text prompt.",
+    },
+    "list_models": {
+        "handler": _list_models,
+        "schema": {
+            "type": "object",
+            "properties": {
+                "category": {
+                    "type": "string",
+                    "enum": ["image", "video", "audio"],
+                    "description": "Optional category filter.",
+                },
+            },
+        },
+        "description": "List available model IDs and metadata across image/video/audio.",
+    },
+}
+
+
+def get_builtin_tools() -> list[tuple[str, ToolHandler, dict[str, Any], str]]:
+    """Return the list of (name, handler, json_schema, description) tuples
+    expected by ``agent_tool_loop`` in ``agnes_client``.
+
+    The OpenAI-compatible ``tools`` payload requires:
+        {"type": "function", "function": {"name": ..., "description": ..., "parameters": {...}}}
+    so each entry is pre-shaped to drop in as-is.
+    """
+    out: list[tuple[str, ToolHandler, dict[str, Any], str]] = []
+    for name, spec in BUILTIN_TOOLS.items():
+        out.append((name, spec["handler"], spec["schema"], spec["description"]))
+    return out
+
+
+def describe_tools() -> dict[str, Any]:
+    """Human-readable summary of the built-in tool set, for CLI help."""
+    return {
+        name: {
+            "description": spec["description"],
+            "parameters": spec["schema"],
+        }
+        for name, spec in BUILTIN_TOOLS.items()
+    }
+
+
+def invoke_tool(name: str, **kwargs: Any) -> Any:
+    """Invoke a named built-in tool with keyword args.
+
+    Returns the raw handler result (dict, list, str, …). Callers in
+    ``agent_tool_loop`` will JSON-stringify non-string results.
+    """
+    if name not in BUILTIN_TOOLS:
+        raise KeyError(f"Unknown tool: {name}. Available: {list(BUILTIN_TOOLS)}")
+    handler = BUILTIN_TOOLS[name]["handler"]
+    return handler(**kwargs)
+
+
+# ---------------------------------------------------------------------------
+# JSON helpers
+# ---------------------------------------------------------------------------
+
+
+def to_json(value: Any) -> str:
+    """Stringify a tool result for feeding back to the LLM."""
+    if isinstance(value, str):
+        return value
+    try:
+        return json.dumps(value, default=str, ensure_ascii=False)
+    except (TypeError, ValueError):
+        return str(value)