jira-cli-toolkit 2.5.1__py3-none-any.whl

jsup/commands.py

@@ -0,0 +1,369 @@
+"""Command grammar shared by the new executable and legacy jsup commands."""
+from __future__ import annotations
+
+import argparse
+
+from . import __version__
+
+
+class CLIParser(argparse.ArgumentParser):
+    def parse_args(self, args=None, namespace=None):
+        if namespace is None:
+            namespace = argparse.Namespace()
+        # Seed the root namespace rather than setting defaults on inherited
+        # option actions, which argparse shares between parent/child parsers.
+        defaults = dict(project=None, site=None, email=None, token=None,
+                        json=False, no_input=False, profile=None, csv=False, columns=None)
+        for name, value in defaults.items():
+            if not hasattr(namespace, name):
+                setattr(namespace, name, value)
+        return super().parse_args(args, namespace)
+
+
+def positive_int(value: str) -> int:
+    number = int(value)
+    if number < 1:
+        raise argparse.ArgumentTypeError("must be greater than zero")
+    return number
+
+
+def _options(parser: argparse.ArgumentParser, operation: str) -> None:
+    """Define each operation once, including options shared by legacy aliases."""
+    lists = {"project-list", "board-list", "sprint-list", "comment-list", "open", "issue-list", "board-issues"}
+    if operation in lists:
+        parser.add_argument("--all", action="store_true", help="fetch every page; overrides --limit")
+        if operation not in {"open", "issue-list", "board-issues"}:
+            parser.add_argument("--limit", dest="max", type=positive_int, default=50)
+    if operation == "api":
+        parser.add_argument("path", metavar="PATH", help="Jira REST path, for example /rest/api/3/myself; or spec")
+        parser.add_argument("spec_action", metavar="ACTION", nargs="?", help="after spec: refresh or status")
+        parser.add_argument("-X", "--method", type=str.upper, default="GET",
+                            choices=["GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"])
+        parser.add_argument("--query", "-q", action="append", default=[], metavar="KEY=VALUE",
+                            help="query parameter; repeat for more, values are URL-encoded")
+        parser.add_argument("--header", "-H", action="append", default=[], metavar="'NAME: VALUE'",
+                            help="extra request header; auth, host and framing headers are managed")
+        parser.add_argument("--data", "-d", metavar="JSON|@FILE|@-", help="JSON body, sent unchanged")
+        parser.add_argument("--raw-data", metavar="TEXT|@FILE|@-", help="non-JSON body; needs --content-type")
+        parser.add_argument("--content-type", help="body media type for --data or --raw-data")
+        parser.add_argument("--form", "-F", action="append", default=[], metavar="NAME=VALUE|NAME=@FILE",
+                            help="multipart field or file; repeat for more")
+        parser.add_argument("--include", "-i", action="store_true", help="print response status and headers to stderr")
+        parser.add_argument("--output", "-o", metavar="FILE", help="save the response body to a new file")
+        parser.add_argument("--spec", action="store_true",
+                            help="describe the operation from cached official specs; sends no request")
+        return
+    if operation == "issue-edit":
+        parser.add_argument("key")
+        for name in ("summary", "priority", "due-date", "parent"):
+            parser.add_argument("--" + name)
+        parser.add_argument("--description", "--desc", dest="desc")
+        parser.add_argument("--description-file", dest="desc_file")
+        parser.add_argument("--editor", action="store_true")
+        parser.add_argument("--field", action="append", default=[])
+        parser.add_argument("--fields-file")
+        for collection in ("label", "component"):
+            for prefix in ("", "add-", "remove-"):
+                parser.add_argument("--" + prefix + collection, action="append", default=[])
+        return
+    if operation in {"issue-assign", "issue-unassign", "issue-link", "issue-unlink", "attachment-list", "attachment-upload", "attachment-download", "attachment-delete", "comment-edit", "comment-delete"}:
+        if operation in {"issue-unlink", "attachment-download", "attachment-delete"}:
+            parser.add_argument("id", type=positive_int)
+        else:
+            parser.add_argument("key")
+        if operation == "issue-assign":
+            parser.add_argument("--user", required=True, help="me, id:<account ID>, or unambiguous display name/email")
+        if operation == "issue-link":
+            parser.add_argument("other")
+            parser.add_argument("--type", required=True)
+            parser.add_argument("--direction", choices=["inward", "outward"], required=True)
+        if operation == "attachment-upload":
+            parser.add_argument("files", nargs="+")
+        if operation == "attachment-download":
+            parser.add_argument("--output", required=True, help="new file path or existing directory")
+        if operation in {"comment-edit", "comment-delete"}:
+            parser.add_argument("comment_id", type=positive_int)
+        if operation == "comment-edit":
+            parser.add_argument("--message", "-m")
+            parser.add_argument("--message-file")
+            parser.add_argument("--editor", action="store_true")
+        if operation in {"issue-unlink", "attachment-delete", "comment-delete"}:
+            parser.add_argument("--yes", action="store_true")
+        return
+    if operation == "dashboard":
+        parser.add_argument("--projects", nargs="+", help="project keys to summarize")
+    elif operation in {"project-show", "project-types", "project-fields", "project-statuses"}:
+        parser.add_argument("key", nargs="?")
+        if operation in {"project-types", "project-fields"}:
+            parser.add_argument("--refresh", action="store_true")
+        if operation == "project-fields":
+            parser.add_argument("--type", required=True)
+    elif operation == "issue-create":
+        legacy = parser._defaults.get("legacy", False)
+        parser.add_argument("--summary", "-s", required=legacy)
+        parser.add_argument("--description", "--desc", "-d", dest="desc", default="" if legacy else None)
+        parser.add_argument("--description-file", "--desc-file", dest="desc_file")
+        parser.add_argument("--type", "-t", default="Task" if legacy else None, help="issue type name or id:<ID>; guided selection when omitted")
+        parser.add_argument("--priority")
+        parser.add_argument("--assignee", help="Jira account ID")
+        parser.add_argument("--label", action="append", default=[])
+        parser.add_argument("--component", action="append", default=[])
+        if not legacy:
+            parser.add_argument("--parent")
+            parser.add_argument("--field", action="append", default=[])
+            parser.add_argument("--fields-file")
+            parser.add_argument("--editor", action="store_true")
+            parser.add_argument("--refresh", action="store_true")
+            parser.add_argument("--template", help="built-in/local template name or JSON path")
+            parser.add_argument("--var", action="append", default=[], help="template variable NAME=VALUE")
+    elif operation == "intake":
+        parser.add_argument("--name", help="client name")
+        parser.add_argument("--issue", help="issue as reported")
+        parser.add_argument("--callback", default="not specified")
+        parser.add_argument("--type", default="Task")
+        parser.add_argument("--priority", default="High")
+    elif operation in ("open", "issue-list"):
+        parser.add_argument("--jql", default="", help=(
+            "extra JQL appended to the open-ticket filter" if operation == "open"
+            else "complete JQL query; cannot be combined with --open or --project"))
+        parser.add_argument("--limit", "--max", dest="max", type=positive_int, default=50)
+        if operation == "issue-list":
+            parser.add_argument("--open", action="store_true", help="exclude the Done status category")
+            parser.add_argument("--assignee", help="account ID or me")
+            parser.add_argument("--status", action="append", default=[])
+            parser.add_argument("--type")
+            parser.add_argument("--label", action="append", default=[])
+            parser.add_argument("--board", type=positive_int)
+            parser.add_argument("--order-by", choices=["updated", "created", "priority", "key"], default="updated")
+            parser.add_argument("--order", choices=["asc", "desc"], default="desc")
+            parser.add_argument("--fields", help="comma-separated Jira field IDs")
+    elif operation in ("issue-show", "issue-move", "transitions", "issue-delete", "comment-add", "comment-list"):
+        parser.add_argument("key")
+        if operation == "issue-show":
+            parser.add_argument("--web", action="store_true")
+        elif operation == "issue-move":
+            parser.add_argument("--to", help="transition name or ID")
+            if not parser._defaults.get("legacy", False):
+                parser.add_argument("--field", action="append", default=[])
+                parser.add_argument("--fields-file")
+        elif operation == "issue-delete":
+            parser.add_argument("--yes", action="store_true", help="skip confirmation")
+        elif operation == "comment-add":
+            parser.add_argument("--message", "-m", required=parser._defaults.get("legacy", False))
+            parser.add_argument("--message-file")
+            parser.add_argument("--editor", action="store_true")
+    elif operation == "board-list":
+        parser.add_argument("--jql-project", help="legacy project-filter override")
+    elif operation == "board-create":
+        parser.add_argument("--name", required=True)
+        parser.add_argument("--jql")
+        parser.add_argument("--filter-id", type=positive_int)
+        parser.add_argument("--type", default="scrum", choices=["scrum", "kanban"])
+    elif operation in ("board-show", "board-issues", "board-feature"):
+        parser.add_argument("board_id", type=positive_int)
+        if operation == "board-show":
+            parser.add_argument("--web", action="store_true")
+        elif operation == "board-issues":
+            parser.add_argument("--jql", default="")
+            parser.add_argument("--limit", "--max", dest="max", type=positive_int, default=50)
+        else:
+            parser.add_argument("--feature", required=True)
+            if "enable" not in parser._defaults:
+                group = parser.add_mutually_exclusive_group(required=True)
+                group.add_argument("--enable", action="store_true")
+                group.add_argument("--disable", action="store_true")
+    elif operation in ("sprint-list", "sprint-create"):
+        parser.add_argument("--board", type=positive_int, required=parser._defaults.get("legacy", False))
+        if operation == "sprint-list":
+            parser.add_argument("--state", default="active,future")
+        else:
+            parser.add_argument("--name", required=True)
+            parser.add_argument("--goal", default="")
+    elif operation in ("sprint-state", "sprint-add"):
+        parser.add_argument("sprint_id", type=positive_int)
+        if operation == "sprint-add":
+            parser.add_argument("keys", nargs="+")
+        elif "state" not in parser._defaults:
+            parser.add_argument("state", choices=["active", "closed", "future"])
+    elif operation == "component-create":
+        parser.add_argument("--name", required=True)
+        parser.add_argument("--description", "--desc", dest="desc", default="")
+    elif operation == "browse":
+        parser.add_argument("target", help="issue key or board:<id>")
+
+
+LEGACY_COMMANDS = {
+    "me": "show authenticated user",
+    "project-list": "list projects",
+    "project-show": "show project details",
+    "issue-create": "create an issue",
+    "intake": "explicit legacy callback/support wizard",
+    "open": "list unfinished issues",
+    "issue-show": "show an issue",
+    "issue-move": "transition an issue",
+    "transitions": "list available transitions",
+    "issue-delete": "delete an issue",
+    "comment-add": "add a comment",
+    "comment-list": "list comments",
+    "board-list": "list boards",
+    "board-create": "create a board",
+    "board-issues": "list board issues",
+    "board-feature": "toggle a board feature",
+    "sprint-list": "list sprints",
+    "sprint-create": "create a sprint",
+    "sprint-state": "change sprint state",
+    "sprint-add": "add issues to a sprint",
+    "component-list": "list components",
+    "component-create": "create a component",
+    "browse": "open an issue or board in a browser",
+}
+
+
+def build_parser(prog: str = "jsup") -> argparse.ArgumentParser:
+    # Suppressed defaults on inherited options prevent a child parser from
+    # overwriting flags supplied earlier in the command line.
+    common = argparse.ArgumentParser(add_help=False, argument_default=argparse.SUPPRESS)
+    common.add_argument("--site")
+    common.add_argument("--email")
+    common.add_argument("--token")
+    common.add_argument("--project", "-p", help="project key")
+    common.add_argument("--profile", help="named identity; never mixed with identity flags")
+    output = common.add_mutually_exclusive_group()
+    output.add_argument("--json", action="store_true", help="JSON output")
+    output.add_argument("--csv", action="store_true", help="CSV output for lists")
+    common.add_argument("--columns", help="comma-separated list columns")
+    common.add_argument("--no-input", action="store_true", help="never prompt")
+    parser = CLIParser(
+        prog=prog, parents=[common], description="Jira CLI Toolkit — Jira Cloud from your terminal",
+        epilog=f"Examples: {prog} issue list -p ENG --open; {prog} help issue create",
+    )
+    parser.add_argument("--version", action="version", version=f"{prog} {__version__}")
+    parser.set_defaults(cmd=None, legacy=False, selected_parser=parser)
+    root = parser.add_subparsers(dest="command", title="commands")
+
+    def group(subparsers, name, help_text):
+        child = subparsers.add_parser(name, parents=[common], help=help_text)
+        child.set_defaults(selected_parser=child)
+        return child, child.add_subparsers(dest=f"{name}_action")
+
+    def command(subparsers, name, operation, help_text, **defaults):
+        child = subparsers.add_parser(name, parents=[common], help=help_text)
+        child.set_defaults(cmd=operation, selected_parser=child, **defaults)
+        _options(child, operation)
+        return child
+
+    helper = root.add_parser("help", help="show help for any command")
+    helper.add_argument("path", nargs="*", help="for example: issue comment add")
+    helper.set_defaults(cmd="help")
+    command(root, "dashboard", "dashboard", "summarize selected projects")
+    completion = command(root, "completion", "completion", "generate local shell completion")
+    completion.add_argument("shell", choices=["bash", "zsh", "fish"])
+    _, templates = group(root, "template", "inspect and validate reusable JSON templates")
+    command(templates, "list", "template-list", "list built-in and local templates")
+    for action in ("show", "validate"):
+        item = command(templates, action, "template-" + action, action + " a declarative template")
+        item.add_argument("template")
+        if action == "validate":
+            item.add_argument("--type")
+            item.add_argument("--var", action="append", default=[])
+            item.add_argument("--refresh", action="store_true")
+    updater = command(root, "update", "update", "check GitHub Releases or explicitly upgrade")
+    updater.add_argument("--check", action="store_true")
+    updater.add_argument("--info", action="store_true", help="local installation details, without network")
+    updater.add_argument("--version", help="requested release version")
+    updater.add_argument("--prerelease", action="store_true")
+    updater.add_argument("--allow-downgrade", action="store_true")
+    updater.add_argument("--yes", action="store_true")
+    _, config = group(root, "config", "set up and inspect local configuration")
+    command(config, "init", "config-init", "legacy credential setup")
+    command(config, "show", "config-show", "show saved configuration with token masked")
+    migrate = command(config, "migrate", "config-migrate", "migrate legacy credentials to a named profile")
+    migrate.add_argument("--storage", choices=["keyring", "file"], default="keyring")
+    for action in ("get", "set"):
+        pref = command(config, action, "config-"+action, "inspect or change a nonsecret preference")
+        pref.add_argument("key", choices=["project", "board"])
+        if action == "set":
+            pref.add_argument("value")
+    _, auth = group(root, "auth", "guided API-token login and credential health")
+    login = command(auth, "login", "auth-login", "validate and store an API token")
+    login.add_argument("--storage", choices=["keyring", "file"], default="keyring")
+    login.add_argument("--token-stdin", action="store_true")
+    login.add_argument("--scoped", action="store_true", help="token uses API scopes and the Atlassian gateway")
+    login.add_argument("--cloud-id", help="cloud ID for a scoped token")
+    command(auth, "status", "auth-status", "validate the selected identity with Jira")
+    command(auth, "logout", "auth-logout", "delete selected local credential; upstream tokens are not revoked")
+    _, profiles = group(root, "profile", "named site/account identities")
+    command(profiles, "list", "profile-list", "list saved profiles without reading secrets")
+    for action in ("use", "remove"):
+        item = command(profiles, action, "profile-"+action, "select or remove a profile")
+        item.add_argument("name")
+    command(root, "doctor", "doctor", "redacted connectivity, identity and project diagnostics")
+    _, context = group(root, "context", "inspect resolved local context")
+    command(context, "show", "context-show", "show site and project without contacting Jira")
+    use = command(context, "use", "context-use", "select a profile/project/board after checking access")
+    use.add_argument("--board", type=positive_int)
+    use.add_argument("--select", action="store_true", help="choose accessible projects and boards interactively")
+    _, user = group(root, "user", "user identity")
+    command(user, "me", "me", "show authenticated user")
+    _, projects = group(root, "project", "projects")
+    command(projects, "list", "project-list", "list accessible projects")
+    command(projects, "view", "project-show", "view a project")
+    command(projects, "issue-types", "project-types", "discover available issue types")
+    command(projects, "fields", "project-fields", "discover creation fields and required values")
+    command(projects, "statuses", "project-statuses", "show workflow statuses by issue type")
+    _, issues = group(root, "issue", "issue operations")
+    command(issues, "list", "issue-list", "search issues, optionally excluding Done")
+    command(issues, "create", "issue-create", "create an issue")
+    command(issues, "view", "issue-show", "view an issue or open it with --web")
+    command(issues, "transition", "issue-move", "choose or apply an available transition")
+    command(issues, "transitions", "transitions", "list available transitions")
+    command(issues, "delete", "issue-delete", "delete an issue after confirmation")
+    command(issues, "edit", "issue-edit", "update editable fields and collection values")
+    command(issues, "assign", "issue-assign", "assign an issue")
+    command(issues, "unassign", "issue-unassign", "clear the assignee")
+    command(issues, "link", "issue-link", "link two issues with explicit direction")
+    command(issues, "unlink", "issue-unlink", "delete a link after confirmation")
+    _, comments = group(issues, "comment", "issue comments")
+    command(comments, "add", "comment-add", "add a comment")
+    command(comments, "list", "comment-list", "list comments")
+    command(comments, "edit", "comment-edit", "edit a comment")
+    command(comments, "delete", "comment-delete", "delete a comment after confirmation")
+    _, attachments = group(issues, "attachment", "issue attachments")
+    for action in ("list", "upload", "download", "delete"):
+        command(attachments, action, "attachment-" + action, action + " attachments")
+    _, boards = group(root, "board", "board operations")
+    command(boards, "list", "board-list", "list boards")
+    command(boards, "create", "board-create", "create a filter and board")
+    command(boards, "view", "board-show", "view a board or open it with --web")
+    command(boards, "issues", "board-issues", "list issues on a board")
+    _, features = group(boards, "feature", "toggle board features")
+    command(features, "enable", "board-feature", "enable a feature", enable=True)
+    command(features, "disable", "board-feature", "disable a feature", enable=False)
+    _, sprints = group(root, "sprint", "sprint operations")
+    command(sprints, "list", "sprint-list", "list board sprints")
+    command(sprints, "create", "sprint-create", "create a sprint")
+    command(sprints, "start", "sprint-state", "start a sprint", state="active")
+    command(sprints, "close", "sprint-state", "close a sprint", state="closed")
+    edit = command(sprints, "edit", "sprint-state", "change sprint state", state=None)
+    edit.add_argument("--state", required=True, choices=["active", "closed", "future"])
+    command(sprints, "add-issues", "sprint-add", "add issues to a sprint")
+    _, components = group(root, "component", "project components")
+    command(components, "list", "component-list", "list components")
+    command(components, "create", "component-create", "create a component")
+    command(root, "api", "api", "call any Jira REST path with the selected identity")
+
+    for name, help_text in LEGACY_COMMANDS.items():
+        command(root, name, name, f"legacy: {help_text}", legacy=True)
+    return parser
+
+
+def help_parser(parser: argparse.ArgumentParser, path: list[str]) -> argparse.ArgumentParser:
+    """Resolve help paths through actual parser choices, including legacy names."""
+    current = parser
+    for part in path:
+        subparsers = next((action for action in current._actions
+                          if isinstance(action, argparse._SubParsersAction)), None)
+        if subparsers is None or part not in subparsers.choices:
+            parser.error(f"unknown help command: {' '.join(path)}")
+        current = subparsers.choices[part]
+    return current

