cu-cli 0.1.0b1__py3-none-any.whl

cu_cli/errors.py

@@ -0,0 +1,174 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Friendly error handling for CLI commands.
+
+``CuCliError`` is a ``ClickException`` that prints a single-line ``error:`` with
+an optional ``hint:`` and honors the exit-code convention in ``exit_codes.py``.
+The ``friendly_errors`` decorator turns raw SDK / network / filesystem
+exceptions into clean, actionable CLI errors.
+"""
+
+from __future__ import annotations
+
+import functools
+import sys
+from typing import Callable, Optional
+
+import click
+from cu_cli_core.errors import CuCoreError, UsageError, ValidationError
+from rich.console import Console
+
+from .exit_codes import GENERIC_ERROR, VALIDATION_FAILURE
+
+err_console = Console(stderr=True)
+
+
+class CuCliError(click.ClickException):
+    """A clean, single-line CLI error with an optional hint."""
+
+    def __init__(self, message: str, hint: Optional[str] = None, exit_code: int = GENERIC_ERROR):
+        super().__init__(message)
+        self.hint = hint
+        self.exit_code = exit_code
+
+    def show(self, file=None) -> None:  # type: ignore[override]
+        err_console.print(f"[bold red]error:[/bold red] {self.message}")
+        if self.hint:
+            err_console.print(f"[dim]hint:[/dim] {self.hint}")
+
+    def format_message(self) -> str:  # type: ignore[override]
+        """Render the message together with the hint.
+
+        rich-click renders a ``ClickException`` through ``format_message`` (see
+        ``write_error``), **not** through our ``show`` override — so a hint
+        placed only in ``show`` is silently dropped in the CLI's error panel.
+        Embedding it here guarantees the resolution guidance always reaches the
+        user (reported previously).
+        """
+        if self.hint:
+            return f"{self.message}\nhint: {self.hint}"
+        return self.message
+
+
+def _attr(obj: object, key: str) -> object:
+    """Read *key* from a mapping or an object (SDK errors mix both shapes)."""
+    if obj is None:
+        return None
+    if isinstance(obj, dict):
+        return obj.get(key)
+    return getattr(obj, key, None)
+
+
+def _walk_service_error(node: object, lines: list, indent: int) -> None:
+    """Append ``code: message`` lines from an (inner)error node and its details.
+
+    The CU service nests the actionable failure under ``error.innererror`` (a
+    mapping) with an optional ``details`` list; each detail carries its own
+    ``code``/``message``/``target``. The top-level ``error.message`` is only a
+    generic string (e.g. ``"Invalid Request."``), so we surface the nested
+    detail instead of dropping it.
+    """
+    if node is None:
+        return
+    code = _attr(node, "code")
+    message = _attr(node, "message")
+    if code or message:
+        pad = "  " * indent
+        label = f"{code}: " if code else ""
+        lines.append(f"{pad}{label}{message or ''}".rstrip())
+    details = _attr(node, "details") or []
+    if isinstance(details, (list, tuple)):
+        for d in details:
+            dcode = _attr(d, "code")
+            dtarget = _attr(d, "target")
+            dmsg = _attr(d, "message")
+            pad = "  " * (indent + 1)
+            loc = f" ({dtarget})" if dtarget else ""
+            label = f"{dcode}{loc}: " if dcode else (f"({dtarget}) " if dtarget else "")
+            lines.append(f"{pad}{label}{dmsg or ''}".rstrip())
+    _walk_service_error(_attr(node, "innererror"), lines, indent + 1)
+
+
+def _format_service_error(exc: object) -> str:
+    """Build a multi-line message that surfaces the SDK's inner error details."""
+    status = _attr(exc, "status_code") or "?"
+    err = _attr(exc, "error")
+    top_code = _attr(err, "code")
+    top_msg = _attr(err, "message") or _attr(exc, "message") or str(exc)
+    head = f"service responded {status}"
+    if top_code:
+        head += f" ({top_code})"
+    lines = [f"{head}: {top_msg}"]
+    _walk_service_error(_attr(err, "innererror"), lines, 1)
+    top_details = _attr(err, "details") or []
+    if isinstance(top_details, (list, tuple)):
+        for d in top_details:
+            _walk_service_error(d, lines, 1)
+    return "\n".join(lines)
+
+
+def friendly_errors(fn: Callable) -> Callable:
+    """Decorator: turn SDK / network exceptions into clean CLI errors."""
+
+    @functools.wraps(fn)
+    def wrapper(*args, **kwargs):
+        try:
+            return fn(*args, **kwargs)
+        except CuCoreError as exc:
+            exit_code = (
+                VALIDATION_FAILURE
+                if isinstance(exc, (UsageError, ValidationError))
+                else GENERIC_ERROR
+            )
+            raise CuCliError(exc.message, hint=exc.hint, exit_code=exit_code) from exc
+        except CuCliError:
+            raise
+        except click.ClickException:
+            raise
+        except click.exceptions.Abort:
+            raise
+        except KeyboardInterrupt:
+            err_console.print("[yellow]aborted[/yellow]")
+            sys.exit(130)
+        except FileNotFoundError as exc:
+            raise CuCliError(
+                f"file not found: {exc.filename or exc}",
+                hint="check the path; globs that match no files are reported.",
+            ) from exc
+        except PermissionError as exc:
+            raise CuCliError(f"permission denied: {exc}") from exc
+        except Exception as exc:  # noqa: BLE001 — translate to a friendly error
+            try:
+                from azure.core.exceptions import (
+                    ClientAuthenticationError,
+                    HttpResponseError,
+                    ServiceRequestError,
+                )
+            except Exception:  # pragma: no cover - azure always present at runtime
+                ClientAuthenticationError = HttpResponseError = ServiceRequestError = ()  # type: ignore
+
+            if isinstance(exc, ClientAuthenticationError):
+                raise CuCliError(
+                    "Authentication failed. Run 'cu doctor' to diagnose, or "
+                    "'az login' to re-authenticate.",
+                ) from exc
+            if isinstance(exc, HttpResponseError):
+                status = getattr(exc, "status_code", None)
+                # For client (4xx) errors the surfaced inner detail *is* the
+                # actionable guidance; a 'cu doctor' nudge only makes sense for
+                # auth/connectivity/service (non-4xx) failures.
+                client_error = isinstance(status, int) and 400 <= status < 500
+                raise CuCliError(
+                    _format_service_error(exc),
+                    hint=None if client_error else
+                    "run 'cu doctor' to verify endpoint, auth, and model deployments.",
+                ) from exc
+            if isinstance(exc, ServiceRequestError):
+                raise CuCliError(
+                    f"Could not reach the endpoint: {exc}. Check the URL and your "
+                    "network. 'cu doctor' can verify connectivity.",
+                ) from exc
+            raise CuCliError(f"unexpected error: {exc}") from exc
+
+    return wrapper

