cinna-cli 0.1.0__py3-none-any.whl

cinna/console.py

@@ -0,0 +1,39 @@
+"""Consistent terminal output using Rich."""
+
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn
+
+console = Console()
+
+
+def status(msg: str):
+    """Print a status message."""
+    console.print(f"[green]\u2713[/green] {msg}")
+
+
+def warn(msg: str):
+    console.print(f"[yellow]![/yellow] {msg}")
+
+
+def error(msg: str):
+    console.print(f"[red]\u2717[/red] {msg}")
+
+
+def step(n: int, total: int, msg: str):
+    """Print a setup step: [1/6] msg"""
+    console.print(f"[dim]\\[{n}/{total}][/dim] {msg}")
+
+
+def spinner(msg: str):
+    """Return a Rich status context manager."""
+    return console.status(f"[bold]{msg}[/bold]", spinner="dots")
+
+
+def file_progress():
+    """Return a progress bar for file operations."""
+    return Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        BarColumn(),
+        TextColumn("{task.completed}/{task.total} files"),
+    )

cinna/context.py

@@ -0,0 +1,216 @@
+"""Generate CLAUDE.md and BUILDING_AGENT.md from building context."""
+
+import importlib.resources
+import json
+import logging
+import re
+from pathlib import Path
+from datetime import datetime, timezone
+
+from cinna.config import CinnaConfig, build_dir
+
+logger = logging.getLogger("cinna.context")
+
+
+# Matches container-internal references like `/app/core/prompts/WEBAPP_BUILDING.md`
+# inside the building prompt. In live-sync mode the companion guides ship
+# inline inside the building-context response (`prompt_files`); the legacy
+# `.cinna/build/app/core/prompts/` Docker-build-context layout is still
+# honoured as a fallback for older backends.
+_PROMPT_REF_RE = re.compile(r"/app/core/prompts/([A-Za-z0-9_]+\.md)")
+
+# Matches rewritten references like `./WEBAPP_BUILDING.md` — used by
+# `list_synced_prompt_refs` to recover which files the CLI mirrored when no
+# `.cinna/build/` directory exists (i.e. the live-sync path).
+_LOCAL_REF_RE = re.compile(r"\./([A-Z][A-Z0-9_]*\.md)")
+
+
+def _load_template(name: str) -> str:
+    """Load a template file from the templates package."""
+    return importlib.resources.files("cinna.templates").joinpath(name).read_text()
+
+
+def _sync_prompt_references(
+    building_prompt: str,
+    workspace_root: Path,
+    prompt_files: dict[str, str] | None = None,
+) -> tuple[str, list[str]]:
+    """Copy reference docs to workspace root, rewrite container paths.
+
+    The building prompt is assembled to run inside the agent container and
+    references auxiliary guides by their container path (e.g.
+    `/app/core/prompts/WEBAPP_BUILDING.md`). On the host those paths don't
+    resolve, so we mirror each referenced file next to BUILDING_AGENT.md and
+    rewrite the references to `./<NAME>.md`.
+
+    File contents come from ``prompt_files`` (the inline dict shipped by the
+    platform in the building-context response). When that's missing — older
+    backends, or the minimal-context fallback — we fall back to reading from
+    ``.cinna/build/app/core/prompts/`` which used to be populated by the
+    legacy Docker-build-context sync.
+
+    Returns (rewritten_prompt, list of filenames synced to workspace_root).
+    """
+    prompt_files = prompt_files or {}
+    src_dir = build_dir(workspace_root) / "app" / "core" / "prompts"
+    referenced = sorted(set(_PROMPT_REF_RE.findall(building_prompt)))
+    synced: list[str] = []
+
+    for filename in referenced:
+        content: str | None = prompt_files.get(filename)
+        if content is None:
+            src = src_dir / filename
+            if src.is_file():
+                content = src.read_text()
+        if content is None:
+            logger.debug(
+                "Referenced prompt file not available locally or inline: %s", filename
+            )
+            continue
+        (workspace_root / filename).write_text(content)
+        synced.append(filename)
+
+    rewritten = _PROMPT_REF_RE.sub(r"./\1", building_prompt)
+    return rewritten, synced
+
+
+def generate_context_files(
+    building_context: dict,
+    config: CinnaConfig,
+    workspace_root: Path,
+) -> None:
+    """Generate CLAUDE.md and BUILDING_AGENT.md from building context response.
+
+    Also mirrors any `/app/core/prompts/*.md` files referenced by the building
+    prompt into the workspace root, so they resolve for host-side AI tools.
+    """
+    timestamp = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    # --- BUILDING_AGENT.md ---
+    building_prompt = building_context.get("building_prompt", "")
+    prompt_files = building_context.get("prompt_files") or {}
+    building_prompt, synced_refs = _sync_prompt_references(
+        building_prompt, workspace_root, prompt_files=prompt_files
+    )
+    if synced_refs:
+        logger.info("Synced referenced prompt docs: %s", ", ".join(synced_refs))
+
+    building_md = (
+        f"> This file is auto-generated by cinna. Do not edit manually.\n"
+        f"> Contains the building mode system prompt pulled from the platform.\n"
+        f"> Regenerated on: {timestamp}\n\n"
+        f"{building_prompt}"
+    )
+    (workspace_root / "BUILDING_AGENT.md").write_text(building_md)
+
+    # --- CLAUDE.md ---
+    mcp_tools = _format_mcp_tools(config)
+    claude_md = (
+        _load_template("CLAUDE.md.template")
+        .replace("{agent_name}", config.agent_name)
+        .replace("{timestamp}", timestamp)
+        .replace("{mcp_tools_section}", mcp_tools)
+    )
+    (workspace_root / "CLAUDE.md").write_text(claude_md)
+
+
+def generate_mcp_json(config: CinnaConfig, workspace_root: Path) -> None:
+    """Generate .mcp.json for Claude Code MCP tool discovery."""
+    mcp_config = {
+        "mcpServers": {
+            "agent-knowledge": {
+                "command": "cinna",
+                "args": ["mcp-proxy"],
+                "env": {
+                    "CINNA_CONFIG": str(workspace_root / ".cinna" / "config.json"),
+                },
+            }
+        }
+    }
+    (workspace_root / ".mcp.json").write_text(json.dumps(mcp_config, indent=2) + "\n")
+
+
+def generate_opencode_json(config: CinnaConfig, workspace_root: Path) -> None:
+    """Generate opencode.json for opencode MCP tool discovery."""
+    opencode_config = {
+        "mcp": {
+            "agent-knowledge": {
+                "type": "local",
+                "command": ["cinna", "mcp-proxy"],
+                "environment": {
+                    "CINNA_CONFIG": str(workspace_root / ".cinna" / "config.json"),
+                },
+                "enabled": True,
+            }
+        }
+    }
+    (workspace_root / "opencode.json").write_text(
+        json.dumps(opencode_config, indent=2) + "\n"
+    )
+
+
+def list_synced_prompt_refs(workspace_root: Path) -> list[str]:
+    """Return filenames of prompt reference docs currently present at the workspace root.
+
+    Used by ``disconnect`` to know which auto-generated files to clean up.
+    Covers two cases:
+
+    * Legacy Docker-build-context layout — files mirrored from
+      ``.cinna/build/app/core/prompts/``.
+    * Live-sync layout — no ``.cinna/build/`` directory; the filenames are
+      recovered by parsing the rewritten ``BUILDING_AGENT.md`` for
+      ``./<NAME>.md`` references.
+    """
+    result: set[str] = set()
+
+    src_dir = build_dir(workspace_root) / "app" / "core" / "prompts"
+    if src_dir.is_dir():
+        for src in src_dir.iterdir():
+            if src.is_file() and src.suffix == ".md" and src.name != "BUILDING_AGENT.md":
+                if (workspace_root / src.name).is_file():
+                    result.add(src.name)
+
+    building_md = workspace_root / "BUILDING_AGENT.md"
+    if building_md.is_file():
+        content = building_md.read_text()
+        for name in _LOCAL_REF_RE.findall(content):
+            if name == "BUILDING_AGENT.md":
+                continue
+            if (workspace_root / name).is_file():
+                result.add(name)
+
+    return sorted(result)
+
+
+def generate_gitignore(workspace_root: Path) -> None:
+    """Generate .gitignore for the local dev workspace."""
+    content = """\
+.cinna/
+.claude/settings.local.json
+CLAUDE.md
+BUILDING_AGENT.md
+WEBAPP_BUILDING.md
+COMPLEX_AGENT_DESIGN.md
+.mcp.json
+opencode.json
+cinna.log
+workspace/credentials/
+workspace/app-data/
+workspace/__pycache__/
+workspace/*.pyc
+"""
+    gitignore = workspace_root / ".gitignore"
+    if not gitignore.exists():
+        gitignore.write_text(content)
+
+
+def _format_mcp_tools(config: CinnaConfig) -> str:
+    """Format MCP tools list for CLAUDE.md."""
+    tools = [
+        "- `knowledge_query` — Search the agent's knowledge base for documentation"
+    ]
+    if config.knowledge_sources:
+        topics = ", ".join(t for ks in config.knowledge_sources for t in ks.topics)
+        if topics:
+            tools.append(f"  Available topics: {topics}")
+    return "\n".join(tools)

