cf-agent 0.1.0__tar.gz

cf_agent-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+*.pyo
+*.pyd
+*.so
+*.egg-info/
+dist/
+build/
+.venv/
+.env
+.DS_Store

cf_agent-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 CF Agent Maintainers
+
+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.

cf_agent-0.1.0/PKG-INFO

@@ -0,0 +1,75 @@
+Metadata-Version: 2.4
+Name: cf-agent
+Version: 0.1.0
+Summary: AI agent for Adobe AEM Content Fragments
+Project-URL: Homepage, https://github.com/your-org/cf-agent
+Project-URL: Repository, https://github.com/your-org/cf-agent
+Project-URL: Issues, https://github.com/your-org/cf-agent/issues
+Author: CF Agent Maintainers
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: httpx>=0.27.0
+Description-Content-Type: text/markdown
+
+# cf-agent
+
+AI agent CLI for managing Adobe AEM Content Fragments with natural language.
+
+## Features
+
+- Chat-driven operations for content fragments
+- Login command to configure Adobe and Anthropic credentials
+- Non-interactive mode for scripting (`--message`)
+
+## Installation
+
+Install from PyPI (after publishing):
+
+```bash
+pip install cf-agent
+```
+
+Install from a local wheel:
+
+```bash
+pip install dist/cf_agent-0.1.0-py3-none-any.whl
+```
+
+## Usage
+
+```bash
+cf-agent login
+cf-agent chat
+```
+
+Run a single command non-interactively:
+
+```bash
+cf-agent chat --message "list fragments in /content/dam/my-project"
+```
+
+## Development Build
+
+```bash
+python -m pip install --upgrade build
+python -m build
+```
+
+Generated artifacts will be in `dist/`.
+
+## License
+
+MIT
+# aem-cs-cli

cf_agent-0.1.0/README.md

@@ -0,0 +1,50 @@
+# cf-agent
+
+AI agent CLI for managing Adobe AEM Content Fragments with natural language.
+
+## Features
+
+- Chat-driven operations for content fragments
+- Login command to configure Adobe and Anthropic credentials
+- Non-interactive mode for scripting (`--message`)
+
+## Installation
+
+Install from PyPI (after publishing):
+
+```bash
+pip install cf-agent
+```
+
+Install from a local wheel:
+
+```bash
+pip install dist/cf_agent-0.1.0-py3-none-any.whl
+```
+
+## Usage
+
+```bash
+cf-agent login
+cf-agent chat
+```
+
+Run a single command non-interactively:
+
+```bash
+cf-agent chat --message "list fragments in /content/dam/my-project"
+```
+
+## Development Build
+
+```bash
+python -m pip install --upgrade build
+python -m build
+```
+
+Generated artifacts will be in `dist/`.
+
+## License
+
+MIT
+# aem-cs-cli

cf_agent-0.1.0/cf_agent/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

cf_agent-0.1.0/cf_agent/agent.py