cu_cli/exit_codes.py

@@ -0,0 +1,20 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Exit-code convention.
+
+    0  success
+    2  validation failure (so agents can branch deterministically)
+    non-zero (1, 3, ...)  service / auth / config errors
+
+Keeping these as named constants makes the contract explicit at every
+``sys.exit`` / ``ClickException`` site.
+"""
+
+from __future__ import annotations
+
+SUCCESS = 0
+GENERIC_ERROR = 1
+VALIDATION_FAILURE = 2
+
+__all__ = ["SUCCESS", "GENERIC_ERROR", "VALIDATION_FAILURE"]

cu_cli/modality.py

@@ -0,0 +1,24 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Service-aligned file extensions used for safe discovery."""
+
+from __future__ import annotations
+
+# Keep this list aligned with:
+# https://learn.microsoft.com/azure/ai-services/content-understanding/service-limits
+DOCUMENT_SAMPLE_EXTS = frozenset({
+    ".pdf", ".tiff",
+    ".docx", ".xlsx", ".pptx", ".docm", ".xlsm", ".pptm", ".doc", ".xls", ".ppt",
+    ".odt", ".ods", ".odp", ".epub",
+    ".txt", ".html", ".md", ".rtf", ".xml", ".json", ".csv", ".tsv", ".kml", ".eml", ".msg",
+})
+IMAGE_EXTS = frozenset({".jpg", ".jpeg", ".jpe", ".png", ".bmp", ".heif", ".heic"})
+AUDIO_EXTS = frozenset({
+    ".wav", ".mp3", ".mp4", ".opus", ".ogg", ".flac", ".wma", ".aac", ".webm", ".m4a",
+})
+VIDEO_EXTS = frozenset({".mp4", ".m4v", ".flv", ".wmv", ".asf", ".avi", ".mkv", ".mov"})
+
+KNOWN_SERVICE_INPUT_EXTS = (
+    DOCUMENT_SAMPLE_EXTS | IMAGE_EXTS | AUDIO_EXTS | VIDEO_EXTS
+)