cinna/errors.py

@@ -0,0 +1,56 @@
+"""Custom exceptions for cinna CLI."""
+
+import click
+
+
+class CinnaError(click.ClickException):
+    """Base exception — all cinna errors are Click exceptions so they display nicely."""
+
+
+class ConfigNotFoundError(CinnaError):
+    """No .cinna/config.json found. User needs to run setup."""
+
+    def __init__(self):
+        super().__init__(
+            "Not in a cinna workspace. Run the setup command from the platform UI first."
+        )
+
+
+class AuthenticationError(CinnaError):
+    """CLI token rejected by the platform."""
+
+    def __init__(self, detail: str = ""):
+        msg = "Authentication failed. Your session may have expired."
+        if detail:
+            msg += f" ({detail})"
+        msg += "\nRun the setup command again from the platform UI."
+        super().__init__(msg)
+
+
+class PlatformError(CinnaError):
+    """Backend returned an unexpected error."""
+
+    def __init__(self, status_code: int, detail: str):
+        super().__init__(f"Platform error ({status_code}): {detail}")
+
+
+class MutagenNotFoundError(CinnaError):
+    """Mutagen is not installed or not on PATH."""
+
+    def __init__(self, required_version: str | None = None):
+        msg = "Mutagen is required but was not found on PATH."
+        if required_version:
+            msg += f" (required version: {required_version})"
+        msg += "\nInstall with:  brew install mutagen-io/mutagen/mutagen"
+        msg += "\nOther platforms: https://mutagen.io/documentation/introduction/installation"
+        super().__init__(msg)
+
+
+class MutagenVersionMismatchError(CinnaError):
+    """Installed Mutagen version does not match what the platform requires."""
+
+    def __init__(self, installed: str, required: str):
+        super().__init__(
+            f"Mutagen version mismatch: installed {installed}, platform requires {required}.\n"
+            "Upgrade with:  brew upgrade mutagen-io/mutagen/mutagen"
+        )