jsup/completion.py

@@ -0,0 +1,56 @@
+"""Shell completions from the actual parser and local profile preferences only."""
+import argparse
+import shlex
+from .commands import build_parser
+from . import config
+
+
+def candidates(words,prog='jira'):
+    prefix=words[-1] if words else ''
+    previous=words[:-1]
+    parser=build_parser(prog)
+    awaiting=None
+    for word in previous:
+        if awaiting:
+            awaiting=None; continue
+        action=next((a for a in parser._actions if word in a.option_strings),None)
+        if action:
+            if action.nargs!=0: awaiting=word
+            continue
+        sub=next((a for a in parser._actions if isinstance(a,argparse._SubParsersAction)),None)
+        if sub and word in sub.choices: parser=sub.choices[word]
+    if awaiting:
+        if awaiting in ('--profile','--project','-p'):
+            try: data=config._read_file()
+            except (ValueError,OSError): return []
+            profiles=data.get('profiles',{})
+            values=profiles.keys() if awaiting=='--profile' else [p.get('project','') for p in profiles.values()]
+            return sorted(set(v for v in values if v and v.startswith(prefix)))
+        return []
+    options=[flag for action in parser._actions for flag in action.option_strings]
+    sub=next((a for a in parser._actions if isinstance(a,argparse._SubParsersAction)),None)
+    values=options+(list(sub.choices) if sub else [])
+    return sorted(v for v in values if v.startswith(prefix))
+
+
+def script(shell,prog):
+    command=shlex.quote(prog)
+    if shell=='bash':
+        return f'''_jira_cli_toolkit_complete() {{
+  local line
+  COMPREPLY=()
+  while IFS= read -r line; do COMPREPLY+=("$line"); done < <({command} --_complete "${{COMP_WORDS[@]:1}}")
+}}
+complete -F _jira_cli_toolkit_complete {command}
+'''
+    if shell=='zsh':
+        return f'''#compdef {prog}
+_jira_cli_toolkit_complete() {{
+  local -a candidates
+  candidates=("${{(@f)$({command} --_complete "${{words[@]:1}}")}}")
+  compadd -- "${{candidates[@]}}"
+}}
+compdef _jira_cli_toolkit_complete {command}
+'''
+    return f'''complete -c {command} -f -a '({command} --_complete (commandline -opc)[2..-1] (commandline -ct))'
+'''