cu_cli/output.py

@@ -0,0 +1,179 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Output helpers: JSON / markdown / pretty tables.
+
+``console`` is routed to stderr so the stdout pipe contract for
+``cu analyze ... --json | jq`` is never broken by status output. Data
+payloads use ``sys.stdout.write`` / explicit file writes, or ``result_console``
+for Rich-rendered result content (e.g. ``cu profile list`` / ``cu profile show``)
+that still needs to be redirectable/pipeable via stdout.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+from pathlib import Path
+from typing import Any, Iterable
+
+from cu_cli_core.serialization import to_plain_value
+from rich.console import Console
+from rich.table import Table
+
+console = Console(stderr=True)
+result_console = Console()
+
+
+class EmptyMarkdownOutputError(RuntimeError):
+    """The service succeeded, but its result has no Markdown projection."""
+
+
+def to_jsonable(obj: Any) -> Any:
+    """Convert Azure SDK model objects to frontend-neutral plain values."""
+    return to_plain_value(obj)
+
+
+def dumps_json(obj: Any) -> str:
+    return json.dumps(to_jsonable(obj), indent=2, default=str)
+
+
+def _enum_value(obj: Any) -> Any:
+    """Return an enum's ``.value`` so tables show ``ready`` not ``Status.READY``."""
+    return getattr(obj, "value", obj)
+
+
+def _md_cell(value: Any) -> str:
+    """Escape a value for a GitHub-flavored-markdown table cell."""
+    text = "" if value is None else str(value)
+    return text.replace("|", "\\|").replace("\n", " ").strip()
+
+
+def markdown_table(rows: "Iterable[Iterable[Any]]", headers: "list[str]") -> str:
+    """Render *rows* as a valid GitHub-flavored-markdown table string."""
+    lines = [
+        "| " + " | ".join(_md_cell(h) for h in headers) + " |",
+        "| " + " | ".join("---" for _ in headers) + " |",
+    ]
+    for row in rows:
+        lines.append("| " + " | ".join(_md_cell(c) for c in row) + " |")
+    return "\n".join(lines)
+
+
+def dump_markdown_kv(pairs: dict, headers: "tuple[str, str]" = ("Key", "Value"),
+                     out: "Path | None" = None) -> None:
+    """Write a two-column mapping as a real markdown table (stdout by default).
+
+    Unlike the Rich tables (which go to stderr and aren't valid markdown), this
+    goes to stdout so ``... --output markdown >> report.md`` produces valid GFM.
+    """
+    body = markdown_table([[k, v] for k, v in pairs.items()], list(headers)) + "\n"
+    if out is None:
+        sys.stdout.write(body)
+        sys.stdout.flush()
+    else:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(body, encoding="utf-8")
+
+
+def dump_json(
+    obj: Any,
+    out: "Path | None" = None,
+    *,
+    overwrite: bool = True,
+) -> None:
+    payload = dumps_json(obj)
+    if out is None:
+        sys.stdout.write(payload)
+        if not payload.endswith("\n"):
+            sys.stdout.write("\n")
+        sys.stdout.flush()
+    elif not overwrite:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        created = False
+        try:
+            with out.open("x", encoding="utf-8") as stream:
+                created = True
+                stream.write(payload)
+        except OSError:
+            if created:
+                out.unlink(missing_ok=True)
+            raise
+    else:
+        import tempfile
+
+        out.parent.mkdir(parents=True, exist_ok=True)
+        temporary: Path | None = None
+        try:
+            with tempfile.NamedTemporaryFile(
+                mode="w",
+                encoding="utf-8",
+                dir=out.parent,
+                prefix=f".{out.name}.",
+                suffix=".tmp",
+                delete=False,
+            ) as stream:
+                stream.write(payload)
+                temporary = Path(stream.name)
+            os.replace(temporary, out)
+        except OSError:
+            if temporary is not None:
+                temporary.unlink(missing_ok=True)
+            raise
+
+
+def render_markdown(result: Any) -> str:
+    """Render an analysis result as LLM-friendly markdown via SDK helper only."""
+    try:
+        from azure.ai.contentunderstanding import to_llm_input
+    except Exception as exc:  # noqa: BLE001
+        raise RuntimeError(
+            "Markdown output requires SDK support for to_llm_input(). "
+            "Install azure-ai-contentunderstanding>=1.2.0b3."
+        ) from exc
+
+    rendered = to_llm_input(result)
+    if not isinstance(rendered, str) or not rendered.strip():
+        raise EmptyMarkdownOutputError("to_llm_input() returned empty markdown output.")
+    return rendered
+
+
+def dump_markdown(result: Any, out: "Path | None" = None) -> None:
+    body = render_markdown(result)
+    if out is None:
+        sys.stdout.write(body)
+        if not body.endswith("\n"):
+            sys.stdout.write("\n")
+        sys.stdout.flush()
+    else:
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_text(body, encoding="utf-8")
+
+
+def analyzer_table(rows: Iterable[Any]) -> Table:
+    t = Table(title="Analyzers", show_lines=False)
+    t.add_column("Analyzer ID", style="bold", overflow="fold", max_width=36)
+    t.add_column("Base")
+    t.add_column("Status")
+    t.add_column("Modified")
+    t.add_column("Description")
+    for a in rows:
+        t.add_row(
+            str(getattr(a, "analyzer_id", "") or ""),
+            str(getattr(a, "base_analyzer_id", "") or "—"),
+            str(_enum_value(getattr(a, "status", "")) or "—"),
+            str(getattr(a, "last_modified_at", "") or "—"),
+            (str(getattr(a, "description", "") or "")[:60]),
+        )
+    return t
+
+
+def kv_table(pairs: dict, title: str = "") -> Table:
+    t = Table(title=title or None, title_justify="left", show_header=False, box=None)
+    t.add_column("key", style="dim")
+    t.add_column("value")
+    for k, v in pairs.items():
+        t.add_row(str(k), str(v) if not isinstance(v, dict)
+                  else json.dumps(v, indent=2, default=str))
+    return t

