arch-insight-cli 0.1.0__py3-none-any.whl

arch_cli/__init__.py

@@ -0,0 +1,3 @@
+"""ARCH-Insight command-line client."""
+
+__version__ = "0.1.0"

arch_cli/main.py

@@ -0,0 +1,273 @@
+"""ARCH-Insight command-line client.
+
+Product API commands use a GoTrue access token (ARCH_ACCESS_TOKEN). Developer
+platform commands also accept the platform personal access token (ARCH_TOKEN).
+Secrets are delegated to the separately maintained arch-secrets package.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import secrets
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+from pathlib import Path
+
+DEFAULT_API = "https://arch-insight.com"
+TIMEOUT = 60
+
+
+class CliError(RuntimeError):
+    pass
+
+
+def _token(args) -> str:
+    token = (args.token or os.environ.get("ARCH_ACCESS_TOKEN")
+             or os.environ.get("ARCH_TOKEN") or "")
+    if not token:
+        raise CliError(
+            "No access token. Set ARCH_ACCESS_TOKEN to a GoTrue session token; "
+            "developer-platform commands also accept ARCH_TOKEN.")
+    return token.strip()
+
+
+def request(args, method: str, path: str, body=None, *, content_type="application/json"):
+    data = body
+    headers = {"Accept": "application/json", "User-Agent": f"arch-cli/{__import__('arch_cli').__version__}"}
+    if isinstance(body, (dict, list)):
+        data = json.dumps(body, ensure_ascii=False).encode("utf-8")
+        headers["Content-Type"] = "application/json"
+    elif isinstance(body, bytes):
+        headers["Content-Type"] = content_type
+    headers["Authorization"] = "Bearer " + _token(args)
+    url = args.api.rstrip("/") + path
+    req = urllib.request.Request(url, data=data, method=method, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=TIMEOUT) as response:
+            raw = response.read()
+            if not raw:
+                return {}
+            if "json" in response.headers.get("Content-Type", ""):
+                return json.loads(raw.decode("utf-8"))
+            return raw
+    except urllib.error.HTTPError as exc:
+        detail = exc.read().decode("utf-8", "replace")[:500]
+        if exc.code in (401, 403):
+            raise CliError("ARCH-Insight rejected the access token. Check its type, expiry, and account access.") from exc
+        raise CliError(f"{method} {path} returned HTTP {exc.code}: {detail}") from exc
+    except urllib.error.URLError as exc:
+        raise CliError(f"Could not reach {args.api}: {exc.reason}") from exc
+
+
+def emit(value) -> None:
+    print(json.dumps(value, ensure_ascii=False, indent=2, default=str))
+
+
+def task_create(args):
+    payload = {"title": args.title, "description": args.description,
+               "status": args.status, "priority": args.priority}
+    for field in ("project_id", "board_id", "factsheet_id", "due_date"):
+        value = getattr(args, field)
+        if value is not None:
+            payload[field] = value
+    if args.assignee:
+        payload["assignees"] = args.assignee
+    emit(request(args, "POST", "/api/agile/tasks", payload))
+
+
+def task_list(args):
+    query = ("?" + urllib.parse.urlencode({"project_id": args.project_id})
+             if args.project_id is not None else "")
+    emit(request(args, "GET", "/api/agile/tasks" + query))
+
+
+def factsheet_create(args):
+    payload = _read_json(args.file)
+    if not isinstance(payload, dict):
+        raise CliError("factsheet create expects one JSON object.")
+    emit(request(args, "POST", "/api/factsheets", payload))
+
+
+def factsheet_list(args):
+    emit(request(args, "GET", "/api/factsheets"))
+
+
+def _read_json(path: str):
+    try:
+        return json.loads(Path(path).read_text(encoding="utf-8"))
+    except OSError as exc:
+        raise CliError(f"Cannot read {path}: {exc}") from exc
+    except json.JSONDecodeError as exc:
+        raise CliError(f"Invalid JSON in {path}: {exc}") from exc
+
+
+def _multipart_file(path: Path) -> tuple[bytes, str]:
+    boundary = "archcli-" + secrets.token_hex(16)
+    filename = path.name.replace('"', "_")
+    content = path.read_bytes()
+    head = (f"--{boundary}\r\n"
+            f'Content-Disposition: form-data; name="file"; filename="{filename}"\r\n'
+            "Content-Type: application/zip\r\n\r\n").encode("utf-8")
+    body = head + content + f"\r\n--{boundary}--\r\n".encode("ascii")
+    return body, f"multipart/form-data; boundary={boundary}"
+
+
+def factsheet_import(args):
+    path = Path(args.file)
+    if not path.is_file():
+        raise CliError(f"File not found: {path}")
+    if path.suffix.lower() == ".zip":
+        body, content_type = _multipart_file(path)
+        emit(request(args, "POST", "/api/factsheets/import-zip", body,
+                     content_type=content_type))
+        return
+    payload = _read_json(str(path))
+    rows = payload if isinstance(payload, list) else [payload]
+    if not rows or any(not isinstance(row, dict) for row in rows):
+        raise CliError("JSON import must contain one fact-sheet object or a list of objects.")
+    # The API validates and creates each fact sheet. If an item fails, report
+    # its index; earlier successful creates remain in the account.
+    created = []
+    for index, row in enumerate(rows, start=1):
+        try:
+            created.append(request(args, "POST", "/api/factsheets", row))
+        except CliError as exc:
+            raise CliError(f"Import stopped at item {index}/{len(rows)} after {len(created)} created: {exc}") from exc
+    emit({"imported": len(created), "items": created})
+
+
+# Developer platform commands use the same API surface as devctl.
+def repo_create(args):
+    if "/" not in args.path:
+        raise CliError("Repository path must be <namespace>/<name>.")
+    namespace, name = args.path.split("/", 1)
+    row = request(args, "POST", "/api/platform/repos",
+                  {"namespace": namespace, "name": name, "description": args.description})
+    emit(row)
+
+
+def repo_list(args):
+    emit(request(args, "GET", "/api/platform/repos"))
+
+
+def pipeline_list(args):
+    query = ("?" + urllib.parse.urlencode({"repo_id": args.repo})
+             if args.repo is not None else "")
+    emit(request(args, "GET", "/api/platform/pipelines" + query))
+
+
+def pipeline_show(args):
+    emit(request(args, "GET", f"/api/platform/pipelines/{args.pipeline_id}"))
+
+
+def pipeline_cancel(args):
+    emit(request(args, "POST", f"/api/platform/pipelines/{args.pipeline_id}/cancel", {}))
+
+
+def pipeline_logs(args):
+    rows = request(args, "GET", f"/api/platform/jobs/{args.job_id}/logs")
+    for row in rows:
+        sys.stdout.write(row.get("content") or "")
+
+
+def registry_list(args):
+    emit(request(args, "GET", "/v2/_catalog"))
+
+
+def registry_tags(args):
+    emit(request(args, "GET", f"/v2/{urllib.parse.quote(args.repository, safe='/')}/tags/list"))
+
+
+def runner_list(args):
+    emit(request(args, "GET", "/api/platform/runners"))
+
+
+def deploy_list(args):
+    query = ("?" + urllib.parse.urlencode({"environment": args.environment})
+             if args.environment else "")
+    emit(request(args, "GET", "/api/platform/deployments" + query))
+
+
+def secrets_command(args):
+    from arch_secrets.main import main as secrets_main
+    forwarded = args.secrets_args
+    if forwarded and forwarded[0] == "--":
+        forwarded = forwarded[1:]
+    return secrets_main(forwarded)
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(prog="arch", description="ARCH-Insight from a terminal.")
+    parser.add_argument("--api", default=os.environ.get("ARCH_API_URL", DEFAULT_API),
+                        help="ARCH-Insight base URL")
+    parser.add_argument("--token", help="GoTrue access token; prefer ARCH_ACCESS_TOKEN")
+    areas = parser.add_subparsers(dest="area", required=True)
+
+    task = areas.add_parser("task", help="Manage Agile tasks").add_subparsers(dest="action", required=True)
+    make_task = task.add_parser("create", help="Create a task")
+    make_task.add_argument("title")
+    make_task.add_argument("--description")
+    make_task.add_argument("--status", choices=("todo", "in_progress", "done"), default="todo")
+    make_task.add_argument("--priority", choices=("low", "medium", "high"), default="medium")
+    make_task.add_argument("--project-id", type=int)
+    make_task.add_argument("--board-id", type=int)
+    make_task.add_argument("--factsheet-id", type=int)
+    make_task.add_argument("--due-date")
+    make_task.add_argument("--assignee", action="append", help="Assignee name; repeat for multiple people")
+    make_task.set_defaults(func=task_create)
+    list_task = task.add_parser("list")
+    list_task.add_argument("--project-id", type=int)
+    list_task.set_defaults(func=task_list)
+
+    factsheet = areas.add_parser("factsheet", help="Create, list, and import fact sheets").add_subparsers(dest="action", required=True)
+    make_fs = factsheet.add_parser("create", help="Create from one JSON object")
+    make_fs.add_argument("file", help="Fact sheet JSON file")
+    make_fs.set_defaults(func=factsheet_create)
+    import_fs = factsheet.add_parser("import", help="Import a JSON file or ARCH-Insight ZIP export")
+    import_fs.add_argument("file")
+    import_fs.set_defaults(func=factsheet_import)
+    factsheet.add_parser("list").set_defaults(func=factsheet_list)
+
+    secrets_parser = areas.add_parser("secrets", help="Fetch, export, or push vault secrets")
+    secrets_parser.add_argument("secrets_args", nargs=argparse.REMAINDER)
+    secrets_parser.set_defaults(func=secrets_command)
+
+    repo = areas.add_parser("repo", help="Manage developer-platform repositories").add_subparsers(dest="action", required=True)
+    create_repo = repo.add_parser("create"); create_repo.add_argument("path"); create_repo.add_argument("--description", default=""); create_repo.set_defaults(func=repo_create)
+    repo.add_parser("list").set_defaults(func=repo_list)
+
+    pipeline = areas.add_parser("pipeline", help="Inspect and control CI pipelines").add_subparsers(dest="action", required=True)
+    lp = pipeline.add_parser("list"); lp.add_argument("--repo", type=int); lp.set_defaults(func=pipeline_list)
+    sp = pipeline.add_parser("show"); sp.add_argument("pipeline_id", type=int); sp.set_defaults(func=pipeline_show)
+    cp = pipeline.add_parser("cancel"); cp.add_argument("pipeline_id", type=int); cp.set_defaults(func=pipeline_cancel)
+    jl = pipeline.add_parser("logs"); jl.add_argument("job_id", type=int); jl.set_defaults(func=pipeline_logs)
+
+    registry = areas.add_parser("registry", help="Inspect the container registry").add_subparsers(dest="action", required=True)
+    registry.add_parser("list").set_defaults(func=registry_list)
+    rt = registry.add_parser("tags"); rt.add_argument("repository"); rt.set_defaults(func=registry_tags)
+
+    runner = areas.add_parser("runner", help="List registered CI runners").add_subparsers(dest="action", required=True)
+    runner.add_parser("list").set_defaults(func=runner_list)
+
+    deploy = areas.add_parser("deploy", help="List deployments").add_subparsers(dest="action", required=True)
+    dl = deploy.add_parser("list"); dl.add_argument("environment", nargs="?", default=""); dl.set_defaults(func=deploy_list)
+    return parser
+
+
+def main(argv=None):
+    args = build_parser().parse_args(argv)
+    try:
+        result = args.func(args)
+        return result if isinstance(result, int) else 0
+    except CliError as exc:
+        print(f"arch: {exc}", file=sys.stderr)
+        return 2
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

arch_insight_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,94 @@
+Metadata-Version: 2.4
+Name: arch-insight-cli
+Version: 0.1.0
+Summary: Command-line client for ARCH-Insight tasks, factsheets, secrets, and developer platform.
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: arch-secrets>=1.1.1
+
+# arch-cli
+
+`arch-cli` is the ARCH-Insight command-line client. It includes commands for
+working with the product API, importing architecture data, managing the
+developer platform, and using the secrets vault.
+
+## Install
+
+```sh
+python -m pip install arch-insight-cli
+```
+
+The installed command is `arch` (also available as `arch-cli`). Python 3.9 or
+newer is required.
+
+## Authenticate
+
+Product commands such as tasks and fact sheets require a GoTrue user access
+token. Set it as `ARCH_ACCESS_TOKEN` or pass it with `--token`:
+
+```sh
+export ARCH_ACCESS_TOKEN='your-user-access-token'
+```
+
+Developer-platform commands also accept the platform token through
+`ARCH_TOKEN`. Set `ARCH_API_URL` to use a self-hosted deployment; the default
+is `https://arch-insight.com`.
+
+## Tasks
+
+```sh
+arch task create "Review database costs" \
+  --description "Check the quarterly forecast" \
+  --project-id 12 --board-id 4 --priority high \
+  --assignee "Alex Example" --due-date 2026-12-01
+
+arch task list --project-id 12
+```
+
+The create command prints the created task as JSON. Repeat `--assignee` to
+assign more than one person.
+
+## Fact sheets
+
+Create one fact sheet from JSON, import one or more JSON objects, or import an
+ARCH-Insight ZIP export:
+
+```sh
+arch factsheet create application.json
+arch factsheet import fact-sheets.json
+arch factsheet import archi_insight_export.zip
+arch factsheet list
+```
+
+JSON imports create rows one at a time through the same API used by the web
+app. If an item fails, earlier successful items remain created. ZIP imports use
+the application's import endpoint and report imported and skipped entries.
+
+## Secrets
+
+The dedicated `arch-secrets` command remains available. The same functionality
+can be reached through `arch secrets`:
+
+```sh
+export ARCH_SECRETS_TOKEN='your-vault-token'
+arch secrets run -- npm start
+arch secrets export > .env
+arch secrets push .env
+```
+
+The vault token is scoped independently from the user access token used by
+product commands.
+
+## Developer platform
+
+```sh
+arch repo list
+arch repo create team/sample --description "Example repository"
+arch pipeline list --repo 12
+arch pipeline show 42
+arch pipeline logs 99
+arch registry list
+arch registry tags team/sample
+arch runner list
+arch deploy list production
+```

arch_insight_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+arch_cli/__init__.py,sha256=nJROJiAYdnQudsRhZQDDEuBdFYDWghK6Pfr8Hk9Y8j8,63
+arch_cli/main.py,sha256=hkBFsRpwjWFpdrrQvaRFCwlwLGhQMbAm6NNWchXyajM,11312
+arch_insight_cli-0.1.0.dist-info/METADATA,sha256=D3wh3QodbX7mHUd4-U9aUQvHc7x92IqY2gf7d5tim8s,2618
+arch_insight_cli-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+arch_insight_cli-0.1.0.dist-info/entry_points.txt,sha256=-Gu60u5RdNZEOkKOd6zIadBslpAd2N1zJKgAMB-ENjg,74
+arch_insight_cli-0.1.0.dist-info/top_level.txt,sha256=B0NCScJnvAuzjddGyclArR5R_n9yV2hplUOufJImqSU,9
+arch_insight_cli-0.1.0.dist-info/RECORD,,

arch_insight_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

arch_insight_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+arch = arch_cli.main:main
+arch-cli = arch_cli.main:main

arch_insight_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+arch_cli