atlassian-cli 0.3.0__py3-none-any.whl

atlassian_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Atlassian Cloud CLI tools for Confluence and Jira."""
+
+__version__ = '0.3.0'

atlassian_cli/config.py

@@ -0,0 +1,57 @@
+"""Shared Atlassian Cloud configuration and session factory for atlassian_cli package."""
+
+import os
+import sys
+
+import requests
+from requests.auth import HTTPBasicAuth
+
+
+def load_env(path=None):
+    """Manually parse a .env file into a dict, skipping comments and blank lines."""
+    if path is None:
+        paths = [os.path.join(os.getcwd(), '.env'), os.path.join(os.path.dirname(__file__), '.env')]
+    else:
+        paths = [path]
+
+    for env_path in paths:
+        if os.path.exists(env_path):
+            with open(env_path, 'r') as file:
+                return dict(line.strip().split('=', 1) for line in file if not line.startswith('#') and '=' in line)
+    return {}
+
+
+def get_config():
+    """Return tuple (url, email, token) from .env or environment variables."""
+    env = load_env()
+    url = env.get('ATLASSIAN_URL', os.environ.get('ATLASSIAN_URL')) or \
+          env.get('CONFLUENCE_URL', os.environ.get('CONFLUENCE_URL'))
+    email = env.get('ATLASSIAN_EMAIL', os.environ.get('ATLASSIAN_EMAIL')) or \
+            env.get('CONFLUENCE_EMAIL', os.environ.get('CONFLUENCE_EMAIL'))
+    token = env.get('ATLASSIAN_TOKEN', os.environ.get('ATLASSIAN_TOKEN')) or \
+            env.get('CONFLUENCE_TOKEN', os.environ.get('CONFLUENCE_TOKEN'))
+
+    if not all([url, email, token]):
+        sys.stderr.write('ERR Missing ATLASSIAN_URL, ATLASSIAN_EMAIL, or ATLASSIAN_TOKEN\n'
+                         'Set them in .env or as environment variables.\n')
+        sys.exit(1)
+
+    return url.rstrip('/'), email, token
+
+
+def get_session(email, token):
+    """Create requests.Session with HTTPBasicAuth and JSON headers."""
+    session = requests.Session()
+    session.auth = HTTPBasicAuth(email, token)
+    session.headers.update({
+        'Accept': 'application/json',
+        'Content-Type': 'application/json'
+    })
+    return session
+
+
+def setup():
+    """Setup configuration and session, returning (session, base_url)."""
+    url, email, token = get_config()
+    session = get_session(email, token)
+    return session, url

atlassian_cli/conflu.py

@@ -0,0 +1,408 @@
+#!/usr/bin/env python3
+"""Confluence Cloud CLI — fast ADF page management via REST API v2.
+
+Commands:
+    get     Download a page (ADF + metadata)
+    put     Upload local ADF to Confluence
+    diff    Compare local vs remote ADF
+    sync    Bulk-download all pages in a space
+    search  Search local page index
+    index   Rebuild page-index.json from API
+"""
+
+import argparse
+import difflib
+import json
+import os
+import sys
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+from atlassian_cli.config import setup
+from atlassian_cli.http import APIError, api_get, api_put
+from atlassian_cli.output import emit, emit_error, set_json_mode
+
+V2 = '/wiki/api/v2'
+
+
+# ---------------------------------------------------------------------------
+# Confluence v2 methods
+# ---------------------------------------------------------------------------
+
+_space_cache = {}
+
+
+def get_page(session, base, page_id):
+    """Fetch a single page with ADF body."""
+    data = api_get(session, base, f'{V2}/pages/{page_id}',
+                   **{'body-format': 'atlas_doc_format'})
+    body = data.get('body', {}).get('atlas_doc_format', {})
+    if isinstance(body.get('value'), str):
+        try:
+            body['value'] = json.loads(body['value'])
+        except json.JSONDecodeError:
+            pass
+    return data
+
+
+def get_space(session, base, *, key=None, space_id=None):
+    """Look up a space by key or ID. Results are cached."""
+    if key and key in _space_cache:
+        return _space_cache[key]
+    if space_id and space_id in _space_cache:
+        return _space_cache[space_id]
+
+    if key:
+        data = api_get(session, base, f'{V2}/spaces', keys=key)
+        results = data.get('results', [])
+        if not results:
+            raise APIError(404, f'Space not found: {key}')
+        space = results[0]
+    elif space_id:
+        space = api_get(session, base, f'{V2}/spaces/{space_id}')
+    else:
+        raise ValueError('Provide key or space_id')
+
+    _space_cache[space.get('key', '')] = space
+    _space_cache[space['id']] = space
+    return space
+
+
+def list_pages(session, base, space_id):
+    """Cursor-paginated listing of all pages in a space."""
+    pages = []
+    url = f'{base}{V2}/spaces/{space_id}/pages?limit=250&sort=id'
+    while url:
+        resp = session.get(url)
+        resp.raise_for_status()
+        data = resp.json()
+        pages.extend(data.get('results', []))
+        next_link = data.get('_links', {}).get('next')
+        if next_link:
+            url = f'{base}{next_link}' if next_link.startswith('/') else next_link
+        else:
+            url = None
+    return pages
+
+
+# ---------------------------------------------------------------------------
+# Local file I/O
+# ---------------------------------------------------------------------------
+
+def _ver(page):
+    v = page.get('version', {})
+    return v.get('number', 0) if isinstance(v, dict) else int(v or 0)
+
+
+def _ver_ts(page):
+    v = page.get('version', {})
+    return v.get('createdAt', '') if isinstance(v, dict) else ''
+
+
+def save_page(page_data, space_key, pages_dir):
+    page_id = page_data['id']
+    space_dir = os.path.join(pages_dir, space_key)
+    os.makedirs(space_dir, exist_ok=True)
+
+    body = page_data.get('body', {}).get('atlas_doc_format', {}).get('value', {})
+    adf_path = os.path.join(space_dir, f'{page_id}.json')
+    with open(adf_path, 'w') as f:
+        json.dump(body, f, indent=2)
+
+    meta = {
+        'id': page_id,
+        'title': page_data.get('title', ''),
+        'spaceId': page_data.get('spaceId', ''),
+        'spaceKey': space_key,
+        'version': _ver(page_data),
+        'parentId': page_data.get('parentId', ''),
+        'updatedAt': _ver_ts(page_data),
+    }
+    meta_path = os.path.join(space_dir, f'{page_id}.meta.json')
+    with open(meta_path, 'w') as f:
+        json.dump(meta, f, indent=2)
+
+    return adf_path, meta_path
+
+
+def _find_page_file(page_id, pages_dir, suffix):
+    if not os.path.isdir(pages_dir):
+        return None
+    for entry in os.listdir(pages_dir):
+        candidate = os.path.join(pages_dir, entry, f'{page_id}{suffix}')
+        if os.path.isfile(candidate):
+            return candidate
+    return None
+
+
+def load_meta(page_id, pages_dir):
+    path = _find_page_file(page_id, pages_dir, '.meta.json')
+    if not path:
+        return None
+    with open(path) as f:
+        return json.load(f)
+
+
+def load_adf(page_id, pages_dir):
+    path = _find_page_file(page_id, pages_dir, '.json')
+    if not path:
+        return None
+    with open(path) as f:
+        return json.load(f)
+
+
+# ---------------------------------------------------------------------------
+# Commands
+# ---------------------------------------------------------------------------
+
+def cmd_get(args):
+    session, base = setup()
+    page = get_page(session, base, args.page_id)
+    space = get_space(session, base, space_id=page['spaceId'])
+    space_key = space.get('key', str(page['spaceId']))
+    adf_path, _ = save_page(page, space_key, args.dir)
+    emit('OK', f'{page["title"]} (v{_ver(page)}) -> {adf_path}')
+
+
+def cmd_put(args):
+    session, base = setup()
+
+    meta = load_meta(args.page_id, args.dir)
+    if not meta:
+        emit_error(f'No local metadata for page {args.page_id}')
+        sys.exit(1)
+    adf = load_adf(args.page_id, args.dir)
+    if not adf:
+        emit_error(f'No local ADF for page {args.page_id}')
+        sys.exit(1)
+
+    remote = get_page(session, base, args.page_id)
+    remote_ver = _ver(remote)
+    local_ver = meta.get('version', 0)
+
+    if not args.force and remote_ver != local_ver:
+        emit_error(f'Version conflict: local v{local_ver}, remote v{remote_ver}. Use --force to overwrite.')
+        sys.exit(1)
+
+    new_version = remote_ver + 1
+    result = api_put(session, base, f'{V2}/pages/{args.page_id}', {
+        'id': str(args.page_id),
+        'status': 'current',
+        'title': meta['title'],
+        'body': {
+            'representation': 'atlas_doc_format',
+            'value': json.dumps(adf),
+        },
+        'version': {
+            'number': new_version,
+            'message': 'Updated via confluence CLI',
+        },
+    })
+
+    meta['version'] = new_version
+    meta['updatedAt'] = _ver_ts(result)
+    space_key = meta.get('spaceKey', '')
+    meta_path = os.path.join(args.dir, space_key, f'{args.page_id}.meta.json')
+    with open(meta_path, 'w') as f:
+        json.dump(meta, f, indent=2)
+
+    emit('OK', f'{meta["title"]} updated to v{new_version}')
+
+
+def cmd_diff(args):
+    session, base = setup()
+
+    local_adf = load_adf(args.page_id, args.dir)
+    if not local_adf:
+        emit_error(f'No local ADF for page {args.page_id}')
+        sys.exit(1)
+
+    remote = get_page(session, base, args.page_id)
+    remote_adf = remote.get('body', {}).get('atlas_doc_format', {}).get('value', {})
+
+    local_lines = json.dumps(local_adf, indent=2, sort_keys=True).splitlines(keepends=True)
+    remote_lines = json.dumps(remote_adf, indent=2, sort_keys=True).splitlines(keepends=True)
+
+    diff = list(difflib.unified_diff(
+        local_lines, remote_lines,
+        fromfile=f'local/{args.page_id}.json',
+        tofile=f'remote/{args.page_id}',
+    ))
+    if diff:
+        sys.stdout.writelines(diff)
+    else:
+        meta = load_meta(args.page_id, args.dir) or {}
+        emit('OK', f'No differences — {meta.get("title", args.page_id)}')
+
+
+def cmd_sync(args):
+    session, base = setup()
+    space = get_space(session, base, key=args.space_key)
+    space_id = space['id']
+    space_key = space.get('key', args.space_key)
+
+    print(f'Listing pages in {space_key}…', file=sys.stderr)
+    pages = list_pages(session, base, space_id)
+    print(f'Found {len(pages)} pages', file=sys.stderr)
+
+    to_fetch = []
+    skipped = 0
+    for page in pages:
+        page_id = page['id']
+        remote_ver = _ver(page)
+        if not args.force:
+            meta = load_meta(page_id, args.dir)
+            if meta and meta.get('version', 0) >= remote_ver:
+                skipped += 1
+                continue
+        to_fetch.append(page)
+
+    if skipped:
+        print(f'SKIP {skipped} pages already up-to-date', file=sys.stderr)
+
+    if not to_fetch:
+        emit('DONE', f'{space_key}: {len(pages)} pages, all up-to-date')
+        return
+
+    print(f'Fetching {len(to_fetch)} pages ({args.workers} workers)…', file=sys.stderr)
+
+    errors = 0
+
+    def fetch_one(page):
+        nonlocal errors
+        page_id = page['id']
+        try:
+            full_page = get_page(session, base, page_id)
+            save_page(full_page, space_key, args.dir)
+            return f'GET {page_id} {full_page.get("title", "")} (v{_ver(full_page)})'
+        except Exception as e:
+            errors += 1
+            return f'ERR {page_id} {page.get("title", "")}: {e}'
+
+    with ThreadPoolExecutor(max_workers=args.workers) as pool:
+        futures = {pool.submit(fetch_one, p): p for p in to_fetch}
+        for future in as_completed(futures):
+            print(future.result())
+
+    emit('DONE', f'{space_key}: {len(to_fetch)} fetched, {skipped} skipped, {errors} errors')
+
+
+def cmd_search(args):
+    if not os.path.isfile(args.index):
+        emit_error(f'Index not found: {args.index}')
+        sys.exit(1)
+
+    with open(args.index) as f:
+        index = json.load(f)
+
+    query = args.query.lower()
+
+    if isinstance(index, dict):
+        flat = []
+        for space_key, pages in index.items():
+            for p in pages:
+                p.setdefault('spaceKey', space_key)
+                flat.append(p)
+    else:
+        flat = index
+
+    results = [
+        p for p in flat
+        if query in p.get('title', '').lower() or query in str(p.get('id', ''))
+    ]
+
+    for p in results:
+        print(f'{p["id"]} [{p.get("spaceKey", "?")}] {p.get("title", "")}')
+
+    if not results:
+        print('No results.', file=sys.stderr)
+
+
+def cmd_index(args):
+    session, base = setup()
+    spaces = args.space if args.space else ['POL', 'COMPLY']
+    index = {}
+
+    for space_key in spaces:
+        space = get_space(session, base, key=space_key)
+        space_id = space['id']
+        print(f'Indexing {space_key}…', file=sys.stderr)
+        pages = list_pages(session, base, space_id)
+
+        index[space_key] = []
+        for page in pages:
+            index[space_key].append({
+                'id': page['id'],
+                'title': page.get('title', ''),
+                'parentId': page.get('parentId', ''),
+                'version': _ver(page),
+                'updatedAt': _ver_ts(page),
+            })
+        print(f'  {space_key}: {len(pages)} pages', file=sys.stderr)
+
+    with open(args.output, 'w') as f:
+        json.dump(index, f, indent=2)
+
+    total = sum(len(v) for v in index.values())
+    emit('DONE', f'{total} pages indexed -> {args.output}')
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='confluence',
+        description='Confluence Cloud CLI — fast ADF page management',
+    )
+    parser.add_argument('--json', action='store_true', dest='json_output',
+                        help='Output as JSON for programmatic parsing')
+    sub = parser.add_subparsers(dest='command', required=True)
+
+    p = sub.add_parser('get', help='Download a page (ADF + metadata)')
+    p.add_argument('page_id', help='Confluence page ID')
+    p.add_argument('--dir', default='pages', help='Output directory (default: pages)')
+    p.set_defaults(func=cmd_get)
+
+    p = sub.add_parser('put', help='Upload local ADF to Confluence')
+    p.add_argument('page_id', help='Confluence page ID')
+    p.add_argument('--dir', default='pages', help='Pages directory (default: pages)')
+    p.add_argument('--force', action='store_true', help='Skip version conflict check')
+    p.set_defaults(func=cmd_put)
+
+    p = sub.add_parser('diff', help='Compare local vs remote ADF')
+    p.add_argument('page_id', help='Confluence page ID')
+    p.add_argument('--dir', default='pages', help='Pages directory (default: pages)')
+    p.set_defaults(func=cmd_diff)
+
+    p = sub.add_parser('sync', help='Bulk-download all pages in a space')
+    p.add_argument('space_key', help='Space key (e.g. POL, COMPLY)')
+    p.add_argument('--dir', default='pages', help='Output directory (default: pages)')
+    p.add_argument('--workers', type=int, default=10, help='Parallel workers (default: 10)')
+    p.add_argument('--force', action='store_true', help='Re-download all, ignore cache')
+    p.set_defaults(func=cmd_sync)
+
+    p = sub.add_parser('search', help='Search local page index')
+    p.add_argument('query', help='Search term (title or ID)')
+    p.add_argument('--index', default='page-index.json', help='Index file path')
+    p.set_defaults(func=cmd_search)
+
+    p = sub.add_parser('index', help='Rebuild page-index.json from API')
+    p.add_argument('--space', action='append', help='Space key(s) to index (default: POL COMPLY)')
+    p.add_argument('--output', default='page-index.json', help='Output file (default: page-index.json)')
+    p.set_defaults(func=cmd_index)
+
+    args = parser.parse_args()
+    if args.json_output:
+        set_json_mode(True)
+    try:
+        args.func(args)
+    except APIError as e:
+        emit_error(str(e))
+        sys.exit(1)
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+if __name__ == '__main__':
+    main()

atlassian_cli/http.py

@@ -0,0 +1,35 @@
+"""Shared HTTP helpers for API calls in the atlassian_cli package."""
+
+class APIError(Exception):
+    def __init__(self, status, body):
+        self.status = status
+        self.body = body
+
+    def __str__(self):
+        return f'HTTP {self.status}: {self.body[:200]}'
+
+def api_get(session, base, path, **params):
+    response = session.get(f'{base}{path}', params=params or None)
+    if response.ok:
+        return response.json()
+    raise APIError(response.status_code, response.text)
+
+def api_post(session, base, path, data):
+    response = session.post(f'{base}{path}', json=data)
+    if response.ok:
+        return response.json()
+    raise APIError(response.status_code, response.text)
+
+def api_put(session, base, path, data):
+    response = session.put(f'{base}{path}', json=data)
+    if response.ok:
+        return response.json()
+    raise APIError(response.status_code, response.text)
+
+def api_delete(session, base, path):
+    response = session.delete(f'{base}{path}')
+    if response.status_code == 204:
+        return None
+    elif response.ok:
+        return response.json()
+    raise APIError(response.status_code, response.text)

atlassian_cli/jira.py

@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+"""Jira CLI — issue and assets management via REST APIs.
+
+Commands:
+    issue       Jira issue operations (CRUD, search, transitions)
+    assets      Jira Assets/JSM operations (CRUD, schemas, types)
+"""
+
+import argparse
+import sys
+
+from atlassian_cli import jira_assets, jira_issues
+from atlassian_cli.http import APIError
+from atlassian_cli.output import emit_error, set_json_mode
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog='jira',
+        description='Jira CLI — issue and assets management',
+    )
+    parser.add_argument('--json', action='store_true', dest='json_output',
+                        help='Output as JSON for programmatic parsing')
+
+    sub = parser.add_subparsers(dest='domain', required=True)
+
+    # -----------------------------------------------------------------------
+    # issue subcommand
+    # -----------------------------------------------------------------------
+    issue_parser = sub.add_parser('issue', help='Jira issue operations')
+    issue_sub = issue_parser.add_subparsers(dest='command', required=True)
+
+    p = issue_sub.add_parser('get', help='Get issue details')
+    p.add_argument('key', help='Issue key (e.g. PROJ-123)')
+    p.set_defaults(func=jira_issues.cmd_get)
+
+    p = issue_sub.add_parser('create', help='Create an issue')
+    p.add_argument('project', help='Project key (e.g. PROJ)')
+    p.add_argument('type', help='Issue type (e.g. Task, Bug, Story)')
+    p.add_argument('summary', help='Issue summary/title')
+    p.add_argument('--description', help='Issue description')
+    p.add_argument('--labels', nargs='*', help='Labels')
+    p.add_argument('--assignee', help='Assignee account ID')
+    p.add_argument('--parent', help='Parent issue key (for sub-tasks)')
+    p.set_defaults(func=jira_issues.cmd_create)
+
+    p = issue_sub.add_parser('update', help='Update issue fields')
+    p.add_argument('key', help='Issue key')
+    p.add_argument('--summary', help='New summary')
+    p.add_argument('--description', help='New description')
+    p.add_argument('--labels', nargs='*', default=None, help='Replace labels')
+    p.add_argument('--assignee', help='Assignee account ID')
+    p.add_argument('--fields', help='JSON string of additional fields')
+    p.set_defaults(func=jira_issues.cmd_update)
+
+    p = issue_sub.add_parser('delete', help='Delete an issue')
+    p.add_argument('key', help='Issue key')
+    p.set_defaults(func=jira_issues.cmd_delete)
+
+    p = issue_sub.add_parser('search', help='Search issues with JQL')
+    p.add_argument('jql', help='JQL query string')
+    p.add_argument('--max', type=int, default=50, help='Max results (default: 50)')
+    p.add_argument('--fields', default='summary,status,assignee,issuetype',
+                   help='Comma-separated fields to return')
+    p.set_defaults(func=jira_issues.cmd_search)
+
+    p = issue_sub.add_parser('transition', help='Transition issue to new status')
+    p.add_argument('key', help='Issue key')
+    p.add_argument('status', help='Target status name')
+    p.set_defaults(func=jira_issues.cmd_transition)
+
+    p = issue_sub.add_parser('comment', help='Add a comment')
+    p.add_argument('key', help='Issue key')
+    p.add_argument('body', help='Comment text')
+    p.set_defaults(func=jira_issues.cmd_comment)
+
+    p = issue_sub.add_parser('comments', help='List comments')
+    p.add_argument('key', help='Issue key')
+    p.set_defaults(func=jira_issues.cmd_comments)
+
+    # -----------------------------------------------------------------------
+    # assets subcommand
+    # -----------------------------------------------------------------------
+    assets_parser = sub.add_parser('assets', help='Jira Assets (JSM) operations')
+    assets_sub = assets_parser.add_subparsers(dest='command', required=True)
+
+    p = assets_sub.add_parser('search', help='Search objects with AQL')
+    p.add_argument('aql', help='AQL query string')
+    p.add_argument('--max', type=int, default=50, help='Max results')
+    p.set_defaults(func=jira_assets.cmd_search)
+
+    p = assets_sub.add_parser('get', help='Get object by ID')
+    p.add_argument('id', help='Object ID')
+    p.set_defaults(func=jira_assets.cmd_get)
+
+    p = assets_sub.add_parser('create', help='Create an object')
+    p.add_argument('type_id', help='Object type ID')
+    p.add_argument('attrs', nargs='+', help='Attributes as key=value pairs')
+    p.set_defaults(func=jira_assets.cmd_create)
+
+    p = assets_sub.add_parser('update', help='Update an object')
+    p.add_argument('id', help='Object ID')
+    p.add_argument('attrs', nargs='+', help='Attributes as key=value pairs')
+    p.set_defaults(func=jira_assets.cmd_update)
+
+    p = assets_sub.add_parser('delete', help='Delete an object')
+    p.add_argument('id', help='Object ID')
+    p.set_defaults(func=jira_assets.cmd_delete)
+
+    p = assets_sub.add_parser('schemas', help='List object schemas')
+    p.set_defaults(func=jira_assets.cmd_schemas)
+
+    p = assets_sub.add_parser('schema', help='Get schema details')
+    p.add_argument('id', help='Schema ID')
+    p.set_defaults(func=jira_assets.cmd_schema)
+
+    p = assets_sub.add_parser('types', help='List object types in a schema')
+    p.add_argument('schema_id', help='Schema ID')
+    p.set_defaults(func=jira_assets.cmd_types)
+
+    p = assets_sub.add_parser('type', help='Get object type details')
+    p.add_argument('id', help='Object type ID')
+    p.set_defaults(func=jira_assets.cmd_type)
+
+    p = assets_sub.add_parser('type-create', help='Create object type')
+    p.add_argument('schema_id', help='Schema ID')
+    p.add_argument('name', help='Type name')
+    p.add_argument('--description', help='Type description')
+    p.add_argument('--parent-type-id', help='Parent object type ID')
+    p.set_defaults(func=jira_assets.cmd_type_create)
+
+    p = assets_sub.add_parser('attrs', help='List attributes for a type')
+    p.add_argument('type_id', help='Object type ID')
+    p.set_defaults(func=jira_assets.cmd_attrs)
+
+    args = parser.parse_args()
+    if args.json_output:
+        set_json_mode(True)
+    try:
+        args.func(args)
+    except APIError as e:
+        emit_error(str(e))
+        sys.exit(1)
+    except KeyboardInterrupt:
+        sys.exit(130)
+
+
+if __name__ == '__main__':
+    main()

atlassian_cli/jira_assets.py

@@ -0,0 +1,167 @@
+"""Jira Assets (JSM) commands — Assets REST API v1."""
+
+import json
+import os
+import sys
+
+from atlassian_cli.config import setup
+from atlassian_cli.http import APIError, api_delete, api_get, api_post, api_put
+from atlassian_cli.output import emit, emit_error, emit_json
+
+CACHE_FILE = '.atlassian-cache.json'
+
+
+def _discover(session, base):
+    """Discover cloudId and workspaceId. Results cached to disk."""
+    cache_path = os.path.join(os.getcwd(), CACHE_FILE)
+    if os.path.isfile(cache_path):
+        with open(cache_path) as f:
+            cache = json.load(f)
+        if cache.get('base') == base:
+            return cache['cloud_id'], cache['workspace_id']
+
+    # Step 1: cloudId
+    resp = session.get(f'{base}/_edge/tenant_info')
+    if not resp.ok:
+        raise APIError(resp.status_code, f'Failed to get cloudId: {resp.text}')
+    cloud_id = resp.json()['cloudId']
+
+    # Step 2: workspaceId
+    resp = session.get(f'{base}/rest/servicedeskapi/assets/workspace')
+    if not resp.ok:
+        raise APIError(resp.status_code, f'Failed to get workspaceId: {resp.text}')
+    workspace_id = resp.json()['values'][0]['workspaceId']
+
+    # Cache
+    with open(cache_path, 'w') as f:
+        json.dump({'base': base, 'cloud_id': cloud_id, 'workspace_id': workspace_id}, f)
+
+    return cloud_id, workspace_id
+
+
+def _assets_base(session, base):
+    """Return the Assets API base URL."""
+    _, workspace_id = _discover(session, base)
+    return f'https://api.atlassian.com/jsm/assets/workspace/{workspace_id}/v1'
+
+
+def assets_setup():
+    """Return (session, site_base, assets_base_url)."""
+    session, base = setup()
+    ab = _assets_base(session, base)
+    return session, base, ab
+
+
+def _parse_attrs(attr_list):
+    """Parse key=value pairs into Assets API attribute format."""
+    attrs = []
+    for pair in attr_list:
+        if '=' not in pair:
+            emit_error(f'Invalid attribute format: {pair} (expected key=value)')
+            sys.exit(1)
+        key, value = pair.split('=', 1)
+        attrs.append({
+            'objectTypeAttributeId': key,
+            'objectAttributeValues': [{'value': value}],
+        })
+    return attrs
+
+
+# Note: Assets API uses a different base URL (api.atlassian.com), so we pass
+# the full assets_base as 'base' and use relative paths.
+
+def cmd_search(args):
+    session, _, ab = assets_setup()
+    data = api_post(session, ab, '/object/aql', {
+        'qlQuery': args.aql,
+        'resultPerPage': args.max,
+        'includeAttributes': True,
+    })
+    objects = data.get('values', data.get('objectEntries', []))
+    for obj in objects:
+        otype = obj.get('objectType', {}).get('name', '?')
+        print(f'{obj["id"]} [{otype}] {obj.get("label", "")}')
+    emit('DONE', f'{len(objects)} objects found')
+
+
+def cmd_get(args):
+    session, _, ab = assets_setup()
+    data = api_get(session, ab, f'/object/{args.id}')
+    emit_json(data)
+
+
+def cmd_create(args):
+    session, _, ab = assets_setup()
+    data = api_post(session, ab, '/object/create', {
+        'objectTypeId': args.type_id,
+        'attributes': _parse_attrs(args.attrs),
+    })
+    emit('OK', f'Created object {data.get("id", "")} ({data.get("label", "")})')
+
+
+def cmd_update(args):
+    session, _, ab = assets_setup()
+    api_put(session, ab, f'/object/{args.id}', {
+        'attributes': _parse_attrs(args.attrs),
+    })
+    emit('OK', f'Updated object {args.id}')
+
+
+def cmd_delete(args):
+    session, _, ab = assets_setup()
+    api_delete(session, ab, f'/object/{args.id}')
+    emit('OK', f'Deleted object {args.id}')
+
+
+def cmd_schemas(args):
+    session, _, ab = assets_setup()
+    data = api_get(session, ab, '/objectschema/list')
+    schemas = data.get('values', data.get('objectschemas', []))
+    for s in schemas:
+        print(f'{s["id"]} {s["name"]}')
+    emit('DONE', f'{len(schemas)} schemas')
+
+
+def cmd_schema(args):
+    session, _, ab = assets_setup()
+    data = api_get(session, ab, f'/objectschema/{args.id}')
+    emit_json(data)
+
+
+def cmd_types(args):
+    session, _, ab = assets_setup()
+    data = api_get(session, ab, f'/objectschema/{args.schema_id}/objecttypes/flat')
+    types = data if isinstance(data, list) else data.get('values', [])
+    for t in types:
+        print(f'{t["id"]} {t["name"]}')
+    emit('DONE', f'{len(types)} types')
+
+
+def cmd_type(args):
+    session, _, ab = assets_setup()
+    data = api_get(session, ab, f'/objecttype/{args.id}')
+    emit_json(data)
+
+
+def cmd_type_create(args):
+    session, _, ab = assets_setup()
+    body = {'name': args.name, 'objectSchemaId': args.schema_id}
+    if hasattr(args, 'description') and args.description:
+        body['description'] = args.description
+    if hasattr(args, 'parent_type_id') and args.parent_type_id:
+        body['parentObjectTypeId'] = args.parent_type_id
+    data = api_post(session, ab, '/objecttype/create', body)
+    emit('OK', f'Created type {data.get("id", "")} ({args.name})')
+
+
+def cmd_attrs(args):
+    session, _, ab = assets_setup()
+    data = api_get(session, ab, f'/objecttype/{args.type_id}/attributes')
+    attrs = data if isinstance(data, list) else data.get('values', [])
+    for a in attrs:
+        req = '*' if a.get('minimumCardinality', 0) > 0 else ''
+        type_name = a.get('type', a.get('defaultType', {}).get('name', '?'))
+        if isinstance(type_name, dict):
+            type_name = type_name.get('name', '?')
+        print(f'{a["id"]} {a["name"]} ({type_name}) {req}'.rstrip())
+    emit('DONE', f'{len(attrs)} attributes')

atlassian_cli/jira_issues.py

@@ -0,0 +1,147 @@
+"""Jira Cloud issue commands — REST API v3."""
+
+import json
+import sys
+
+from atlassian_cli.config import setup
+from atlassian_cli.http import APIError, api_delete, api_get, api_post
+from atlassian_cli.output import emit, emit_error
+
+V3 = '/rest/api/3'
+
+
+def _extract_text(adf_body):
+    """Recursively extract plain text from an ADF body."""
+    def extract(node):
+        if node.get('type') == 'text':
+            return [node.get('text', '')]
+        parts = []
+        for child in node.get('content', []):
+            parts.extend(extract(child))
+        return parts
+    return ' '.join(extract(adf_body))
+
+
+def _text_adf(text):
+    """Wrap plain text in minimal ADF document."""
+    return {
+        'type': 'doc', 'version': 1,
+        'content': [{'type': 'paragraph', 'content': [{'type': 'text', 'text': text}]}],
+    }
+
+
+def cmd_get(args):
+    session, base = setup()
+    data = api_get(session, base, f'{V3}/issue/{args.key}')
+    fields = data.get('fields', {})
+    status = fields.get('status', {}).get('name', '?')
+    summary = fields.get('summary', '')
+    emit('OK', f'{data["key"]} [{status}] {summary}', data={'key': data['key'], 'id': data['id']})
+
+
+def cmd_create(args):
+    session, base = setup()
+    fields = {
+        'project': {'key': args.project},
+        'issuetype': {'name': args.type},
+        'summary': args.summary,
+    }
+    if args.description:
+        fields['description'] = _text_adf(args.description)
+    if args.labels:
+        fields['labels'] = args.labels
+    if args.assignee:
+        fields['assignee'] = {'accountId': args.assignee}
+    if args.parent:
+        fields['parent'] = {'key': args.parent}
+
+    result = api_post(session, base, f'{V3}/issue', {'fields': fields})
+    emit('OK', f'Created {result["key"]}', data=result)
+
+
+def cmd_update(args):
+    session, base = setup()
+    fields = {}
+    if args.summary:
+        fields['summary'] = args.summary
+    if args.description:
+        fields['description'] = _text_adf(args.description)
+    if args.labels is not None:
+        fields['labels'] = args.labels
+    if args.assignee:
+        fields['assignee'] = {'accountId': args.assignee}
+    if args.fields:
+        fields.update(json.loads(args.fields))
+
+    if not fields:
+        emit_error('No fields to update')
+        sys.exit(1)
+
+    # Jira PUT /issue returns 204 No Content on success
+    resp = session.put(f'{base}{V3}/issue/{args.key}', json={'fields': fields})
+    if not resp.ok:
+        raise APIError(resp.status_code, resp.text)
+    emit('OK', f'Updated {args.key}')
+
+
+def cmd_delete(args):
+    session, base = setup()
+    api_delete(session, base, f'{V3}/issue/{args.key}')
+    emit('OK', f'Deleted {args.key}')
+
+
+def cmd_search(args):
+    session, base = setup()
+    data = api_post(session, base, f'{V3}/search/jql', {
+        'jql': args.jql,
+        'maxResults': args.max,
+        'fields': args.fields.split(','),
+    })
+    issues = data.get('issues', [])
+    for issue in issues:
+        f = issue.get('fields', {})
+        status = f.get('status', {}).get('name', '?')
+        summary = f.get('summary', '')
+        print(f'{issue["key"]} [{status}] {summary}')
+    emit('DONE', f'{len(issues)} issues found')
+
+
+def cmd_transition(args):
+    session, base = setup()
+    data = api_get(session, base, f'{V3}/issue/{args.key}/transitions')
+    transitions = data.get('transitions', [])
+
+    target = None
+    for t in transitions:
+        if (t['name'].lower() == args.status.lower()
+                or t.get('to', {}).get('name', '').lower() == args.status.lower()):
+            target = t
+            break
+
+    if not target:
+        available = ', '.join(t['name'] for t in transitions)
+        emit_error(f'No transition to "{args.status}". Available: {available}')
+        sys.exit(1)
+
+    api_post(session, base, f'{V3}/issue/{args.key}/transitions',
+             {'transition': {'id': target['id']}})
+    emit('OK', f'{args.key} -> {target["to"]["name"]}')
+
+
+def cmd_comment(args):
+    session, base = setup()
+    api_post(session, base, f'{V3}/issue/{args.key}/comment',
+             {'body': _text_adf(args.body)})
+    emit('OK', f'Comment added to {args.key}')
+
+
+def cmd_comments(args):
+    session, base = setup()
+    data = api_get(session, base, f'{V3}/issue/{args.key}/comment')
+    comments = data.get('comments', [])
+    for c in comments:
+        author = c.get('author', {}).get('displayName', '?')
+        date = c.get('created', '')[:16]
+        text = _extract_text(c.get('body', {}))[:100]
+        print(f'{author} ({date}): {text}')
+    emit('DONE', f'{len(comments)} comments')

atlassian_cli/output.py

@@ -0,0 +1,28 @@
+"""Provides shared output formatting for atlassian_cli package with both text and JSON modes."""
+
+import json
+import sys
+
+_json_mode = False
+
+def set_json_mode(enabled: bool):
+    global _json_mode
+    _json_mode = enabled
+
+def emit(prefix, message, data=None):
+    if _json_mode:
+        output_data = {'status': prefix.lower(), 'message': message}
+        if data:
+            output_data.update(data)
+        print(json.dumps(output_data))
+    else:
+        print(f'{prefix} {message}')
+
+def emit_json(data):
+    print(json.dumps(data, indent=2))
+
+def emit_error(message):
+    if _json_mode:
+        print(json.dumps({'status': 'error', 'message': message}), file=sys.stderr)
+    else:
+        print(f'ERR {message}', file=sys.stderr)

atlassian_cli-0.3.0.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.4
+Name: atlassian-cli
+Version: 0.3.0
+Summary: Fast CLI tools for Atlassian Cloud (Confluence + Jira) — optimized for AI agents
+Author-email: Alex Fishlock <alex.fishlock@catapult.cx>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/catapultcx/atlassian-cli
+Project-URL: Repository, https://github.com/catapultcx/atlassian-cli
+Project-URL: Issues, https://github.com/catapultcx/atlassian-cli/issues
+Keywords: atlassian,confluence,jira,cli,claude,ai
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: responses>=0.23.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <h1 align="center">atlassian-cli</h1>
+  <p align="center">
+    Fast CLI tools for Atlassian Cloud — built for AI agents, loved by humans.
+  </p>
+</p>
+
+<p align="center">
+  <a href="https://github.com/catapultcx/atlassian-cli/actions/workflows/ci.yml"><img src="https://github.com/catapultcx/atlassian-cli/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
+  <a href="https://pypi.org/project/atlassian-cli/"><img src="https://img.shields.io/pypi/v/atlassian-cli" alt="PyPI"></a>
+  <a href="https://pypi.org/project/atlassian-cli/"><img src="https://img.shields.io/pypi/pyversions/atlassian-cli" alt="Python"></a>
+  <a href="https://github.com/catapultcx/atlassian-cli/blob/main/LICENSE"><img src="https://img.shields.io/github/license/catapultcx/atlassian-cli" alt="License"></a>
+</p>
+
+---
+
+Two CLI tools — `confluence` and `jira` — that talk directly to Atlassian Cloud REST APIs. Zero bloat, one dependency (`requests`), deterministic output that AI agents parse in a single shot.
+
+## Install
+
+```bash
+pip install atlassian-cli
+```
+
+Or from source:
+
+```bash
+pip install git+https://github.com/catapultcx/atlassian-cli.git
+```
+
+## Setup
+
+Create a `.env` file (or export environment variables):
+
+```bash
+ATLASSIAN_URL=https://your-site.atlassian.net
+ATLASSIAN_EMAIL=you@example.com
+ATLASSIAN_TOKEN=your-api-token
+```
+
+Get your API token at https://id.atlassian.com/manage-profile/security/api-tokens
+
+> Legacy `CONFLUENCE_URL` / `CONFLUENCE_EMAIL` / `CONFLUENCE_TOKEN` env vars are also supported.
+
+## Confluence CLI
+
+Manages Confluence pages as local JSON files in ADF (Atlassian Document Format). No markdown — ADF preserves every macro, panel, and table perfectly.
+
+```bash
+# Download a page
+confluence get 9268920323
+
+# Upload local edits back
+confluence put 9268920323
+confluence put 9268920323 --force          # skip version check
+
+# Compare local vs remote
+confluence diff 9268920323
+
+# Bulk-download an entire space (parallel, version-cached)
+confluence sync POL
+confluence sync COMPLY --workers 20 --force
+
+# Search local page index (instant, no API call)
+confluence search "risk assessment"
+
+# Rebuild the page index
+confluence index
+confluence index --space POL --space COMPLY
+```
+
+### How sync works
+
+`sync` downloads every page in a space using parallel workers. It caches version numbers locally — subsequent syncs only fetch pages that changed. A full space of 500+ pages takes seconds.
+
+```
+pages/
+  POL/
+    9268920323.json          # ADF body
+    9268920323.meta.json     # title, version, timestamps
+  COMPLY/
+    5227515611.json
+    5227515611.meta.json
+page-index.json              # searchable index
+```
+
+## Jira CLI
+
+### Issues
+
+Full CRUD on Jira issues via REST API v3.
+
+```bash
+# Get issue details
+jira issue get ISMS-42
+
+# Create issues
+jira issue create PROJ Task "Fix the login bug"
+jira issue create PROJ Story "User auth" --description "As a user..." --labels security urgent
+jira issue create PROJ Sub-task "Write tests" --parent PROJ-100
+
+# Update fields
+jira issue update ISMS-42 --summary "New title"
+jira issue update ISMS-42 --labels risk compliance
+jira issue update ISMS-42 --fields '{"priority": {"name": "High"}}'
+
+# Delete
+jira issue delete ISMS-42
+
+# Search with JQL
+jira issue search "project = ISMS AND status = Open"
+jira issue search "assignee = currentUser() ORDER BY updated DESC" --max 20
+
+# Transitions
+jira issue transition ISMS-42 "In Progress"
+jira issue transition ISMS-42 Done
+
+# Comments
+jira issue comment ISMS-42 "Fixed in v2.1"
+jira issue comments ISMS-42
+```
+
+### Assets (JSM)
+
+CRUD for Jira Service Management Assets via the Assets REST API v1.
+
+```bash
+# Browse schemas and types
+jira assets schemas
+jira assets schema 1
+jira assets types 1
+jira assets type 5
+jira assets attrs 5
+
+# Search with AQL
+jira assets search "objectType = Server"
+
+# CRUD objects
+jira assets get 123
+jira assets create 5 Name=srv01 IP=10.0.0.1
+jira assets update 123 Name=srv02
+jira assets delete 123
+
+# Create new object types
+jira assets type-create 1 "Network Device" --description "Switches and routers"
+```
+
+## `--json` flag
+
+Both CLIs accept a global `--json` flag that switches all output to machine-readable JSON. Perfect for piping into `jq` or parsing from code.
+
+```bash
+# Text mode (default)
+$ confluence get 9268920323
+OK Artificial Intelligence Policy (v12) -> pages/POL/9268920323.json
+
+# JSON mode
+$ confluence --json get 9268920323
+{"status":"ok","message":"Artificial Intelligence Policy (v12) -> pages/POL/9268920323.json"}
+```
+
+## Output format
+
+All commands emit status-prefixed lines for easy parsing:
+
+| Prefix | Meaning |
+|--------|---------|
+| `OK`   | Success |
+| `GET`  | Page downloaded |
+| `SKIP` | Already up-to-date |
+| `ERR`  | Error |
+| `DONE` | Batch complete |
+
+## Architecture
+
+```
+src/atlassian_cli/
+  config.py       Shared auth, .env parsing, session factory
+  http.py         API helpers: get/post/put/delete + error handling
+  output.py       Text & JSON output formatting
+  conflu.py       Confluence CLI (v2 API, ADF)
+  jira.py         Jira CLI entry point (subparsers)
+  jira_issues.py  Jira issue commands (v3 API)
+  jira_assets.py  Jira Assets commands (Assets v1 API)
+```
+
+**APIs used:**
+- Confluence Cloud REST API v2 (`/wiki/api/v2/`)
+- Jira Cloud REST API v3 (`/rest/api/3/`)
+- Jira Assets REST API v1 (`api.atlassian.com/jsm/assets/workspace/{id}/v1`)
+
+## Development
+
+```bash
+git clone https://github.com/catapultcx/atlassian-cli.git
+cd atlassian-cli
+python -m venv .venv && source .venv/bin/activate
+pip install -e ".[dev]"
+pytest
+ruff check src/ tests/
+```
+
+## License
+
+MIT

atlassian_cli-0.3.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+atlassian_cli/__init__.py,sha256=hEMtjMFFOG0MdzHtBqJD1Afot-rMkCFG1IfGTuXQ6jk,80
+atlassian_cli/config.py,sha256=RrKrhkIQrKYIveyDbNcK6hB7v85dJl5rXFTpZQDIrpU,2029
+atlassian_cli/conflu.py,sha256=A6PyWDmMobifFrIRwN2T9IZoM6Xl383epCFPAnhsexU,13422
+atlassian_cli/http.py,sha256=eKNR4MtNvO1I04_9SkIWSST7E1ql8mc8_OiYKABQ9_k,1147
+atlassian_cli/jira.py,sha256=GMdRTaJQxK0dGAUe1xqzkCzJBacAKNRXdviAs_D1iLg,6233
+atlassian_cli/jira_assets.py,sha256=sx9FbUjlhdzJeW_0aTh8epARVzwME65TUlLLw-GEFPY,5472
+atlassian_cli/jira_issues.py,sha256=C9K4-TJGvLdyK2VycJz1Q1BlmCTxpeYPPfwI6MnHirk,4589
+atlassian_cli/output.py,sha256=xC5e6L4UsnwMgqRHOv61ykr_ko8nS2k-FCVbESH2h8s,738
+atlassian_cli-0.3.0.dist-info/licenses/LICENSE,sha256=N2En73-GfhLh4N3JFemhxauOoYUoc0QLC1loMpwDnCg,1068
+atlassian_cli-0.3.0.dist-info/METADATA,sha256=wctTx1cyLqUZLgwNt8Hoh7nE8Ai3zas7mDo4nj2jLag,6840
+atlassian_cli-0.3.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+atlassian_cli-0.3.0.dist-info/entry_points.txt,sha256=fzzWod768AQuQu6s4ZQLWDdK9FVBfmgd3UHJUT19tWY,88
+atlassian_cli-0.3.0.dist-info/top_level.txt,sha256=QuHsUMDGmyPIe55UShDMrvDeOuMVIkBQvOx4lDYavJk,14
+atlassian_cli-0.3.0.dist-info/RECORD,,

atlassian_cli-0.3.0.dist-info/WHEEL

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

atlassian_cli-0.3.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+confluence = atlassian_cli.conflu:main
+jira = atlassian_cli.jira:main

atlassian_cli-0.3.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Catapult CX
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

atlassian_cli-0.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+atlassian_cli