@@ -0,0 +1,147 @@
+"""CLI entry point and agent loop."""
+
+import json
+import click
+import anthropic
+
+from . import config as cfg_module
+from . import tools
+
+SYSTEM = """\
+You are a helpful assistant for managing Adobe AEM Content Fragments.
+You have tools to list, search, get, create, update, delete, publish, and copy fragments,
+as well as list models and variations.
+
+Rules:
+- Always confirm before deleting or bulk-publishing unless the user already confirmed
+- When updating or deleting, always call get_fragment first to obtain the current ETag
+- Summarise results concisely — show counts and key fields, not raw JSON, unless asked
+- For bulk results show the first 5 and summarise the rest
+- If an API call returns an error, explain it clearly in plain English
+"""
+
+
+def _agent_loop(cfg: dict, user_input: str, messages: list) -> list:
+    """Run one user turn through the agentic loop. Returns updated messages."""
+    client = anthropic.Anthropic()
+    messages.append({"role": "user", "content": user_input})
+
+    while True:
+        response = client.messages.create(
+            model="claude-sonnet-4-6",
+            max_tokens=4096,
+            system=SYSTEM,
+            tools=tools.DEFINITIONS,
+            messages=messages,
+        )
+
+        text_parts = [b.text for b in response.content if hasattr(b, "text")]
+        tool_calls = [b for b in response.content if b.type == "tool_use"]
+
+        if text_parts:
+            click.echo(f"\nAgent: {''.join(text_parts)}\n")
+
+        if not tool_calls or response.stop_reason == "end_turn":
+            break
+
+        messages.append({"role": "assistant", "content": response.content})
+
+        tool_results = []
+        for tc in tool_calls:
+            click.echo(f"  ↳ {tc.name}({json.dumps(tc.input, separators=(',', ':'))})")
+            try:
+                result = tools.HANDLERS[tc.name](cfg, **tc.input)
+            except Exception as exc:
+                result = {"error": str(exc)}
+            tool_results.append({
+                "type": "tool_result",
+                "tool_use_id": tc.id,
+                "content": json.dumps(result),
+            })
+
+        messages.append({"role": "user", "content": tool_results})
+
+    return messages
+
+
+# ── CLI commands ───────────────────────────────────────────────────────────────
+
+@click.group()
+def cli():
+    """Content Fragment AI Agent — manage Adobe AEM fragments with natural language."""
+
+
+@cli.command()
+def login():
+    """Configure your Adobe and Anthropic credentials."""
+    click.echo("Enter your credentials (press Enter to keep existing value):\n")
+
+    existing = cfg_module._parse_dotenv(cfg_module.CONFIG_FILE)
+
+    fields = {
+        "ADOBE_CLIENT_ID": "Adobe Client ID",
+        "ADOBE_CLIENT_SECRET": "Adobe Client Secret",
+        "ADOBE_IMS_TOKEN_URL": "Adobe IMS Token URL",
+        "ADOBE_SITES_API_BASE_URL": "Adobe Sites API Base URL",
+        "ADOBE_SCOPES": "Adobe Scopes",
+        "ANTHROPIC_API_KEY": "Anthropic API Key",
+    }
+
+    defaults = {
+        "ADOBE_IMS_TOKEN_URL": "https://ims-na1.adobelogin.com/ims/token/v3",
+        "ADOBE_SCOPES": "openid,AdobeID,aem.fragments.management,aem.folders",
+    }
+
+    values = {}
+    for key, label in fields.items():
+        current = existing.get(key, defaults.get(key, ""))
+        prompt = f"{label}"
+        if current:
+            display = current[:6] + "..." if len(current) > 8 else current
+            prompt += f" [{display}]"
+        value = click.prompt(prompt, default=current, show_default=False)
+        values[key] = value.strip()
+
+    cfg_module.save(values)
+    click.echo(f"\nCredentials saved to {cfg_module.CONFIG_FILE}")
+    click.echo("Run `cf-agent chat` to start.")
+
+
+@cli.command()
+@click.option("--message", "-m", default=None, help="Run a single message non-interactively.")
+def chat(message):
+    """Start an interactive chat session with the Content Fragment agent."""
+    cfg = cfg_module.load()
+    messages = []
+
+    if message:
+        # Non-interactive: run one message and exit (useful for scripting)
+        _agent_loop(cfg, message, messages)
+        return
+
+    click.echo("Content Fragment Agent — type 'quit' to exit.\n")
+
+    while True:
+        try:
+            user_input = click.prompt("You", prompt_suffix=": ").strip()
+        except (click.exceptions.Abort, EOFError):
+            click.echo("\nGoodbye.")
+            break
+
+        if user_input.lower() in ("quit", "exit", "q"):
+            click.echo("Goodbye.")
+            break
+        if not user_input:
+            continue
+
+        messages = _agent_loop(cfg, user_input, messages)
+
+
+# Allow `cf-agent` with no subcommand to start chat directly
+@cli.result_callback()
+def _default(*args, **kwargs):
+    pass
+
+
+if __name__ == "__main__":
+    cli()

cf_agent-0.1.0/cf_agent/auth.py

