upscaler-cli 0.2.3.dev6696__py3-none-any.whl → 0.2.3.dev6697__py3-none-any.whl

src/cli/asset.py

@@ -79,14 +79,29 @@ def asset_find(ctx, title, description, asset_type, limit, offset):
         returned = metadata.get("returned_count", len(data))
         if total > returned:
             click.echo(f"Showing {returned} of {total} results (use --offset to paginate)\n")
-        click.echo(format_table(
-            data,
-            columns=["asset_id", "title", "asset_type", "description"],
-        ))
+        click.echo(
+            format_table(
+                data,
+                columns=["asset_id", "title", "asset_type", "description"],
+            )
+        )
 
 
 @asset_group.command("create")
-@click.option("--type", "asset_type", required=True, help="Asset type to create.")
+@click.option(
+    "--type",
+    "asset_type",
+    required=True,
+    type=click.Choice(
+        [
+            "document_definition",
+            "register_definition",
+            "record_definition",
+            "course_definition",
+        ]
+    ),
+    help="Asset type to create.",
+)
 @click.option("--data", "data_input", required=True, help="JSON data (value, - for stdin, @file).")
 @click.option(
     "--values-type",
@@ -179,7 +194,13 @@ def asset_update(ctx, asset_id, data_input, dry_run):
 @click.option("--dry-run", is_flag=True, help="Preview without updating.")
 @pass_context
 def asset_update_content(
-    ctx, asset_id, data_input, values_type, file_pairs, content_types, dry_run,
+    ctx,
+    asset_id,
+    data_input,
+    values_type,
+    file_pairs,
+    content_types,
+    dry_run,
 ):
     """Update asset content (Slate JSON or markdown), optionally uploading files.
 
@@ -228,7 +249,9 @@ def asset_update_content(
 @asset_group.command("upload-file")
 @click.option("--asset-id", required=True, help="Document ID to upload into.")
 @click.option(
-    "--field", "field_name", required=True,
+    "--field",
+    "field_name",
+    required=True,
     help="File-block name (options.name) on the Slate tree.",
 )
 @click.option(
@@ -361,7 +384,11 @@ def asset_add_task(ctx, asset_id, title, description, dry_run):
         data["description"] = description
 
     _execute_asset(
-        ctx, "add_task_definition", asset_id=asset_id, data=data, dry_run=dry_run,
+        ctx,
+        "add_task_definition",
+        asset_id=asset_id,
+        data=data,
+        dry_run=dry_run,
     )
 
 
@@ -379,7 +406,8 @@ def asset_add_task(ctx, asset_id, title, description, dry_run):
     "values_file",
     default=None,
     type=click.Path(exists=True, dir_okay=False),
-    help="Path to a markdown (or Slate JSON) file. Packed as the 'values' field.",
+    help="Path to the body file. With --values-type markdown the file is sent "
+         "as a raw string; otherwise it is parsed as a Slate JSON array.",
 )
 @click.option(
     "--values-type",
@@ -390,7 +418,13 @@ def asset_add_task(ctx, asset_id, title, description, dry_run):
 @click.option("--dry-run", is_flag=True, help="Preview without updating.")
 @pass_context
 def asset_set_task_values(
-    ctx, asset_id, task_definition_id, data_input, values_file, values_type, dry_run,
+    ctx,
+    asset_id,
+    task_definition_id,
+    data_input,
+    values_file,
+    values_type,
+    dry_run,
 ):
     """Set the body of a single task definition (markdown or SlateJS).
 
@@ -403,30 +437,9 @@ def asset_set_task_values(
         upscaler asset set-task-values --asset-id rd_abc --task-id td_xyz \\
             --data '{"values": "## Header\\n..."}' --values-type markdown
     """
-    from src.cli.helpers import parse_data
+    from src.cli.helpers import build_values_payload
 
-    if not data_input and not values_file:
-        click.echo("Provide either --data or --values-file.", err=True)
-        sys.exit(1)
-        return
-    if data_input and values_file:
-        click.echo("--data and --values-file are mutually exclusive.", err=True)
-        sys.exit(1)
-        return
-
-    if values_file:
-        data = {"values": Path(values_file).read_text()}
-    else:
-        try:
-            data = parse_data(data_input)
-        except Exception as e:
-            click.echo(str(e), err=True)
-            sys.exit(1)
-            return
-        if "values" not in data:
-            click.echo("--data must include a 'values' key.", err=True)
-            sys.exit(1)
-            return
+    data = build_values_payload(data_input, values_file, values_type)
 
     data["taskDefinitionId"] = task_definition_id
     if values_type:
@@ -488,10 +501,164 @@ def asset_set_task_condition(ctx, asset_id, task_definition_id, data_input, dry_
     )
 
 
+@asset_group.command("add-lesson")
+@click.option("--asset-id", required=True, help="Course definition ID (cd_...).")
+@click.option("--title", required=True, help="Lesson title.")
+@click.option("--description", default=None, help="Lesson description (optional).")
+@click.option("--dry-run", is_flag=True, help="Preview without creating.")
+@pass_context
+def asset_add_lesson(ctx, asset_id, title, description, dry_run):
+    """Append a new lesson definition to a course_definition.
+
+    Returns the assigned lesson definition ID (cl_...) which is needed to set
+    the lesson's body via `set-lesson-values`, rename it, or reorder it.
+
+    Example:
+        upscaler asset add-lesson --asset-id cd_abc --title "Phishing Basics"
+    """
+    data = {"title": title}
+    if description:
+        data["description"] = description
+
+    _execute_asset(
+        ctx,
+        "add_lesson_definition",
+        asset_id=asset_id,
+        data=data,
+        dry_run=dry_run,
+    )
+
+
+@asset_group.command("set-lesson-title")
+@click.option("--asset-id", required=True, help="Course definition ID (cd_...).")
+@click.option("--lesson-id", "lesson_definition_id", required=True, help="Lesson ID (cl_...).")
+@click.option("--title", required=True, help="New lesson title.")
+@click.option("--dry-run", is_flag=True, help="Preview without updating.")
+@pass_context
+def asset_set_lesson_title(ctx, asset_id, lesson_definition_id, title, dry_run):
+    """Rename a single lesson definition."""
+    _execute_asset(
+        ctx,
+        "set_lesson_definition_title",
+        asset_id=asset_id,
+        data={"lessonDefinitionId": lesson_definition_id, "title": title},
+        dry_run=dry_run,
+    )
+
+
+@asset_group.command("set-lesson-description")
+@click.option("--asset-id", required=True, help="Course definition ID (cd_...).")
+@click.option("--lesson-id", "lesson_definition_id", required=True, help="Lesson ID (cl_...).")
+@click.option("--description", required=True, help="New lesson description.")
+@click.option("--dry-run", is_flag=True, help="Preview without updating.")
+@pass_context
+def asset_set_lesson_description(ctx, asset_id, lesson_definition_id, description, dry_run):
+    """Set the description of a single lesson definition."""
+    _execute_asset(
+        ctx,
+        "set_lesson_definition_description",
+        asset_id=asset_id,
+        data={"lessonDefinitionId": lesson_definition_id, "description": description},
+        dry_run=dry_run,
+    )
+
+
+@asset_group.command("set-lesson-values")
+@click.option("--asset-id", required=True, help="Course definition ID (cd_...).")
+@click.option("--lesson-id", "lesson_definition_id", required=True, help="Lesson ID (cl_...).")
+@click.option(
+    "--data",
+    "data_input",
+    default=None,
+    help="JSON object with 'values' key. Mutually exclusive with --values-file.",
+)
+@click.option(
+    "--values-file",
+    "values_file",
+    default=None,
+    type=click.Path(exists=True, dir_okay=False),
+    help="Path to the body file. With --values-type markdown the file is sent "
+         "as a raw string; otherwise it is parsed as a Slate JSON array.",
+)
+@click.option(
+    "--values-type",
+    type=click.Choice(["markdown", "slateJson"]),
+    default=None,
+    help="Content format: 'markdown' or 'slateJson' (default: slateJson).",
+)
+@click.option("--dry-run", is_flag=True, help="Preview without updating.")
+@pass_context
+def asset_set_lesson_values(
+    ctx,
+    asset_id,
+    lesson_definition_id,
+    data_input,
+    values_file,
+    values_type,
+    dry_run,
+):
+    """Set the body of a single lesson definition (markdown or SlateJS).
+
+    Provide content via either --data (JSON object with 'values') or --values-file
+    (raw markdown or Slate JSON file). Pass --values-type markdown for markdown bodies.
+
+    Examples:
+        upscaler asset set-lesson-values --asset-id cd_abc --lesson-id cl_xyz \\
+            --values-file lesson1-body.md --values-type markdown
+    """
+    from src.cli.helpers import build_values_payload
+
+    data = build_values_payload(data_input, values_file, values_type)
+
+    data["lessonDefinitionId"] = lesson_definition_id
+    if values_type:
+        data["valuesType"] = values_type
+
+    _execute_asset(
+        ctx,
+        "set_lesson_definition_values",
+        asset_id=asset_id,
+        data=data,
+        dry_run=dry_run,
+    )
+
+
+@asset_group.command("remove-lesson")
+@click.option("--asset-id", required=True, help="Course definition ID (cd_...).")
+@click.option("--lesson-id", "lesson_definition_id", required=True, help="Lesson ID (cl_...).")
+@click.option("--dry-run", is_flag=True, help="Preview without removing.")
+@pass_context
+def asset_remove_lesson(ctx, asset_id, lesson_definition_id, dry_run):
+    """Remove a single lesson definition from a course_definition."""
+    _execute_asset(
+        ctx,
+        "remove_lesson_definition",
+        asset_id=asset_id,
+        data={"lessonDefinitionId": lesson_definition_id},
+        dry_run=dry_run,
+    )
+
+
+@asset_group.command("move-lesson")
+@click.option("--asset-id", required=True, help="Course definition ID (cd_...).")
+@click.option("--from-id", "from_id", required=True, help="Lesson ID to move (cl_...).")
+@click.option("--to-id", "to_id", required=True, help="Target sibling lesson ID (cl_...).")
+@click.option("--dry-run", is_flag=True, help="Preview without reordering.")
+@pass_context
+def asset_move_lesson(ctx, asset_id, from_id, to_id, dry_run):
+    """Reorder a lesson definition within a course_definition."""
+    _execute_asset(
+        ctx,
+        "move_lesson_definition",
+        asset_id=asset_id,
+        data={"fromId": from_id, "toId": to_id},
+        dry_run=dry_run,
+    )
+
+
 def _execute_asset(ctx, operation, asset_id=None, asset_type=None, data=None, dry_run=False):
     """Execute an asset operation."""
-    from src.cli.helpers import make_client
-    from src.formatters.json_fmt import format_json
+    from src.cli.helpers import emit_action_result, emit_dry_run, make_client
 
     payload = {"operation": operation}
     if asset_id:
@@ -502,11 +669,11 @@ def _execute_asset(ctx, operation, asset_id=None, asset_type=None, data=None, dr
         payload["data"] = data
 
     if dry_run:
-        if ctx.json_mode:
-            click.echo(format_json({"dry_run": True, "payload": payload}, compact=True))
-        else:
-            click.echo(f"[dry-run] Would {operation} asset:")
-            click.echo(format_json(payload))
+        emit_dry_run(
+            ctx,
+            summary=f"would {operation} {asset_type or asset_id or 'asset'}",
+            payload=payload,
+        )
         return
 
     client = make_client(ctx)
@@ -517,11 +684,9 @@ def _execute_asset(ctx, operation, asset_id=None, asset_type=None, data=None, dr
         handle_error(ctx, e)
         return
 
-    if ctx.json_mode:
-        click.echo(format_json(result, compact=True))
-    else:
-        d = result.get("data", {})
-        click.echo(f"Asset {operation}: {d.get('assetId', d.get('asset_id', ''))}")
+    emit_action_result(
+        ctx, result, label=f"Asset {operation}", id_keys=("assetId", "asset_id", "id")
+    )
 
 
 # File-upload flow for Pattern A (Documents). Documents persist `values` as
@@ -678,9 +843,7 @@ def _dry_run_asset_with_files(ctx, asset_id, files, data):
     if ctx.json_mode:
         click.echo(format_json({"dry_run": True, "payload": dry_payload}, compact=True))
     else:
-        click.echo(
-            f"[dry-run] Would upload {len(files)} file(s) and update-content asset:"
-        )
+        click.echo(f"[dry-run] Would upload {len(files)} file(s) and update-content asset:")
         click.echo(format_json(dry_payload))
 
 

src/cli/context.py

@@ -12,6 +12,7 @@ class Context:
 
     def __init__(self):
         self.json_mode: bool = False
+        self.quiet_mode: bool = False
         self.verbose: bool = False
         self.server_url: Optional[str] = None
         self.profile: str = DEFAULT_PROFILE

src/cli/entry.py

@@ -34,7 +34,8 @@ def entry_group():
 
 @entry_group.command("create")
 @click.option(
-    "--definition-id", required=True,
+    "--definition-id",
+    required=True,
     help="Definition ID (rd_ = record, rg_ = register).",
 )
 @click.option("--data", "data_input", required=True, help="JSON data (value, - for stdin, @file).")
@@ -126,9 +127,7 @@ def entry_update(ctx, entry_id, data_input, file_pairs, task_id, content_types,
 
 @entry_group.command("upload-file")
 @click.option("--entry-id", required=True, help="Entry ID to upload into.")
-@click.option(
-    "--field", "field_name", required=True, help="File-field name (options.name)."
-)
+@click.option("--field", "field_name", required=True, help="File-field name (options.name).")
 @click.option(
     "--path",
     "file_path",
@@ -230,9 +229,12 @@ def entry_complete_task(ctx, entry_id, task_id, data_input, dry_run):
             return
 
     _execute_entry(
-        ctx, "complete_task",
-        entry_id=entry_id, task_id=task_id,
-        data=data, dry_run=dry_run,
+        ctx,
+        "complete_task",
+        entry_id=entry_id,
+        task_id=task_id,
+        data=data,
+        dry_run=dry_run,
     )
 
 
@@ -262,7 +264,7 @@ def _execute_entry(
     files=None,
 ):
     """Execute an entry operation."""
-    from src.cli.helpers import make_client
+    from src.cli.helpers import emit_action_result, make_client
     from src.formatters.json_fmt import format_json
 
     payload = {"operation": operation}
@@ -281,10 +283,10 @@ def _execute_entry(
         # then issue ONE mutation. The no-files path below stays unchanged.
         if dry_run:
             dry_payload = dict(payload)
-            dry_payload["files"] = [
-                {"field": f["field"], "path": str(f["path"])} for f in files
-            ]
-            if ctx.json_mode:
+            dry_payload["files"] = [{"field": f["field"], "path": str(f["path"])} for f in files]
+            if ctx.quiet_mode:
+                click.echo(f"[dry-run] would upload {len(files)} file(s) and {operation} entry")
+            elif ctx.json_mode:
                 click.echo(format_json({"dry_run": True, "payload": dry_payload}, compact=True))
             else:
                 click.echo(f"[dry-run] Would upload {len(files)} file(s) and {operation} entry:")
@@ -300,15 +302,16 @@ def _execute_entry(
         return
 
     if dry_run:
+        if ctx.quiet_mode:
+            click.echo(f"[dry-run] would {operation} entry")
+            return
         dry_run_data = {"dry_run": True, "payload": payload}
 
         # For complete_task, fetch and show the task's form fields
         if operation == "complete_task" and task_id:
             try:
                 client = make_client(ctx)
-                task_result = asyncio.run(
-                    client.request("GET", f"/api/v1/tasks/{task_id}")
-                )
+                task_result = asyncio.run(client.request("GET", f"/api/v1/tasks/{task_id}"))
                 task_data = task_result.get("data", {})
                 definition = task_data.get("definition", [])
                 fields = []
@@ -317,12 +320,14 @@ def _execute_entry(
                         if block.get("type", "").startswith("form-"):
                             opts = block.get("options", {})
                             if opts.get("name"):
-                                fields.append({
-                                    "key": opts["name"],
-                                    "label": opts.get("title", opts["name"]),
-                                    "type": block["type"],
-                                    "required": opts.get("required", False),
-                                })
+                                fields.append(
+                                    {
+                                        "key": opts["name"],
+                                        "label": opts.get("title", opts["name"]),
+                                        "type": block["type"],
+                                        "required": opts.get("required", False),
+                                    }
+                                )
                 if fields:
                     dry_run_data["task_fields"] = fields
                 current_values = task_data.get("values", {})
@@ -346,13 +351,13 @@ def _execute_entry(
         handle_error(ctx, e)
         return
 
-    # After record creation, enrich tasks with their form field definitions
-    if operation == "create" and result.get("data", {}).get("tasks"):
+    # After record creation, enrich tasks with their form field definitions.
+    # Skipped in --quiet mode: the enrichment makes extra calls and only
+    # populates output that quiet mode discards anyway.
+    if not ctx.quiet_mode and operation == "create" and result.get("data", {}).get("tasks"):
         try:
             for task in result["data"]["tasks"]:
-                task_detail = asyncio.run(
-                    client.request("GET", f"/api/v1/tasks/{task['id']}")
-                )
+                task_detail = asyncio.run(client.request("GET", f"/api/v1/tasks/{task['id']}"))
                 task_def = task_detail.get("data", {}).get("definition", [])
                 if isinstance(task_def, list):
                     fields = []
@@ -360,22 +365,20 @@ def _execute_entry(
                         if block.get("type", "").startswith("form-"):
                             opts = block.get("options", {})
                             if opts.get("name"):
-                                fields.append({
-                                    "key": opts["name"],
-                                    "label": opts.get("title", opts["name"]),
-                                    "type": block["type"],
-                                    "required": opts.get("required", False),
-                                })
+                                fields.append(
+                                    {
+                                        "key": opts["name"],
+                                        "label": opts.get("title", opts["name"]),
+                                        "type": block["type"],
+                                        "required": opts.get("required", False),
+                                    }
+                                )
                     if fields:
                         task["fields"] = fields
         except Exception:
             pass  # Non-critical enrichment
 
-    if ctx.json_mode:
-        click.echo(format_json(result, compact=True))
-    else:
-        d = result.get("data", {})
-        click.echo(f"Entry {operation}: {d.get('id', d.get('entryId', ''))}")
+    emit_action_result(ctx, result, label=f"Entry {operation}", id_keys=("id", "entryId"))
 
 
 # File-upload flow for Pattern B (Items + Records, which persist `values`
@@ -397,12 +400,21 @@ def _execute_entry_with_files(ctx, *, entry_id, task_id, data, files):
     client = make_client(ctx)
     landed_uids: list[str] = []
 
-    schema_fields = _fetch_schema_or_die(ctx, client, entry_id)
+    # Records hold their file fields on individual tasks, so an upload must name
+    # the task: it drives both the schema lookup and the values read/merge.
+    if _is_record_id(entry_id) and not task_id:
+        click.echo(
+            "Record file uploads require --task-id (records hold fields on tasks).",
+            err=True,
+        )
+        sys.exit(1)
+
+    schema_fields = _fetch_schema_or_die(ctx, client, entry_id, task_id=task_id)
 
     # Hard-fail before any S3 upload on unknown/ambiguous/non-file fields.
     resolved = _resolve_field_descriptors(ctx, schema_fields, files)
 
-    values, expected_version = _fetch_entry_values(ctx, client, entry_id)
+    values, expected_version = _fetch_entry_values(ctx, client, entry_id, task_id=task_id)
 
     # The splice spec is built once during upload and re-applied on
     # every conflict retry. Top-level entries land via append_file_to_form_field
@@ -427,9 +439,7 @@ def _execute_entry_with_files(ctx, *, entry_id, task_id, data, files):
             landed_uids.append(file_item["uid"])
 
             if "table_key" in descriptor:
-                table_rows = splice_spec["nested"].setdefault(
-                    descriptor["table_key"], {}
-                )
+                table_rows = splice_spec["nested"].setdefault(descriptor["table_key"], {})
                 table_rows.setdefault(descriptor["col_key"], []).append(file_item)
             else:
                 splice_spec["top_level"].append((descriptor["ff_key"], file_item))
@@ -485,11 +495,18 @@ def _apply_splice_spec(values, splice_spec):
     return values
 
 
-def _fetch_schema_or_die(ctx, client, entry_id):
+def _is_record_id(entry_id):
+    return bool(entry_id) and (entry_id.startswith("r_") or entry_id.startswith("rec_"))
+
+
+def _fetch_schema_or_die(ctx, client, entry_id, task_id=None):
+    path = f"/api/v1/assets/{entry_id}/schema"
+    if task_id:
+        # Records carry fields per-task; name the task so the backend returns
+        # that task's field schema instead of a (non-existent) record schema.
+        path += f"?taskId={task_id}"
     try:
-        resp = asyncio.run(
-            client.request("GET", f"/api/v1/assets/{entry_id}/schema")
-        )
+        resp = asyncio.run(client.request("GET", path))
     except Exception as e:
         handle_error(ctx, e)
         sys.exit(1)
@@ -518,12 +535,8 @@ def _resolve_field_descriptors(ctx, schema_fields, files):
     All resolution failures (unknown table, unknown column, ambiguous label,
     non-file target) raise SystemExit before any S3 traffic.
     """
-    top_file_fields = [
-        f for f in schema_fields if f.get("type") == AGENT_SCHEMA_FILE_UPLOAD_TYPE
-    ]
-    table_fields = [
-        f for f in schema_fields if f.get("type") == AGENT_SCHEMA_TABLE_TYPE
-    ]
+    top_file_fields = [f for f in schema_fields if f.get("type") == AGENT_SCHEMA_FILE_UPLOAD_TYPE]
+    table_fields = [f for f in schema_fields if f.get("type") == AGENT_SCHEMA_TABLE_TYPE]
     by_key = {f["key"]: f for f in schema_fields if f.get("key")}
     titles_to_keys: dict[str, list[str]] = {}
     for f in top_file_fields:
@@ -603,9 +616,7 @@ def _resolve_nested(ctx, descriptor, raw_stripped, table_fields):
         _fail_loud_unknown_table(ctx, table_raw, table_fields)
 
     columns = [c for c in (table.get("columns") or []) if isinstance(c, dict)]
-    file_columns = [
-        c for c in columns if c.get("type") == AGENT_SCHEMA_FILE_UPLOAD_TYPE
-    ]
+    file_columns = [c for c in columns if c.get("type") == AGENT_SCHEMA_FILE_UPLOAD_TYPE]
 
     # Match the column by its full schema key OR its bare last segment: the
     # backend reports table columns as the dotted `ff_table.ff_col`, but a user
@@ -621,9 +632,7 @@ def _resolve_nested(ctx, descriptor, raw_stripped, table_fields):
     if col_raw in col_by_key:
         col = col_by_key[col_raw]
         if col.get("type") != AGENT_SCHEMA_FILE_UPLOAD_TYPE:
-            _fail_loud_non_file_column(
-                ctx, table, _bare_col_key(col.get("key")), file_columns
-            )
+            _fail_loud_non_file_column(ctx, table, _bare_col_key(col.get("key")), file_columns)
         return {
             **descriptor,
             "table_key": table["key"],
@@ -645,7 +654,7 @@ def _resolve_nested(ctx, descriptor, raw_stripped, table_fields):
     if len(candidates) > 1:
         click.echo(
             f'Column "{col_raw}" in table "{table.get("label") or table["key"]}" '
-            f'matches multiple file columns: '
+            f"matches multiple file columns: "
             f'{", ".join(_bare_col_key(k) for k in candidates)}. '
             f"Pass the ff_* key to disambiguate.",
             err=True,
@@ -659,10 +668,7 @@ def _match_table(table_raw, table_fields):
     if table_raw in by_key:
         return by_key[table_raw]
     norm = table_raw.lower()
-    label_matches = [
-        t for t in table_fields
-        if (t.get("label") or "").strip().lower() == norm
-    ]
+    label_matches = [t for t in table_fields if (t.get("label") or "").strip().lower() == norm]
     if len(label_matches) == 1:
         return label_matches[0]
     # Ambiguous tables (two with the same label) fall through to the
@@ -671,14 +677,12 @@ def _match_table(table_raw, table_fields):
 
 
 def _fail_loud_unknown(ctx, field_name, file_fields, table_fields=()):
-    available = ", ".join(
-        f'"{f.get("label")}" → {f.get("key")}' for f in file_fields
-    ) or "(none)"
+    available = ", ".join(f'"{f.get("label")}" → {f.get("key")}' for f in file_fields) or "(none)"
     extra = ""
     if table_fields:
         nested = []
         for t in table_fields:
-            for c in (t.get("columns") or []):
+            for c in t.get("columns") or []:
                 if isinstance(c, dict) and c.get("type") == AGENT_SCHEMA_FILE_UPLOAD_TYPE:
                     nested.append(
                         f'"{t.get("label") or t.get("key")}.'
@@ -686,9 +690,7 @@ def _fail_loud_unknown(ctx, field_name, file_fields, table_fields=()):
                         f'{t.get("key")}.{_bare_col_key(c.get("key"))}'
                     )
         if nested:
-            extra = (
-                f" Nested file columns (use TABLE.COLUMN form): {', '.join(nested)}."
-            )
+            extra = f" Nested file columns (use TABLE.COLUMN form): {', '.join(nested)}."
     click.echo(
         f'No file field named "{field_name}" on this entry. '
         f"Available file fields (title → id): {available}.{extra}",
@@ -706,17 +708,14 @@ def _fail_loud_non_file(ctx, key, file_fields, table_fields=()):
             "into a nested file column)"
         )
     click.echo(
-        f'Field "{key}" is not a file-upload field{extra}. '
-        f"Available file fields: {available}.",
+        f'Field "{key}" is not a file-upload field{extra}. ' f"Available file fields: {available}.",
         err=True,
     )
     sys.exit(1)
 
 
 def _fail_loud_unknown_table(ctx, table_raw, table_fields):
-    available = ", ".join(
-        f'"{t.get("label")}" → {t.get("key")}' for t in table_fields
-    ) or "(none)"
+    available = ", ".join(f'"{t.get("label")}" → {t.get("key")}' for t in table_fields) or "(none)"
     click.echo(
         f'No table field named "{table_raw}" on this entry. '
         f"Available tables (title → id): {available}.",
@@ -726,9 +725,10 @@ def _fail_loud_unknown_table(ctx, table_raw, table_fields):
 
 
 def _fail_loud_unknown_column(ctx, table, col_raw, file_columns):
-    available = ", ".join(
-        f'"{c.get("label")}" → {_bare_col_key(c.get("key"))}' for c in file_columns
-    ) or "(none)"
+    available = (
+        ", ".join(f'"{c.get("label")}" → {_bare_col_key(c.get("key"))}' for c in file_columns)
+        or "(none)"
+    )
     click.echo(
         f'No file column "{col_raw}" in table '
         f'"{table.get("label") or table.get("key")}". '
@@ -739,9 +739,7 @@ def _fail_loud_unknown_column(ctx, table, col_raw, file_columns):
 
 
 def _fail_loud_non_file_column(ctx, table, col_key, file_columns):
-    available = ", ".join(
-        _bare_col_key(c.get("key")) for c in file_columns
-    ) or "(none)"
+    available = ", ".join(_bare_col_key(c.get("key")) for c in file_columns) or "(none)"
     click.echo(
         f'Column "{col_key}" in table '
         f'"{table.get("label") or table.get("key")}" is not a file-upload column. '
@@ -751,7 +749,24 @@ def _fail_loud_non_file_column(ctx, table, col_key, file_columns):
     sys.exit(1)
 
 
-def _fetch_entry_values(ctx, client, entry_id):
+def _fetch_entry_values(ctx, client, entry_id, task_id=None):
+    # A record's values live on its tasks, not at the record level, so a file
+    # upload to a record reads (and later merges into) the named task's values.
+    # completeTask is last-writer-wins, so no version is needed for records.
+    if _is_record_id(entry_id) and task_id:
+        try:
+            task = asyncio.run(client.request("GET", f"/api/v1/tasks/{task_id}"))
+        except Exception as e:
+            handle_error(ctx, e)
+            sys.exit(1)
+        task_data = (task or {}).get("data") or {}
+        values = task_data.get("values") if isinstance(task_data, dict) else None
+        if values is None:
+            values = {}
+        if not isinstance(values, dict):
+            click.echo("Task values are not a flat dict.", err=True)
+            sys.exit(1)
+        return values, None
     try:
         entry = asyncio.run(client.request("GET", f"/api/v1/assets/{entry_id}"))
     except Exception as e:
@@ -796,9 +811,7 @@ def _submit_with_retry(
             expected_version=current_version if not task_id else None,
         )
         try:
-            result = asyncio.run(
-                client.request("POST", "/api/v1/entries", json=payload)
-            )
+            result = asyncio.run(client.request("POST", "/api/v1/entries", json=payload))
         except Exception as e:
             if _is_version_conflict(e) and not task_id and attempt < _CONFLICT_RETRY_BUDGET:
                 current_values, current_version = _refresh_and_reapply(
@@ -935,9 +948,7 @@ def _emit_retry_exhausted(ctx, landed_uids):
     else:
         click.echo(err_body["message"], err=True)
         if landed_uids:
-            click.echo(
-                "Files uploaded to S3 (subject to lifecycle cleanup):", err=True
-            )
+            click.echo("Files uploaded to S3 (subject to lifecycle cleanup):", err=True)
             for uid in landed_uids:
                 click.echo(f"  {uid}", err=True)
     sys.exit(1)

src/cli/get.py

@@ -17,7 +17,7 @@ _PREFIX_ROUTES = {
 }
 
 # Known asset prefixes (routed to /api/v1/assets)
-_ASSET_PREFIXES = ("d_", "doc_", "rg_", "rd_", "r_", "rec_", "i_")
+_ASSET_PREFIXES = ("d_", "doc_", "rg_", "rd_", "r_", "rec_", "i_", "cd_")
 
 # Explicit --type → endpoint
 _TYPE_ROUTES = {
@@ -62,8 +62,13 @@ def _detect_route(resource_id, resource_type):
     type=click.Choice(["member", "group", "task", "todo"]),
     help="Resource type (for IDs without a known prefix, e.g. member).",
 )
+@click.option(
+    "--draft", is_flag=True, default=False,
+    help="Read the unpublished working copy instead of the published version "
+         "(record definitions: shows edits not yet released).",
+)
 @pass_context
-def get_asset(ctx, resource_id, fmt, resource_type):
+def get_asset(ctx, resource_id, fmt, resource_type, draft):
     """Retrieve an asset, member, or group by ID.
 
     Asset and group IDs are auto-detected by prefix (rg_, d_, g_, etc.).
@@ -72,6 +77,7 @@ def get_asset(ctx, resource_id, fmt, resource_type):
     Examples:
         upscaler get rg_abc123
         upscaler get rg_abc123 --format schema
+        upscaler get rd_abc123 --format schema --draft
         upscaler get g_abc123
         upscaler get <uid> --type member
         upscaler --json get <uid> --type member
@@ -84,10 +90,19 @@ def get_asset(ctx, resource_id, fmt, resource_type):
     endpoint, is_asset = _detect_route(resource_id, resource_type)
 
     if endpoint is None:
-        msg = (
-            f"Unknown resource ID format: {resource_id}. "
-            "Use --type member or --type group for IDs without a known prefix."
-        )
+        if resource_id.startswith("cl_"):
+            # Lessons are not standalone assets: they live inside a course and
+            # are read through it. `get <cd_…>` returns every lesson with its
+            # id, title, description, and body.
+            msg = (
+                f"{resource_id} is a lesson, which is read through its course. "
+                "Run `upscaler get <cd_…>` to see every lesson (id, title, body)."
+            )
+        else:
+            msg = (
+                f"Unknown resource ID format: {resource_id}. "
+                "Use --type member or --type group for IDs without a known prefix."
+            )
         if ctx.json_mode:
             import json
             click.echo(json.dumps({"error": msg, "exit_code": 1}), err=True)
@@ -97,14 +112,16 @@ def get_asset(ctx, resource_id, fmt, resource_type):
         return
 
     if is_asset:
-        _get_asset(ctx, client, resource_id, fmt, format_json)
+        _get_asset(ctx, client, resource_id, fmt, format_json, draft=draft)
     else:
         _get_simple(ctx, client, f"{endpoint}/{resource_id}", format_json)
 
 
-def _get_asset(ctx, client, asset_id, fmt, format_json):
+def _get_asset(ctx, client, asset_id, fmt, format_json, draft=False):
     """Fetch and display an asset with format control."""
     params = {}
+    if draft:
+        params["draft"] = "true"
     if fmt:
         params["format"] = fmt
 

src/cli/helpers.py

@@ -50,6 +50,60 @@ def parse_data(value: str) -> dict:
     return data
 
 
+def build_values_payload(data_input, values_file, values_type) -> dict:
+    """Build the ``{"values": ...}`` payload for a ``set-*-values`` command.
+
+    Content comes from exactly one of ``--data`` or ``--values-file``. A
+    ``--values-file`` is read as a markdown string, or parsed as a JSON Slate
+    body when ``--values-type`` is not ``markdown`` (packing slateJson as a raw
+    string sends a string where the platform expects a list, which it silently
+    drops, so a malformed file must fail loudly). On any usage error this prints
+    to stderr and exits non-zero, matching the rest of the CLI.
+
+    Args:
+        data_input: The ``--data`` flag value (or None).
+        values_file: The ``--values-file`` path (or None).
+        values_type: The ``--values-type`` value (e.g. "markdown", "slateJson").
+
+    Returns:
+        A dict with a ``values`` key, ready for the command's id/valuesType keys.
+    """
+    import click
+
+    if not data_input and not values_file:
+        click.echo("Provide either --data or --values-file.", err=True)
+        sys.exit(1)
+    if data_input and values_file:
+        click.echo("--data and --values-file are mutually exclusive.", err=True)
+        sys.exit(1)
+
+    if values_file:
+        raw = Path(values_file).read_text()
+        if values_type == "markdown":
+            values = raw
+        else:
+            try:
+                values = json.loads(raw)
+            except json.JSONDecodeError as e:
+                click.echo(
+                    f"--values-file expects a JSON Slate body for --values-type "
+                    f"slateJson, but {values_file} is not valid JSON: {e}",
+                    err=True,
+                )
+                sys.exit(1)
+        return {"values": values}
+
+    try:
+        data = parse_data(data_input)
+    except Exception as e:
+        click.echo(str(e), err=True)
+        sys.exit(1)
+    if "values" not in data:
+        click.echo("--data must include a 'values' key.", err=True)
+        sys.exit(1)
+    return data
+
+
 def validate_entry_data(data: dict) -> dict:
     """Reject entry payloads that put ff_* keys at the top level.
 
@@ -88,6 +142,87 @@ def handle_error(ctx, e) -> None:
     sys.exit(exit_code)
 
 
+def _resolve_id(data: dict, id_keys) -> str:
+    """Return the first non-empty id value among id_keys, or ''."""
+    for key in id_keys:
+        value = (data or {}).get(key)
+        if value:
+            return value
+    return ""
+
+
+_RESULT_ID_KEYS = ("id", "entryId", "entry_id", "assetId", "asset_id")
+
+
+def _envelope_error_message(error) -> str:
+    """Extract a human-readable message from a native-tool error envelope.
+
+    `error` is the unified envelope dict ({error_code, message, ...}) on most
+    failures, but tolerate a bare string or missing value too.
+    """
+    if isinstance(error, dict):
+        return error.get("message") or error.get("error_code") or "Operation failed"
+    if error:
+        return str(error)
+    return "Operation failed"
+
+
+def emit_action_result(ctx, result: dict, *, label: str, id_keys=_RESULT_ID_KEYS) -> None:
+    """Print the outcome of a create/update mutation, honoring --quiet/--json.
+
+    quiet : print only the resolved id (one line); nothing else.
+    json  : print the full compact envelope.
+    human : print "<label>: <id>".
+
+    A native-tool envelope can report failure with HTTP 200
+    ({"success": false, "error": {...}}); surface that error and exit non-zero
+    instead of printing an empty id.
+    """
+    import click
+
+    from src.formatters.json_fmt import format_json
+
+    if result.get("success") is False:
+        if ctx.json_mode:
+            click.echo(format_json(result, compact=True), err=True)
+        else:
+            click.echo(f"{label} failed: {_envelope_error_message(result.get('error'))}", err=True)
+        sys.exit(1)
+        return
+
+    if getattr(ctx, "quiet_mode", False):
+        rid = _resolve_id(result.get("data", {}), id_keys)
+        if rid:
+            click.echo(rid)
+        return
+    if ctx.json_mode:
+        click.echo(format_json(result, compact=True))
+    else:
+        rid = _resolve_id(result.get("data", {}), id_keys)
+        click.echo(f"{label}: {rid}")
+
+
+def emit_dry_run(ctx, *, summary: str, payload: dict) -> None:
+    """Print a dry-run preview, honoring --quiet/--json.
+
+    quiet : print only the one-line summary (no body).
+    json  : print {"dry_run": true, "payload": ...} compact.
+    human : print the summary line followed by the pretty payload.
+    """
+    import click
+
+    from src.formatters.json_fmt import format_json
+
+    if getattr(ctx, "quiet_mode", False):
+        click.echo(f"[dry-run] {summary}")
+        return
+    if ctx.json_mode:
+        click.echo(format_json({"dry_run": True, "payload": payload}, compact=True))
+    else:
+        click.echo(f"[dry-run] {summary}")
+        click.echo(format_json(payload))
+
+
 def make_client(ctx):
     """Create an UpscalerClient from CLI context.
 

src/cli/list_cmd.py

@@ -116,10 +116,16 @@ def list_group():
 
 
 @list_group.command("definitions")
+@click.option("--limit", default=20, type=int, help="Max results to return (1-200).")
+@click.option("--offset", default=0, type=int, help="Offset for pagination.")
 @pass_context
-def list_definitions(ctx):
-    """List all definitions (registers, records)."""
-    _do_list(ctx, type_name="definitions")
+def list_definitions(ctx, limit, offset):
+    """List all definitions (registers, records).
+
+    Results are paginated; use --limit/--offset to page through, matching
+    `list entries`.
+    """
+    _do_list(ctx, type_name="definitions", limit=limit, offset=offset)
 
 
 @list_group.command("entries")
@@ -167,6 +173,16 @@ def list_definitions(ctx):
         "human label (case-insensitive). Implies --include-values."
     ),
 )
+@click.option(
+    "--fields",
+    "fields_csv",
+    default=None,
+    help=(
+        "Comma-separated field keys/labels to return under `values` "
+        "(e.g. --fields status,owner). Convenience alias for repeated "
+        "--select-value; both may be combined. Implies --include-values."
+    ),
+)
 @click.option(
     "--resolve-labels",
     is_flag=True,
@@ -187,6 +203,7 @@ def list_entries(
     offset,
     include_values,
     select_values_raw,
+    fields_csv,
     resolve_labels,
 ):
     """List entries for a definition with optional filtering and sorting."""
@@ -199,13 +216,19 @@ def list_entries(
 
     sort = _parse_sort(sort_raw) if sort_raw else None
 
+    # --fields is a comma-separated convenience alias for repeated
+    # --select-value; combine both into one projection spec list.
+    select_specs = list(select_values_raw)
+    if fields_csv:
+        select_specs.extend(f.strip() for f in fields_csv.split(",") if f.strip())
+
     schema_fields = None
-    if select_values_raw or resolve_labels:
+    if select_specs or resolve_labels:
         schema_fields = _fetch_schema_fields(ctx, definition_id)
 
     select_values = None
-    if select_values_raw:
-        select_values = _resolve_select_values(select_values_raw, schema_fields)
+    if select_specs:
+        select_values = _resolve_select_values(select_specs, schema_fields)
         include_values = True
 
     _do_list(

src/cli/main.py

@@ -6,7 +6,9 @@ Global flags:
     --json / --no-json   Output structured JSON to stdout. Default from
                          $UPSCALER_OUTPUT (set to 'json' to make JSON the
                          shell-wide default; --no-json forces human output
-                         when the env var is set).
+                         when the env var is set). Passing --json explicitly
+                         is always accepted and idempotent, even when the env
+                         var already makes JSON the default.
     --verbose            Log HTTP request/response to stderr
     --server             Override REST API server URL
     --profile NAME       Use a named profile (auth + config). Default: prod.
@@ -25,8 +27,7 @@ from src.profile import resolve_profile
 
 AGENT_SKILLS_URL = "https://github.com/upscaler-io/agent-skills"
 _VERSION_MESSAGE = (
-    f"%(prog)s %(version)s\n"
-    f"Agent skills: {AGENT_SKILLS_URL}/tree/{src.RECOMMENDED_SKILLS_REF}"
+    f"%(prog)s %(version)s\n" f"Agent skills: {AGENT_SKILLS_URL}/tree/{src.RECOMMENDED_SKILLS_REF}"
 )
 
 
@@ -34,27 +35,100 @@ def _default_json_mode():
     return os.environ.get("UPSCALER_OUTPUT", "").lower() == "json"
 
 
-@click.group(epilog=f"Agent skills for Upscaler: {AGENT_SKILLS_URL}")
+# Global options that GlobalFlagGroup accepts in any position. Boolean flags
+# take no value; value options carry the following token (or the --opt=value
+# form).
+_GLOBAL_BOOL_FLAGS = frozenset({"--json", "--no-json", "--quiet", "-q", "--verbose", "-v"})
+_GLOBAL_VALUE_OPTS = frozenset({"--server", "--profile"})
+
+
+def _hoist_global_options(args):
+    """Move the CLI's global options to the front of the argument list.
+
+    Click only consumes group-level options that appear before the subcommand,
+    so `upscaler health --json` fails with "No such option" even though
+    `upscaler --json health` works. Agents and people routinely place `--json`
+    (and friends) after the subcommand, so the root group hoists the known
+    global options to the front before Click parses the command.
+
+    Scanning stops at `--`, the end-of-options marker, leaving genuinely
+    positional arguments after it untouched. A global flag's literal spelling
+    passed as another option's value would be hoisted too; that pathological
+    case is not supported.
+    """
+    hoisted = []
+    rest = []
+    i = 0
+    n = len(args)
+    while i < n:
+        tok = args[i]
+        if tok == "--":
+            rest.extend(args[i:])
+            break
+        if tok in _GLOBAL_BOOL_FLAGS:
+            hoisted.append(tok)
+            i += 1
+        elif tok in _GLOBAL_VALUE_OPTS:
+            hoisted.append(tok)
+            if i + 1 < n:
+                hoisted.append(args[i + 1])
+                i += 2
+            else:
+                i += 1
+        elif "=" in tok and tok.split("=", 1)[0] in _GLOBAL_VALUE_OPTS:
+            hoisted.append(tok)
+            i += 1
+        else:
+            rest.append(tok)
+            i += 1
+    return hoisted + rest
+
+
+class GlobalFlagGroup(click.Group):
+    """Root group that accepts the CLI's global options in any position.
+
+    Global flags are defined on this group, which by default Click only parses
+    before the subcommand. Hoisting them (see _hoist_global_options) makes
+    `upscaler list entries --json` behave like `upscaler --json list entries`.
+    """
+
+    def parse_args(self, ctx, args):
+        return super().parse_args(ctx, _hoist_global_options(args))
+
+
+@click.group(cls=GlobalFlagGroup, epilog=f"Agent skills for Upscaler: {AGENT_SKILLS_URL}")
 @click.option(
     "--json/--no-json",
     "json_mode",
     default=_default_json_mode,
     help="Output structured JSON. Default from $UPSCALER_OUTPUT=json.",
 )
+@click.option(
+    "--quiet",
+    "-q",
+    "quiet_mode",
+    is_flag=True,
+    help="Print only the resulting id(s); suppress full payload/schema echo.",
+)
 @click.option("--verbose", "-v", is_flag=True, help="Log HTTP details to stderr.")
 @click.option("--server", default=None, help="Override REST API server URL.")
 @click.option(
     "--profile",
     default=None,
-    help="Profile name (own auth + config). Default: prod. "
-         "Overrides $UPSCALER_PROFILE.",
+    help="Profile name (own auth + config). Default: prod. " "Overrides $UPSCALER_PROFILE.",
 )
 @click.version_option(version=src.__version__, prog_name="upscaler", message=_VERSION_MESSAGE)
 @click.pass_context
-def cli(ctx, json_mode, verbose, server, profile):
-    """Upscaler CLI: search, retrieve, and manage documents, records, and workflows."""
+def cli(ctx, json_mode, quiet_mode, verbose, server, profile):
+    """Upscaler CLI: search, retrieve, and manage documents, records, and workflows.
+
+    Global flags (--json, --quiet, --profile, --server, --verbose) are options on
+    this top-level group but are accepted in any position, so both
+    `upscaler --json list entries ...` and `upscaler list entries --json` work.
+    """
     ctx.ensure_object(Context)
     ctx.obj.json_mode = json_mode
+    ctx.obj.quiet_mode = quiet_mode
     ctx.obj.verbose = verbose
     ctx.obj.server_url = server
     try:
@@ -86,8 +160,7 @@ def health(ctx):
     verify_ssl = config.resolve_verify_ssl()
     if not server_url:
         click.echo(
-            "Server URL not configured. "
-            "Use --server or: upscaler config set server_url <url>",
+            "Server URL not configured. " "Use --server or: upscaler config set server_url <url>",
             err=True,
         )
         sys.exit(1)
@@ -98,21 +171,30 @@ def health(ctx):
         )
         data = response.json()
         if ctx.obj.json_mode:
-            click.echo(json.dumps({
-                "success": True,
-                "status": data.get("status"),
-                "server": server_url,
-            }))
+            click.echo(
+                json.dumps(
+                    {
+                        "success": True,
+                        "status": data.get("status"),
+                        "server": server_url,
+                    }
+                )
+            )
         else:
             click.echo(f"Server: {server_url}")
             click.echo(f"Status: {data.get('status', 'unknown')}")
     except Exception as e:
         if ctx.obj.json_mode:
-            click.echo(json.dumps({
-                "success": False,
-                "error": str(e),
-                "server": server_url,
-            }), err=True)
+            click.echo(
+                json.dumps(
+                    {
+                        "success": False,
+                        "error": str(e),
+                        "server": server_url,
+                    }
+                ),
+                err=True,
+            )
         else:
             click.echo(f"Server: {server_url}")
             click.echo(f"Status: unreachable ({e})", err=True)

src/client.py

@@ -105,7 +105,17 @@ class UpscalerClient:
             raise APIError(f"Invalid JSON response from {path}", response.status_code)
 
         if response.status_code >= 400:
-            error_msg = result.get("error", f"HTTP {response.status_code}")
+            err = result.get("error")
+            if isinstance(err, dict):
+                # Unified error envelope ({error_code, message, ...}); pass a
+                # readable string to APIError, not the raw dict.
+                error_msg = (
+                    err.get("message")
+                    or err.get("error_code")
+                    or f"HTTP {response.status_code}"
+                )
+            else:
+                error_msg = err or f"HTTP {response.status_code}"
             raise APIError(error_msg, response.status_code)
 
         return result

{upscaler_cli-0.2.3.dev6696.dist-info → upscaler_cli-0.2.3.dev6697.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: upscaler-cli
-Version: 0.2.3.dev6696
+Version: 0.2.3.dev6697
 Summary: Upscaler CLI - search, retrieve, and manage documents, records, and workflows
 Requires-Python: >=3.10
 Requires-Dist: click>=8.0

{upscaler_cli-0.2.3.dev6696.dist-info → upscaler_cli-0.2.3.dev6697.dist-info}/RECORD

@@ -1,5 +1,5 @@
 src/__init__.py,sha256=uPUKlWJW1lQznOQiQGxfCjKn6GR6sNapNL-2ihXFIqs,272
-src/client.py,sha256=LCYw5lIxnTgMaCl-7lk6oAUR3ppc0myya1agGWaxY3I,4694
+src/client.py,sha256=uQbutI4MXPupXOIVUfKUIr_Z0PTM1W5uqDfjwxrvTZ8,5107
 src/config.py,sha256=nOfHEXnUnxLNIv6Ko1LVbrCtrJyvLpGDoe_m7qG_0tw,4803
 src/errors.py,sha256=BMaD32cmXavKfH6SdhsoD3jhBZgap-YpTWZC0IZO_Vo,832
 src/profile.py,sha256=XhCkmVhs_G-ELM6avTytrpTeJ-REoMgx6a-iSA-liOk,3918
@@ -9,20 +9,20 @@ src/auth/encryption.py,sha256=ct3pC9kW94LnfZN3puGf9_PeRHSvNzfwK78Yf_YuYo0,2397
 src/auth/oauth.py,sha256=PQ7Ov6LLkRYUyQp5lUuhFDBGIqQ-TGfLeaxqbn9qW6U,21213
 src/auth/token_store.py,sha256=oQOArbgTozxNyypz6KFhC7OJxee0xCsQIMML6Jy88CI,4005
 src/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-src/cli/asset.py,sha256=G7wN2qT_Ls_i17OIw8vRH9EhfxqWRyZpVoPAV573n4I,24277
+src/cli/asset.py,sha256=SouscANT7rmkRMrdjnoF4GJYS8-RvmkLQDk7drDJijU,29487
 src/cli/auth.py,sha256=N04ITXNrMfc8IvnjJDmgJRm3R5S62SdYDPm_s3tny9A,13976
 src/cli/automation.py,sha256=jwHaE2zfRJ-k5d1p2rwdrOrGe56pqsqKopxpW3IYaZU,7062
 src/cli/completions.py,sha256=skCxzy7h92Rt2a9xq_oFzWmf6ApaIGCVu0Dsc9TauYQ,786
 src/cli/config_cmd.py,sha256=qqQNRaDKdtGajpOyIx0qFFgAH5lJbbrOLNcc0Dhq_oQ,1186
-src/cli/context.py,sha256=H1doPOx9jShR78k9E52MfgFZNW_SOwQN0Pa5r6hdJMM,442
-src/cli/entry.py,sha256=O2J0hkl2h6_baBP-3JbbljMdBNY-N_9PajOXEUYCyx4,33040
+src/cli/context.py,sha256=uqL_EWjLcDLsFv2YmNBtJlFud5Jd1mJv63mZMu4eIuo,480
+src/cli/entry.py,sha256=WQba9TqUr4X8FYGeAhktu3iZpHGCfSgXVW-jb75D6tI,34728
 src/cli/files.py,sha256=g8yiX2Nr2Nbg3bFbSDucLKUNOBCBHokNwqOAV_XyFeM,2349
 src/cli/framework.py,sha256=XI5PU3oDbzzSJqPXkbuxkJxKoXaf6UbyzpRp23SD90M,14820
-src/cli/get.py,sha256=NA6Ms1HkqRH9TQ1_pyMBqPh3wwJQ75QwcFS3hKqZV9M,4436
-src/cli/helpers.py,sha256=3r2xRAbdVekOuViQGS-OLaxtrZG808xxk_UeX6YLogo,5442
+src/cli/get.py,sha256=40SVjx5aDcYT8Pj-TRuAUCcI5qEuPfTpRa3ZlOkeC2I,5261
+src/cli/helpers.py,sha256=o4iGNlxmm_cU4qtoJqrKgU4ZKm5FElXejsFSTRgaZ2U,10107
 src/cli/hierarchy.py,sha256=EUwkAMlstWqYI9dEazpmKAhDUMIM2qE3e8QTlvxYER8,1247
-src/cli/list_cmd.py,sha256=54iTA-8gH1mQbReBhK-DP8PYWNaphtepvVD8_71T9rA,12758
-src/cli/main.py,sha256=urKRmHGvGEGpnkatGm2pTYJJ0zAyI5eCdeFZTdx9k3A,5039
+src/cli/list_cmd.py,sha256=Ldo0Dw-e39wG0tVcOMxP_z0UlpPTjgtxsBpoX0jpKm4,13648
+src/cli/main.py,sha256=gDigKVHnSWIK7j7Up3CUeAtCaogiwxOcj2IoT1yrltE,8053
 src/cli/profile_cmd.py,sha256=jhBg_Ac63Mwbiz7tgjOZ263vaexoIyWwHnbzSmAWa_Y,3365
 src/cli/search.py,sha256=PfhWfULvglmwvp5Gm2XFA6Bu1yuiqkD-q7Muo1V7iGU,3735
 src/cli/todo.py,sha256=Y51t5vvP4LiKKDlqf4dTALIw6VAan0W4X3UEVMowGKA,3586
@@ -30,8 +30,8 @@ src/formatters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 src/formatters/json_fmt.py,sha256=S66lMzKTlfG5ImLOO1y7TCEvbAOsg-bIBmVaYX--zLs,1091
 src/formatters/table.py,sha256=rd2mHRIDpmiGH-QQnuwJWS4L0QC6cq7v14pe00GvKa4,1374
 src/formatters/tree.py,sha256=5rC58JqZvsQLq68v0WMcyl6dI2t0dyBPNI9CicBO0gg,1311
-upscaler_cli-0.2.3.dev6696.dist-info/METADATA,sha256=f7_szXuOoojU1FODa1FwMAhjF-jnsMUzE71P88JB5lY,601
-upscaler_cli-0.2.3.dev6696.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-upscaler_cli-0.2.3.dev6696.dist-info/entry_points.txt,sha256=fG1SBWk0NO-b7H3BTDlxANSf2a9mztWytQ08xeI6U8I,46
-upscaler_cli-0.2.3.dev6696.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
-upscaler_cli-0.2.3.dev6696.dist-info/RECORD,,
+upscaler_cli-0.2.3.dev6697.dist-info/METADATA,sha256=oUhv-oaCXbh-M0ELnTQ1_jAzIuqZAygitVhTcpNAST0,601
+upscaler_cli-0.2.3.dev6697.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+upscaler_cli-0.2.3.dev6697.dist-info/entry_points.txt,sha256=fG1SBWk0NO-b7H3BTDlxANSf2a9mztWytQ08xeI6U8I,46
+upscaler_cli-0.2.3.dev6697.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+upscaler_cli-0.2.3.dev6697.dist-info/RECORD,,