cu_cli/profile.py

@@ -0,0 +1,30 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Standalone access to the shared CU profile implementation."""
+
+from cu_cli_core.profiles import (
+    DEFAULT_PROFILE_NAME,
+    KNOWN_PROFILE_KEYS,
+    Profile,
+    ProfileStore,
+    azure_config_path,
+    is_valid_profile_name,
+    normalize_profile_name,
+    validate_profile_key,
+    validate_profile_name,
+    validate_profile_value,
+)
+
+__all__ = [
+    "DEFAULT_PROFILE_NAME",
+    "KNOWN_PROFILE_KEYS",
+    "Profile",
+    "ProfileStore",
+    "azure_config_path",
+    "is_valid_profile_name",
+    "normalize_profile_name",
+    "validate_profile_key",
+    "validate_profile_name",
+    "validate_profile_value",
+]

cu_cli/resources/__init__.py

@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT license.
+
+"""Bundled azd/Bicep resources emitted by ``cu infra generate``."""

cu_cli/resources/azd_template/README.md

@@ -0,0 +1,187 @@
+# Azure Content Understanding starter (azd template)
+
+Provision a Microsoft Foundry resource and project, configure a local CU CLI
+profile, and optionally deploy selected supported large language models (LLMs)
+and embeddings models
+supported by the selected Content Understanding API version. The model
+deployments enable prebuilt analyzers such as `prebuilt-invoice` and custom
+analyzers. The template also configures Content Understanding defaults that map
+model names to deployment names. It is purpose-built as a launchpad for
+**Azure Content Understanding in Foundry Tools** workflows and the
+[`cu` CLI](https://github.com/Azure/content-understanding-toolkit/tree/main/cu-cli).
+```sh
+azd init --template kmuthukrishn/content-understanding-starter
+azd env new dev
+azd env set AZURE_LOCATION eastus2
+azd up
+```
+
+That's it. No app code, no Container Apps, no AI Search — just the bits you
+need to start authoring analyzers.
+
+## Permissions required for `azd up`
+
+This template deploys at subscription scope. For the complete new-resource
+path, the identity running `azd up` needs **Contributor** or **Owner** on the
+selected subscription, or a custom role with equivalent permissions. This
+allows the deployment to create the resource group, Foundry resource and
+project, and selected model deployments.
+
+Contributor cannot create Azure role assignments. If the deployment should
+also assign the generated data-plane role, the identity additionally needs
+**Role Based Access Control Administrator**, **User Access Administrator**, or
+**Owner** on the subscription. If you have Contributor only, set
+`AZURE_ASSIGN_ROLES` to `false`; the post-provision hook uses resource-key
+authentication instead.
+
+With Entra authentication, CU CLI also requires **Cognitive Services User** on
+the Microsoft Foundry resource to configure defaults and create, manage, and run
+analyzers. This is data-plane access and is not included in Owner or
+Contributor.
+
+## What gets provisioned
+
+| Resource | Purpose |
+| --- | --- |
+| Resource group `rg-<env>` | Container for everything |
+| `Microsoft.CognitiveServices/accounts` (kind `AIServices`) | Microsoft Foundry resource that exposes Content Understanding and other Foundry Tools through one endpoint |
+| `Microsoft.CognitiveServices/accounts/projects` | Foundry project (defaults to `proj-<env>`) |
+| `Microsoft.CognitiveServices/accounts/deployments` | Models selected from the live Content Understanding and Microsoft Foundry resource catalogs, or none |
+| Role assignment on the calling user | `Cognitive Services User` — permits CU CLI to configure defaults and create, manage, and run analyzers with Entra authentication |
+
+The resource endpoint is `https://<resource-name>.services.ai.azure.com/` — the same
+host that serves `/contentunderstanding/...`, `/openai/...`, and the Foundry
+project API.
+
+If `FOUNDRY_EXISTING_ENDPOINT` is set, this template skips resource and project
+creation and performs the same live discovery against that existing resource.
+
+## Microsoft Foundry resource naming
+
+The Microsoft Foundry resource name must be globally unique because it becomes part of a
+public DNS hostname:
+
+`https://<resource-name>.services.ai.azure.com/`
+
+By default, this template uses `aif-<unique-suffix>`. To make the name more
+meaningful, set an optional prefix and azd will construct:
+
+`<prefix>-<unique-suffix>`
+
+Example:
+
+```sh
+azd env set FOUNDRY_RESOURCE_PREFIX yslincu
+azd up
+```
+
+This produces resource names like `yslincu-xbrzt4yrmiexg`.
+
+## Live model setup
+
+The first infrastructure deployment intentionally creates the Foundry resource
+with an empty `infra/models.json`. The post-provision hook then:
+
+1. Calls `GET prebuilt-document` with `CU_API_VERSION`.
+2. Reads `supportedModels.completion` and `supportedModels.embedding`.
+3. Calls `az cognitiveservices account list-models` for the provisioned resource.
+4. Shows only model versions present in both live catalogs.
+5. Deploys the selection and writes it to `infra/models.json`, making subsequent
+   Bicep runs repeatable.
+
+Choose `0` to deploy no models. In that mode, `prebuilt-digitalParse`,
+`prebuilt-read`, and `prebuilt-layout` are available without language or
+embeddings model deployments.
+Set `CU_MODEL_SELECTION=recommended` for noninteractive selection or
+`CU_MODEL_SELECTION=none` for deterministic setup without model deployments.
+
+The generated hook runs `cu _infra-models`, so keep the `cu` CLI installed and
+on `PATH` when running `azd up` (`cu-cli` on macOS). A saved `prompt` selection
+requires an interactive terminal; set `CU_MODEL_SELECTION=recommended`, `none`,
+or explicit `model@version` selectors for unattended runs. Model setup failures
+are reported without blocking CU CLI profile configuration. Resolve the model
+deployment issue and rerun `azd up`; `prebuilt-digitalParse`, `prebuilt-read`,
+and `prebuilt-layout` remain available without language or embeddings models.
+
+## Auto-configuring the CU CLI profile
+
+After live model setup, the post-provision hook automatically runs:
+
+```sh
+cu profile set endpoint <FOUNDRY_ENDPOINT>
+cu profile set default_analyzer prebuilt-layout
+cu doctor
+
+# safe first sanity check (no language or embeddings model required):
+cu analyze <file> --analyzer prebuilt-layout
+
+# When model deployments and Content Understanding defaults are ready:
+cu analyzer schema create --from-sample <file> --output-file schema.json
+cu analyzer create --name my-analyzer --schema schema.json
+cu analyze <file> --analyzer my-analyzer
+```
+
+so the freshly provisioned resource is saved in the default CU CLI profile
+immediately after `azd up`, with `prebuilt-layout` configured as the default
+analyzer. The hook prints the redacted `cu profile show --name default` result.
+If the default profile already has saved values, the hook preserves it and
+explains how to rerun `cu infra generate --force` before `azd up` to replace values.
+
+The post-provision hook only prints the custom-analyzer workflow after it
+verifies succeeded chat completion and embeddings model deployments and
+configures Content Understanding defaults. Otherwise it prints the specific
+repair action and retains the `prebuilt-layout` sanity check.
+
+On macOS, use `cu-cli` in place of `cu` (macOS ships a built-in `cu` command).
+
+Profile setup is automatic and requires no environment variable. To opt out,
+set `CU_DISABLE_AUTO_PROFILE_SETUP=true` before `azd up`. Generated templates
+also honor the legacy `CU_AUTOCONFIG=false` setting. This does not disable live
+model setup; use `azd env set CU_MODEL_SELECTION none` to skip model deployments.
+
+## Cleanup
+
+```sh
+azd down --purge
+```
+
+The `--purge` flag is important — Microsoft Foundry resource names are
+soft-deleted for 48h after `azd down`, and a follow-up `azd up` in the same
+environment would otherwise fail.
+
+## Outputs
+
+After `azd up`, `azd env get-values` exposes:
+
+| Variable | Notes |
+| --- | --- |
+| `FOUNDRY_ENDPOINT` | `https://<resource-name>.services.ai.azure.com/` |
+| `FOUNDRY_EXISTING_ENDPOINT` | Optional existing endpoint to reuse instead of provisioning a new resource |
+| `FOUNDRY_EXISTING_RESOURCE_GROUP` | Resource group for `FOUNDRY_EXISTING_ENDPOINT` |
+| `FOUNDRY_PROJECT_ENDPOINT` | Project-scoped URL (`/api/projects/<project>`) |
+| `FOUNDRY_RESOURCE_NAME` | Account name (also the custom subdomain) |
+| `FOUNDRY_PROJECT_NAME` | Project name |
+| `CU_ENDPOINT` | Alias of `FOUNDRY_ENDPOINT` for clarity |
+| `MODEL_DEPLOYMENTS` | JSON array describing each deployment |
+| `CU_API_VERSION` | API version used for live `prebuilt-document` model discovery |
+| `CU_MODEL_SELECTION` | `prompt`, `recommended`, `none`, or explicit model selectors |
+| `CU_MODEL_SETUP_COMPLETE` | Prevents repeated prompting after successful setup |
+
+## Layout
+
+```text
+.
+├── azure.yaml           # azd project manifest + postprovision hook wiring
+├── infra/
+│   ├── main.bicep              # subscription-scope entrypoint
+│   ├── main.parameters.json    # azd → Bicep parameter glue
+│   └── modules/
+│       └── foundry.bicep       # account + project + persisted model deployments + RBAC
+└── hooks/
+    ├── postprovision.ps1       # Windows live model setup + cu autoconfig
+    └── postprovision.sh        # POSIX live model setup + cu autoconfig
+```
+
+## Status
+
+Experimental / personal starter. Not yet on awesome-azd.

cu_cli/resources/azd_template/azure.yaml

@@ -0,0 +1,27 @@
+# yaml-language-server: $schema=https://raw.githubusercontent.com/Azure/azure-dev/main/schemas/v1.0/azure.yaml.json
+
+name: content-understanding-starter
+metadata:
+  template: content-understanding-starter@0.1.0
+
+infra:
+  provider: bicep
+  path: infra
+  module: main
+
+# No `services:` block on purpose — this template is infra-only.
+# The companion CLI (`cu`) is the developer surface; provisioning the Foundry
+# account + project + a model deployment is all this template does.
+
+hooks:
+  postprovision:
+    posix:
+      shell: sh
+      run: ./hooks/postprovision.sh
+      continueOnError: false
+      interactive: true
+    windows:
+      shell: pwsh
+      run: ./hooks/postprovision.ps1
+      continueOnError: false
+      interactive: true