@@ -0,0 +1,32 @@
+"""Adobe IMS token management with in-memory caching."""
+
+import time
+import httpx
+
+_cache: dict = {"token": None, "expires_at": 0.0}
+
+
+def get_token(cfg: dict) -> str:
+    """Return a valid access token, fetching a fresh one when expired."""
+    if _cache["token"] and time.time() < _cache["expires_at"] - 60:
+        return _cache["token"]
+
+    resp = httpx.post(
+        cfg["ADOBE_IMS_TOKEN_URL"],
+        data={
+            "client_id": cfg["ADOBE_CLIENT_ID"],
+            "client_secret": cfg["ADOBE_CLIENT_SECRET"],
+            "grant_type": "client_credentials",
+            "scope": cfg["ADOBE_SCOPES"],
+        },
+        timeout=30,
+    )
+    resp.raise_for_status()
+    data = resp.json()
+
+    if "access_token" not in data:
+        raise RuntimeError(f"Token fetch failed: {data}")
+
+    _cache["token"] = data["access_token"]
+    _cache["expires_at"] = time.time() + data.get("expires_in", 86400)
+    return _cache["token"]

cf_agent-0.1.0/cf_agent/client.py

@@ -0,0 +1,27 @@
+"""Thin authenticated HTTP client for the Adobe Sites API."""
+
+import httpx
+from .auth import get_token
+
+
+def request(cfg: dict, method: str, path: str, content_type: str = "application/json", **kwargs) -> dict:
+    """Make an authenticated call to the Adobe Sites API."""
+    headers = {
+        "Authorization": f"Bearer {get_token(cfg)}",
+        "Accept": "application/json",
+        **kwargs.pop("headers", {}),
+    }
+    if method in ("POST", "PUT", "PATCH"):
+        headers["Content-Type"] = content_type
+
+    resp = httpx.request(
+        method,
+        f"{cfg['ADOBE_SITES_API_BASE_URL']}{path}",
+        headers=headers,
+        timeout=30,
+        **kwargs,
+    )
+
+    if resp.status_code == 204 or not resp.content:
+        return {"status": "success", "message": "Operation completed successfully"}
+    return resp.json()

cf_agent-0.1.0/cf_agent/config.py