cinna/logging.py

@@ -0,0 +1,38 @@
+"""File-based logging for debugging CLI issues."""
+
+import logging
+import logging.handlers
+from pathlib import Path
+
+LOG_FILE = "cinna.log"
+
+
+def setup_logging(verbose: bool = False) -> None:
+    """Configure file logging. Logs to ./cinna.log in the current directory."""
+    try:
+        log_path = Path.cwd() / LOG_FILE
+    except (FileNotFoundError, OSError):
+        raise SystemExit(
+            "Error: Current directory no longer exists.\n"
+            "This usually happens after 'cinna disconnect-all' deletes the workspace.\n"
+            "Run: cd ~  (or any existing directory) and try again."
+        )
+
+    file_handler = logging.handlers.RotatingFileHandler(
+        log_path,
+        maxBytes=5 * 1024 * 1024,  # 5MB
+        backupCount=3,
+    )
+    file_handler.setFormatter(
+        logging.Formatter("%(asctime)s %(levelname)s [%(name)s] %(message)s")
+    )
+
+    root = logging.getLogger("cinna")
+    root.setLevel(logging.DEBUG)
+    root.addHandler(file_handler)
+
+    if verbose:
+        console_handler = logging.StreamHandler()
+        console_handler.setLevel(logging.DEBUG)
+        console_handler.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))
+        root.addHandler(console_handler)