licos-platform-cli 0.2.4__tar.gz → 0.2.6__tar.gz

{licos_platform_cli-0.2.4 → licos_platform_cli-0.2.6}/.gitignore

@@ -33,17 +33,16 @@ Thumbs.db
 *.log
 *.pid
 .licos
+.tmp
 
 /tmp
-
-/Docs/hermes-agent
-/Docs/OpenCode
-/Docs/平台API
+tools/android-sdk-cache/*.zip
 
 *.codex-*
 
 dist
+logs
+
+source
 
-project-20260423_130440
-projects-20260425_workflow
-coze-skills
+平台API

{licos_platform_cli-0.2.4 → licos_platform_cli-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: licos-platform-cli
-Version: 0.2.4
+Version: 0.2.6
 Summary: LICOS platform CLI
 Requires-Python: >=3.10
-Requires-Dist: licos-platform-sdk>=0.2.3
+Requires-Dist: licos-platform-sdk>=0.2.5

{licos_platform_cli-0.2.4 → licos_platform_cli-0.2.6}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "hatchling.build"
 
 [project]
 name = "licos-platform-cli"
-version = "0.2.4"
-description = "LICOS platform CLI"
+version = "0.2.6"
+description = "LICOS platform CLI"
 requires-python = ">=3.10"
 dependencies = [
-    "licos-platform-sdk>=0.2.3",
+    "licos-platform-sdk>=0.2.5",
 ]
 
 [project.scripts]

{licos_platform_cli-0.2.4 → licos_platform_cli-0.2.6}/src/licos_platform_cli/database_commands.py

@@ -1,248 +1,295 @@
-from __future__ import annotations
-
-import argparse
-import json
-from typing import Any, Callable
-
-from licos_platform_sdk import database
-
-
-Handler = Callable[[argparse.Namespace], Any]
-
-
-def _set_handler(parser: argparse.ArgumentParser, handler: Handler) -> None:
-    parser.set_defaults(handler=handler)
-
-
-def _json_value(value: str) -> Any:
-    try:
-        return json.loads(value)
-    except json.JSONDecodeError:
-        return value
-
-
-def _json_object(value: str | None) -> dict[str, Any] | None:
-    if not value:
-        return None
-    parsed = _json_value(value)
-    if not isinstance(parsed, dict):
-        raise argparse.ArgumentTypeError("value must be a JSON object")
-    return parsed
-
-
-def _json_list(value: str | None) -> list[Any] | None:
-    if not value:
-        return None
-    parsed = _json_value(value)
-    if not isinstance(parsed, list):
-        raise argparse.ArgumentTypeError("value must be a JSON array")
-    return parsed
-
-
-def _filters(args: argparse.Namespace) -> list[dict[str, Any]] | None:
-    raw_filters = getattr(args, "filter", None) or []
-    filters = []
-    for item in raw_filters:
-        field, op, raw_value = item
-        filters.append({"field": field, "op": op, "value": _json_value(raw_value)})
-    return filters or None
-
-
-def _order_by(args: argparse.Namespace) -> list[dict[str, str]] | None:
-    raw_orders = getattr(args, "order", None) or []
-    orders = []
-    for item in raw_orders:
-        if ":" in item:
-            field, direction = item.rsplit(":", 1)
-        else:
-            field, direction = item, "asc"
-        orders.append({"field": field, "direction": direction})
-    return orders or None
-
-
-def _range(args: argparse.Namespace) -> dict[str, int] | None:
-    if not getattr(args, "range", None):
-        return None
-    start, end = args.range
-    return {"from": start, "to": end}
-
-
-def _query_options(args: argparse.Namespace) -> dict[str, Any]:
-    return {
-        "select": args.select,
-        "filters": _filters(args),
-        "order_by": _order_by(args),
-        "range": _range(args),
-        "limit": args.limit,
-        "offset": args.offset,
-        "count": args.count,
-        "head": args.head,
-    }
-
-
-def _cmd_query(args: argparse.Namespace) -> Any:
-    return database.query(args.table, **_query_options(args))
-
-
-def _cmd_single(args: argparse.Namespace) -> Any:
-    return database.single(
-        args.table,
-        maybe=args.maybe,
-        select=args.select,
-        filters=_filters(args),
-        order_by=_order_by(args),
-    )
-
-
-def _cmd_aggregate(args: argparse.Namespace) -> Any:
-    return database.aggregate(
-        args.table,
-        args.aggregate,
-        field=args.field,
-        group_by=args.group_by,
-        filters=_filters(args),
-    )
-
-
-def _cmd_insert(args: argparse.Namespace) -> Any:
-    if not args.row and not args.rows:
-        raise argparse.ArgumentTypeError("--row or --rows is required")
-    return database.insert(
-        args.table,
-        row=_json_object(args.row),
-        rows=_json_list(args.rows),
-        returning=not args.no_returning,
-    )
-
-
-def _cmd_update(args: argparse.Namespace) -> Any:
-    if not args.values and not args.updates:
-        raise argparse.ArgumentTypeError("--values or --updates is required")
-    return database.update(
-        args.table,
-        values=_json_object(args.values),
-        filters=_filters(args),
-        updates=_json_list(args.updates),
-        returning=not args.no_returning,
-    )
-
-
-def _cmd_delete_rows(args: argparse.Namespace) -> Any:
-    filters = _filters(args)
-    if not filters and not args.deletes:
-        raise argparse.ArgumentTypeError("--filter or --deletes is required")
-    return database.delete(
-        args.table,
-        filters=filters,
-        deletes=_json_list(args.deletes),
-        returning=not args.no_returning,
-    )
-
-
-def _cmd_upsert(args: argparse.Namespace) -> Any:
-    if not args.row and not args.rows:
-        raise argparse.ArgumentTypeError("--row or --rows is required")
-    return database.upsert(
-        args.table,
-        row=_json_object(args.row),
-        rows=_json_list(args.rows),
-        conflict_keys=args.conflict_keys,
-        returning=not args.no_returning,
-    )
-
-
-def _cmd_transaction(args: argparse.Namespace) -> Any:
-    operations = _json_list(args.operations)
-    if operations is None:
-        raise argparse.ArgumentTypeError("--operations is required")
-    return database.transaction(operations)
-
-
-def _cmd_rpc(args: argparse.Namespace) -> Any:
-    return database.rpc(args.function_name, args=_json_object(args.args) or {})
-
-
-def _add_filter_args(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument(
-        "--filter",
-        nargs=3,
-        action="append",
-        metavar=("FIELD", "OP", "VALUE"),
-        help="Add a filter. VALUE is parsed as JSON when possible.",
-    )
-
-
-def _add_query_args(parser: argparse.ArgumentParser) -> None:
-    parser.add_argument("--select", default=None, help="Comma-separated fields")
-    _add_filter_args(parser)
-    parser.add_argument("--order", action="append", default=[], help="Order by field or field:desc")
-    parser.add_argument("--range", nargs=2, type=int, metavar=("FROM", "TO"))
-    parser.add_argument("--limit", type=int, default=None)
-    parser.add_argument("--offset", type=int, default=None)
-    parser.add_argument("--count", action="store_true")
-    parser.add_argument("--head", action="store_true")
-
-
-def add_database_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
-    database_parser = subparsers.add_parser("database", help="Call LICOS runtime database APIs")
-    database_subparsers = database_parser.add_subparsers(dest="database_command", required=True)
-
-    query = database_subparsers.add_parser("query", help="Query rows")
-    query.add_argument("table")
-    _add_query_args(query)
-    _set_handler(query, _cmd_query)
-
-    single = database_subparsers.add_parser("single", help="Query a single row")
-    single.add_argument("table")
-    single.add_argument("--maybe", action="store_true", help="Allow zero rows")
-    single.add_argument("--select", default=None, help="Comma-separated fields")
-    _add_filter_args(single)
-    single.add_argument("--order", action="append", default=[], help="Order by field or field:desc")
-    _set_handler(single, _cmd_single)
-
-    aggregate = database_subparsers.add_parser("aggregate", help="Run aggregate query")
-    aggregate.add_argument("table")
-    aggregate.add_argument("aggregate")
-    aggregate.add_argument("--field", default=None)
-    aggregate.add_argument("--group-by", action="append", default=None)
-    _add_filter_args(aggregate)
-    _set_handler(aggregate, _cmd_aggregate)
-
-    insert = database_subparsers.add_parser("insert", help="Insert row(s)")
-    insert.add_argument("table")
-    insert.add_argument("--row", default=None, help="JSON object")
-    insert.add_argument("--rows", default=None, help="JSON array")
-    insert.add_argument("--no-returning", action="store_true")
-    _set_handler(insert, _cmd_insert)
-
-    update = database_subparsers.add_parser("update", help="Update row(s)")
-    update.add_argument("table")
-    update.add_argument("--values", default=None, help="JSON object")
-    update.add_argument("--updates", default=None, help="JSON array of mutation batches")
-    update.add_argument("--no-returning", action="store_true")
-    _add_filter_args(update)
-    _set_handler(update, _cmd_update)
-
-    delete_rows = database_subparsers.add_parser("delete-rows", help="Delete row(s)")
-    delete_rows.add_argument("table")
-    delete_rows.add_argument("--deletes", default=None, help="JSON array of mutation batches")
-    delete_rows.add_argument("--no-returning", action="store_true")
-    _add_filter_args(delete_rows)
-    _set_handler(delete_rows, _cmd_delete_rows)
-
-    upsert = database_subparsers.add_parser("upsert", help="Upsert row(s)")
-    upsert.add_argument("table")
-    upsert.add_argument("--row", default=None, help="JSON object")
-    upsert.add_argument("--rows", default=None, help="JSON array")
-    upsert.add_argument("--conflict-keys", action="append", default=None)
-    upsert.add_argument("--no-returning", action="store_true")
-    _set_handler(upsert, _cmd_upsert)
-
-    transaction = database_subparsers.add_parser("transaction", help="Run transaction")
-    transaction.add_argument("--operations", required=True, help="JSON array")
-    _set_handler(transaction, _cmd_transaction)
-
-    rpc = database_subparsers.add_parser("rpc", help="Call database function")
-    rpc.add_argument("function_name")
-    rpc.add_argument("--args", default=None, help="JSON object")
-    _set_handler(rpc, _cmd_rpc)
+from __future__ import annotations
+
+import argparse
+import json
+import os
+from pathlib import Path
+from typing import Any, Callable
+
+from licos_platform_sdk import database
+
+
+Handler = Callable[[argparse.Namespace], Any]
+
+
+def _set_handler(parser: argparse.ArgumentParser, handler: Handler) -> None:
+    parser.set_defaults(handler=handler)
+
+
+def _json_value(value: str) -> Any:
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError:
+        return value
+
+
+def _json_object(value: str | None) -> dict[str, Any] | None:
+    if not value:
+        return None
+    parsed = _json_value(value)
+    if not isinstance(parsed, dict):
+        raise argparse.ArgumentTypeError("value must be a JSON object")
+    return parsed
+
+
+def _json_list(value: str | None) -> list[Any] | None:
+    if not value:
+        return None
+    parsed = _json_value(value)
+    if not isinstance(parsed, list):
+        raise argparse.ArgumentTypeError("value must be a JSON array")
+    return parsed
+
+
+def _filters(args: argparse.Namespace) -> list[dict[str, Any]] | None:
+    raw_filters = getattr(args, "filter", None) or []
+    filters = []
+    for item in raw_filters:
+        field, op, raw_value = item
+        filters.append({"field": field, "op": op, "value": _json_value(raw_value)})
+    return filters or None
+
+
+def _order_by(args: argparse.Namespace) -> list[dict[str, str]] | None:
+    raw_orders = getattr(args, "order", None) or []
+    orders = []
+    for item in raw_orders:
+        if ":" in item:
+            field, direction = item.rsplit(":", 1)
+        else:
+            field, direction = item, "asc"
+        orders.append({"field": field, "direction": direction})
+    return orders or None
+
+
+def _range(args: argparse.Namespace) -> dict[str, int] | None:
+    if not getattr(args, "range", None):
+        return None
+    start, end = args.range
+    return {"from": start, "to": end}
+
+
+def _query_options(args: argparse.Namespace) -> dict[str, Any]:
+    return {
+        "select": args.select,
+        "filters": _filters(args),
+        "order_by": _order_by(args),
+        "range": _range(args),
+        "limit": args.limit,
+        "offset": args.offset,
+        "count": args.count,
+        "head": args.head,
+    }
+
+
+def _cmd_query(args: argparse.Namespace) -> Any:
+    return database.query(args.table, **_query_options(args))
+
+
+def _cmd_single(args: argparse.Namespace) -> Any:
+    return database.single(
+        args.table,
+        maybe=args.maybe,
+        select=args.select,
+        filters=_filters(args),
+        order_by=_order_by(args),
+    )
+
+
+def _cmd_aggregate(args: argparse.Namespace) -> Any:
+    return database.aggregate(
+        args.table,
+        args.aggregate,
+        field=args.field,
+        group_by=args.group_by,
+        filters=_filters(args),
+    )
+
+
+def _cmd_insert(args: argparse.Namespace) -> Any:
+    if not args.row and not args.rows:
+        raise argparse.ArgumentTypeError("--row or --rows is required")
+    return database.insert(
+        args.table,
+        row=_json_object(args.row),
+        rows=_json_list(args.rows),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_update(args: argparse.Namespace) -> Any:
+    if not args.values and not args.updates:
+        raise argparse.ArgumentTypeError("--values or --updates is required")
+    return database.update(
+        args.table,
+        values=_json_object(args.values),
+        filters=_filters(args),
+        updates=_json_list(args.updates),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_delete_rows(args: argparse.Namespace) -> Any:
+    filters = _filters(args)
+    if not filters and not args.deletes:
+        raise argparse.ArgumentTypeError("--filter or --deletes is required")
+    return database.delete(
+        args.table,
+        filters=filters,
+        deletes=_json_list(args.deletes),
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_upsert(args: argparse.Namespace) -> Any:
+    if not args.row and not args.rows:
+        raise argparse.ArgumentTypeError("--row or --rows is required")
+    return database.upsert(
+        args.table,
+        row=_json_object(args.row),
+        rows=_json_list(args.rows),
+        conflict_keys=args.conflict_keys,
+        returning=not args.no_returning,
+    )
+
+
+def _cmd_transaction(args: argparse.Namespace) -> Any:
+    operations = _json_list(args.operations)
+    if operations is None:
+        raise argparse.ArgumentTypeError("--operations is required")
+    return database.transaction(operations)
+
+
+def _cmd_rpc(args: argparse.Namespace) -> Any:
+    return database.rpc(args.function_name, args=_json_object(args.args) or {})
+
+
+def _cmd_schema(args: argparse.Namespace) -> Any:
+    return database.get_schema()
+
+
+def _cmd_export_orm(args: argparse.Namespace) -> Any:
+    try:
+        content = database.export_orm(language=args.language, orm=args.orm)
+        resolved_orm = args.orm or database.default_orm(args.language)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError(str(exc)) from exc
+
+    output_path = _resolve_project_output(args.out)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    output_path.write_text(content, encoding="utf-8")
+    return {
+        "language": args.language,
+        "orm": resolved_orm,
+        "path": str(output_path),
+        "bytes": len(content.encode("utf-8")),
+    }
+
+
+def _resolve_project_output(value: str) -> Path:
+    output_path = Path(value)
+    project_root = os.environ.get("LICOS_PROJECT_PATH")
+    if not project_root:
+        return output_path
+    root = Path(project_root).resolve()
+    resolved = (output_path if output_path.is_absolute() else Path.cwd() / output_path).resolve()
+    try:
+        resolved.relative_to(root)
+    except ValueError as exc:
+        raise argparse.ArgumentTypeError("--out must stay inside LICOS_PROJECT_PATH") from exc
+    return resolved
+
+
+def _add_filter_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--filter",
+        nargs=3,
+        action="append",
+        metavar=("FIELD", "OP", "VALUE"),
+        help="Add a filter. VALUE is parsed as JSON when possible.",
+    )
+
+
+def _add_query_args(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument("--select", default=None, help="Comma-separated fields")
+    _add_filter_args(parser)
+    parser.add_argument("--order", action="append", default=[], help="Order by field or field:desc")
+    parser.add_argument("--range", nargs=2, type=int, metavar=("FROM", "TO"))
+    parser.add_argument("--limit", type=int, default=None)
+    parser.add_argument("--offset", type=int, default=None)
+    parser.add_argument("--count", action="store_true")
+    parser.add_argument("--head", action="store_true")
+
+
+def add_database_parser(subparsers: argparse._SubParsersAction[argparse.ArgumentParser]) -> None:
+    database_parser = subparsers.add_parser("database", help="Call LICOS runtime database APIs")
+    database_subparsers = database_parser.add_subparsers(dest="database_command", required=True)
+
+    query = database_subparsers.add_parser("query", help="Query rows")
+    query.add_argument("table")
+    _add_query_args(query)
+    _set_handler(query, _cmd_query)
+
+    single = database_subparsers.add_parser("single", help="Query a single row")
+    single.add_argument("table")
+    single.add_argument("--maybe", action="store_true", help="Allow zero rows")
+    single.add_argument("--select", default=None, help="Comma-separated fields")
+    _add_filter_args(single)
+    single.add_argument("--order", action="append", default=[], help="Order by field or field:desc")
+    _set_handler(single, _cmd_single)
+
+    aggregate = database_subparsers.add_parser("aggregate", help="Run aggregate query")
+    aggregate.add_argument("table")
+    aggregate.add_argument("aggregate")
+    aggregate.add_argument("--field", default=None)
+    aggregate.add_argument("--group-by", action="append", default=None)
+    _add_filter_args(aggregate)
+    _set_handler(aggregate, _cmd_aggregate)
+
+    insert = database_subparsers.add_parser("insert", help="Insert row(s)")
+    insert.add_argument("table")
+    insert.add_argument("--row", default=None, help="JSON object")
+    insert.add_argument("--rows", default=None, help="JSON array")
+    insert.add_argument("--no-returning", action="store_true")
+    _set_handler(insert, _cmd_insert)
+
+    update = database_subparsers.add_parser("update", help="Update row(s)")
+    update.add_argument("table")
+    update.add_argument("--values", default=None, help="JSON object")
+    update.add_argument("--updates", default=None, help="JSON array of mutation batches")
+    update.add_argument("--no-returning", action="store_true")
+    _add_filter_args(update)
+    _set_handler(update, _cmd_update)
+
+    delete_rows = database_subparsers.add_parser("delete-rows", help="Delete row(s)")
+    delete_rows.add_argument("table")
+    delete_rows.add_argument("--deletes", default=None, help="JSON array of mutation batches")
+    delete_rows.add_argument("--no-returning", action="store_true")
+    _add_filter_args(delete_rows)
+    _set_handler(delete_rows, _cmd_delete_rows)
+
+    upsert = database_subparsers.add_parser("upsert", help="Upsert row(s)")
+    upsert.add_argument("table")
+    upsert.add_argument("--row", default=None, help="JSON object")
+    upsert.add_argument("--rows", default=None, help="JSON array")
+    upsert.add_argument("--conflict-keys", action="append", default=None)
+    upsert.add_argument("--no-returning", action="store_true")
+    _set_handler(upsert, _cmd_upsert)
+
+    transaction = database_subparsers.add_parser("transaction", help="Run transaction")
+    transaction.add_argument("--operations", required=True, help="JSON array")
+    _set_handler(transaction, _cmd_transaction)
+
+    rpc = database_subparsers.add_parser("rpc", help="Call database function")
+    rpc.add_argument("function_name")
+    rpc.add_argument("--args", default=None, help="JSON object")
+    _set_handler(rpc, _cmd_rpc)
+
+    schema = database_subparsers.add_parser("schema", help="Fetch database schema metadata")
+    _set_handler(schema, _cmd_schema)
+
+    export_orm = database_subparsers.add_parser("export-orm", help="Export ORM source from database schema metadata")
+    export_orm.add_argument("--language", required=True, choices=["typescript", "python"])
+    export_orm.add_argument("--orm", choices=["drizzle", "sqlalchemy"], default=None)
+    export_orm.add_argument("--out", required=True, help="Output source file path")
+    _set_handler(export_orm, _cmd_export_orm)