@@ -0,0 +1,74 @@
+"""
+Config loader. Reads credentials in this priority order:
+  1. Environment variables
+  2. ~/.cf-agent/config  (written by `cf-agent login`)
+  3. .env in current working directory
+"""
+
+import os
+from pathlib import Path
+
+REQUIRED = [
+    "ADOBE_CLIENT_ID",
+    "ADOBE_CLIENT_SECRET",
+    "ADOBE_IMS_TOKEN_URL",
+    "ADOBE_SITES_API_BASE_URL",
+    "ADOBE_SCOPES",
+    "ANTHROPIC_API_KEY",
+]
+
+CONFIG_DIR = Path.home() / ".cf-agent"
+CONFIG_FILE = CONFIG_DIR / "config"
+
+
+def _parse_dotenv(path: Path) -> dict:
+    result = {}
+    try:
+        with open(path) as f:
+            for line in f:
+                line = line.strip().rstrip("\r")
+                if not line or line.startswith("#"):
+                    continue
+                key, _, value = line.partition("=")
+                result[key.strip()] = value.strip()
+    except FileNotFoundError:
+        pass
+    return result
+
+
+def load() -> dict:
+    """Return a config dict, merging all sources. Raises if required keys are missing."""
+    merged = {}
+
+    # Lowest priority: .env in cwd
+    merged.update(_parse_dotenv(Path.cwd() / ".env"))
+
+    # Mid priority: ~/.cf-agent/config
+    merged.update(_parse_dotenv(CONFIG_FILE))
+
+    # Highest priority: real environment variables
+    for key in REQUIRED:
+        if key in os.environ:
+            merged[key] = os.environ[key]
+
+    missing = [k for k in REQUIRED if not merged.get(k)]
+    if missing:
+        raise SystemExit(
+            f"Missing configuration: {', '.join(missing)}\n"
+            "Run `cf-agent login` to set up your credentials."
+        )
+
+    # Inject into os.environ so the Anthropic SDK picks up ANTHROPIC_API_KEY
+    os.environ.setdefault("ANTHROPIC_API_KEY", merged["ANTHROPIC_API_KEY"])
+
+    return merged
+
+
+def save(values: dict) -> None:
+    """Persist credentials to ~/.cf-agent/config."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.chmod(0o700) if CONFIG_FILE.exists() else None
+    with open(CONFIG_FILE, "w") as f:
+        for k, v in values.items():
+            f.write(f"{k}={v}\n")
+    CONFIG_FILE.chmod(0o600)

cf_agent-0.1.0/cf_agent/tools.py

@@ -0,0 +1,233 @@
+"""Tool definitions and handlers for the Content Fragment agent."""
+
+import json
+import urllib.parse
+from . import client as api_client
+
+
+# ── Handlers ───────────────────────────────────────────────────────────────────
+
+def list_fragments(cfg, path=None, limit=20, projection="summary"):
+    params = {"limit": min(limit, 50), "projection": projection}
+    if path:
+        params["path"] = path
+    return api_client.request(cfg, "GET", "/cf/fragments", params=params)
+
+
+def get_fragment(cfg, fragment_id):
+    return api_client.request(cfg, "GET", f"/cf/fragments/{fragment_id}")
+
+
+def search_fragments(cfg, query_filter, limit=20, projection="summary"):
+    query = urllib.parse.quote(json.dumps({"filter": query_filter}))
+    params = {"query": query, "limit": min(limit, 50), "projection": projection}
+    return api_client.request(cfg, "GET", "/cf/fragments/search", params=params)
+
+
+def create_fragment(cfg, title, model_id, parent_path, description=None, fields=None):
+    body = {"title": title, "modelId": model_id, "parentPath": parent_path}
+    if description:
+        body["description"] = description
+    if fields:
+        body["fields"] = fields
+    return api_client.request(cfg, "POST", "/cf/fragments", json=body)
+
+
+def update_fragment(cfg, fragment_id, etag, patch_ops):
+    return api_client.request(
+        cfg,
+        "PATCH",
+        f"/cf/fragments/{fragment_id}",
+        json=patch_ops,
+        headers={"If-Match": etag},
+        content_type="application/json-patch+json",
+    )
+
+
+def delete_fragment(cfg, fragment_id, etag):
+    return api_client.request(
+        cfg, "DELETE", f"/cf/fragments/{fragment_id}", headers={"If-Match": etag}
+    )
+
+
+def publish_fragments(cfg, ids=None, paths=None):
+    body = {"filterReferencesByStatus": ["DRAFT", "MODIFIED"]}
+    if ids:
+        body["ids"] = ids
+    if paths:
+        body["paths"] = paths
+    return api_client.request(cfg, "POST", "/cf/fragments/publish", json=body)
+
+
+def list_models(cfg, limit=20, projection="summary"):
+    return api_client.request(
+        cfg, "GET", "/cf/models", params={"limit": min(limit, 50), "projection": projection}
+    )
+
+
+def list_variations(cfg, fragment_id):
+    return api_client.request(cfg, "GET", f"/cf/fragments/{fragment_id}/variations")
+
+
+def copy_fragment(cfg, fragment_id, parent_path, name=None):
+    body = {"parentPath": parent_path}
+    if name:
+        body["name"] = name
+    return api_client.request(cfg, "POST", f"/cf/fragments/{fragment_id}/copy", json=body)
+
+
+# ── Tool definitions (Anthropic format) ───────────────────────────────────────
+
+DEFINITIONS = [
+    {
+        "name": "list_fragments",
+        "description": "List content fragments, optionally filtered by a DAM path.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "DAM path prefix, e.g. /content/dam/marketplace"},
+                "limit": {"type": "integer", "default": 20, "description": "Max results (1-50)"},
+                "projection": {"type": "string", "enum": ["minimal", "summary", "full"], "default": "summary"},
+            },
+        },
+    },
+    {
+        "name": "get_fragment",
+        "description": "Get full details of a content fragment by UUID. Always call this before updating or deleting to obtain the current ETag.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "fragment_id": {"type": "string", "description": "The UUID of the content fragment"},
+            },
+            "required": ["fragment_id"],
+        },
+    },
+    {
+        "name": "search_fragments",
+        "description": "Search fragments using filters: status, model, path, or full text.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "query_filter": {
+                    "type": "object",
+                    "description": (
+                        "Filter criteria. Supported keys: "
+                        "path (string), "
+                        "status (array: NEW|DRAFT|PUBLISHED|MODIFIED|UNPUBLISHED), "
+                        "modelIds (array of base64 model IDs), "
+                        "fullText ({text: string, queryMode: AS_IS|EXACT_WORDS|EXACT_PHRASE})"
+                    ),
+                },
+                "limit": {"type": "integer", "default": 20},
+                "projection": {"type": "string", "enum": ["minimal", "summary", "full"], "default": "summary"},
+            },
+            "required": ["query_filter"],
+        },
+    },
+    {
+        "name": "create_fragment",
+        "description": "Create a new content fragment under a DAM folder.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "title": {"type": "string"},
+                "model_id": {"type": "string", "description": "Base64-encoded model ID (use list_models to find it)"},
+                "parent_path": {"type": "string", "description": "Parent folder, e.g. /content/dam/marketplace"},
+                "description": {"type": "string"},
+                "fields": {
+                    "type": "array",
+                    "description": "Initial field values, e.g. [{name: 'title', type: 'text', values: ['Hello']}]",
+                },
+            },
+            "required": ["title", "model_id", "parent_path"],
+        },
+    },
+    {
+        "name": "update_fragment",
+        "description": "Update a fragment using JSON Patch operations. Call get_fragment first to get the ETag.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "fragment_id": {"type": "string"},
+                "etag": {"type": "string", "description": "ETag from get_fragment"},
+                "patch_ops": {
+                    "type": "array",
+                    "description": "JSON Patch ops, e.g. [{op: 'replace', path: '/title', value: 'New Title'}]",
+                },
+            },
+            "required": ["fragment_id", "etag", "patch_ops"],
+        },
+    },
+    {
+        "name": "delete_fragment",
+        "description": "Delete a content fragment. Must not be PUBLISHED. Call get_fragment first to get the ETag.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "fragment_id": {"type": "string"},
+                "etag": {"type": "string"},
+            },
+            "required": ["fragment_id", "etag"],
+        },
+    },
+    {
+        "name": "publish_fragments",
+        "description": "Publish one or more content fragments by UUID or DAM path.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "ids": {"type": "array", "items": {"type": "string"}, "description": "Fragment UUIDs"},
+                "paths": {"type": "array", "items": {"type": "string"}, "description": "Fragment DAM paths"},
+            },
+        },
+    },
+    {
+        "name": "list_models",
+        "description": "List available content fragment models. Use this to find model IDs when creating fragments.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "limit": {"type": "integer", "default": 20},
+                "projection": {"type": "string", "enum": ["minimal", "summary", "full"], "default": "summary"},
+            },
+        },
+    },
+    {
+        "name": "list_variations",
+        "description": "List all variations of a content fragment.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "fragment_id": {"type": "string"},
+            },
+            "required": ["fragment_id"],
+        },
+    },
+    {
+        "name": "copy_fragment",
+        "description": "Copy a content fragment to a different DAM folder.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "fragment_id": {"type": "string", "description": "UUID of the fragment to copy"},
+                "parent_path": {"type": "string", "description": "Destination folder path"},
+                "name": {"type": "string", "description": "Optional new name for the copy"},
+            },
+            "required": ["fragment_id", "parent_path"],
+        },
+    },
+]
+
+# Maps tool name → handler function (cfg is injected by the agent loop)
+HANDLERS = {
+    "list_fragments": list_fragments,
+    "get_fragment": get_fragment,
+    "search_fragments": search_fragments,
+    "create_fragment": create_fragment,
+    "update_fragment": update_fragment,
+    "delete_fragment": delete_fragment,
+    "publish_fragments": publish_fragments,
+    "list_models": list_models,
+    "list_variations": list_variations,
+    "copy_fragment": copy_fragment,
+}

cf_agent-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "cf-agent"
+version = "0.1.0"
+description = "AI agent for Adobe AEM Content Fragments"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+authors = [
+    { name = "CF Agent Maintainers" },
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "anthropic>=0.40.0",
+    "httpx>=0.27.0",
+    "click>=8.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/your-org/cf-agent"
+Repository = "https://github.com/your-org/cf-agent"
+Issues = "https://github.com/your-org/cf-agent/issues"
+
+[project.scripts]
+cf-agent = "cf_agent.agent:cli"
+
+[tool.hatch.build.targets.wheel]
+packages = ["cf_agent"]