jsup/config.py

@@ -0,0 +1,160 @@
+"""Config: CLI flags > env vars > ~/.config/jsup/config.json (mode 600)."""
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+from urllib.parse import urlsplit
+from pathlib import Path
+
+CONFIG_PATH = Path.home() / ".config" / "jsup" / "config.json"
+KEYS = ("JIRA_SITE", "JIRA_EMAIL", "JIRA_API_TOKEN", "JIRA_PROJECT")
+
+
+def _read_file() -> dict:
+    try:
+        data = json.loads(CONFIG_PATH.read_text(encoding="utf-8"))
+        if not isinstance(data, dict):
+            raise ValueError("Configuration must be a JSON object.")
+        return data
+    except FileNotFoundError:
+        return {}
+    except json.JSONDecodeError:
+        raise ValueError(f"Invalid configuration JSON in {CONFIG_PATH}; repair the file before continuing.") from None
+
+
+def atomic_json(path, data):
+    path.parent.mkdir(parents=True, exist_ok=True, mode=0o700)
+    fd, temp = tempfile.mkstemp(prefix=".jira-", dir=path.parent)
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8") as stream:
+            json.dump(data, stream, indent=2)
+            stream.write("\n")
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.chmod(temp, 0o600)
+        os.replace(temp, path)
+    finally:
+        if os.path.exists(temp):
+            os.unlink(temp)
+
+
+def validate_site(site):
+    url = urlsplit(site)
+    if url.scheme != "https" or not url.hostname or url.username or url.password or url.query or url.fragment or url.path not in ("", "/"):
+        raise ValueError("Use an HTTPS Jira site URL without credentials, a path, query, or fragment.")
+    return site.rstrip("/")
+
+
+def resolve_config(args, *, read_secret=True) -> dict:
+    """Resolve existing settings without requiring authentication or printing secrets."""
+    file_cfg = _read_file()
+    if file_cfg.get("schema_version") == 2:
+        from . import credentials
+        chosen = getattr(args, "profile", None) or os.getenv("JIRA_PROFILE")
+        explicit = [getattr(args, key, None) for key in ("site", "email", "token")]
+        env = [os.getenv(key) for key in ("JIRA_SITE", "JIRA_EMAIL", "JIRA_API_TOKEN")]
+        if chosen and any(explicit):
+            raise ValueError("--profile/JIRA_PROFILE cannot be combined with identity flags; select one identity source.")
+        source, values = None, None
+        if any(explicit):
+            if not all(explicit):
+                raise ValueError("Identity flags require --site, --email and --token together; saved credentials will not be mixed.")
+            source, values = "flags", explicit
+        elif not chosen and any(env):
+            if not all(env):
+                raise ValueError("Environment identity requires JIRA_SITE, JIRA_EMAIL and JIRA_API_TOKEN together.")
+            source, values = "environment", env
+        if values:
+            return dict(site=validate_site(values[0]), email=values[1], token=values[2],
+                        project=getattr(args, "project", None) or os.getenv("JIRA_PROJECT", ""),
+                        source=source, profile=None)
+        chosen = chosen or file_cfg.get("active_profile")
+        settings = file_cfg.get("profiles", {}).get(chosen)
+        if not settings:
+            if chosen:
+                raise ValueError(f"Unknown profile: {chosen}. Run profile list or auth login.")
+            return dict(site="", email="", token="", project="", source="none", profile=None)
+        site = validate_site(settings["site"])
+        allow_ui = sys.stdin.isatty() and not getattr(args, "no_input", False) and not getattr(args, "json", False)
+        result = dict(site=site, email=settings["email"], token=credentials.get(chosen, settings, CONFIG_PATH, allow_ui=allow_ui) if read_secret else "",
+                      project=getattr(args, "project", None) or os.getenv("JIRA_PROJECT") or settings.get("project", ""),
+                      board=settings.get("board"), profile=chosen, source=settings["storage"])
+        if settings.get("cloud_id"):
+            result["api_site"] = "https://api.atlassian.com/ex/jira/" + settings["cloud_id"]
+        return result
+    if getattr(args, "profile", None) or os.getenv("JIRA_PROFILE"):
+        raise ValueError("No named profiles exist yet. Run auth login or config migrate.")
+    cfg = {
+        "site": (getattr(args, "site", None) or os.getenv("JIRA_SITE")
+                 or file_cfg.get("JIRA_SITE", "")).rstrip("/"),
+        "email": (getattr(args, "email", None) or os.getenv("JIRA_EMAIL")
+                  or file_cfg.get("JIRA_EMAIL", "")),
+        "token": (getattr(args, "token", None) or os.getenv("JIRA_API_TOKEN")
+                  or file_cfg.get("JIRA_API_TOKEN", "")),
+        "project": (getattr(args, "project", None) or os.getenv("JIRA_PROJECT")
+                    or file_cfg.get("JIRA_PROJECT", "")),
+    }
+    cfg["source"] = ("flags" if any(getattr(args, key, None) for key in ("site", "email", "token"))
+                     else "environment" if any(os.getenv(k) for k in KEYS[:3]) else "legacy-config")
+    cfg["profile"] = None
+    return cfg
+
+
+def get_config(args) -> dict:
+    cfg = resolve_config(args)
+    if not (cfg["site"] and cfg["email"] and cfg["token"]):
+        print("Not configured yet. Run: jsup config init", file=sys.stderr)
+        sys.exit(2)
+    return cfg
+
+
+def init_config() -> None:
+    import getpass
+    cur = _read_file()
+    if cur.get("schema_version") == 2:
+        raise ValueError("Named profiles are configured. Use auth login instead of legacy config init.")
+    site = input(f"Jira site [{cur.get('JIRA_SITE') or os.getenv('JIRA_SITE', '')}]: ").strip() \
+        or cur.get("JIRA_SITE") or os.getenv("JIRA_SITE", "")
+    email = input(f"Email [{cur.get('JIRA_EMAIL') or os.getenv('JIRA_EMAIL', '')}]: ").strip() \
+        or cur.get("JIRA_EMAIL") or os.getenv("JIRA_EMAIL", "")
+    default_token = "*****" if (cur.get("JIRA_API_TOKEN") or os.getenv("JIRA_API_TOKEN")) else ""
+    token_in = getpass.getpass(f"API token [{default_token}]: ").strip()
+    token = token_in or cur.get("JIRA_API_TOKEN") or os.getenv("JIRA_API_TOKEN", "")
+    project = input(f"Default project [{cur.get('JIRA_PROJECT') or os.getenv('JIRA_PROJECT', '')}]: ").strip() \
+        or cur.get("JIRA_PROJECT") or os.getenv("JIRA_PROJECT", "")
+    if not (site and email and token):
+        print("site, email and token are required.", file=sys.stderr)
+        sys.exit(2)
+    atomic_json(CONFIG_PATH, {
+        "JIRA_SITE": site.rstrip("/"), "JIRA_EMAIL": email,
+        "JIRA_API_TOKEN": token, "JIRA_PROJECT": project,
+    })
+    print(f"Saved to {CONFIG_PATH} (mode 600). Try: jsup me")
+
+
+def show_config(as_json: bool = False) -> None:
+    cfg = _read_file()
+    if cfg.get("schema_version") == 2:
+        safe = {"file": str(CONFIG_PATH), "schema_version": 2,
+                "active_profile": cfg.get("active_profile"),
+                "profiles": {name: {k: v for k, v in settings.items() if k != "credential_id"}
+                             for name, settings in cfg.get("profiles", {}).items()}}
+        print(json.dumps(safe, indent=2))
+        return
+    if as_json:
+        print(json.dumps({"file": str(CONFIG_PATH), "site": cfg.get("JIRA_SITE") or None,
+                          "email": cfg.get("JIRA_EMAIL") or None,
+                          "project": cfg.get("JIRA_PROJECT") or None,
+                          "token_configured": bool(cfg.get("JIRA_API_TOKEN"))}, indent=2))
+        return
+    if not cfg:
+        print("No config file. Run: jsup config init")
+        return
+    tok = cfg.get("JIRA_API_TOKEN", "")
+    print(f"file:    {CONFIG_PATH}")
+    print(f"site:    {cfg.get('JIRA_SITE', '')}")
+    print(f"email:   {cfg.get('JIRA_EMAIL', '')}")
+    print(f"token:   {'*' * 8 + tok[-4:] if len(tok) > 4 else '(missing)'}")
+    print(f"project: {cfg.get('JIRA_PROJECT', '')}")