code-context-control 2.54.0__py3-none-any.whl → 2.56.0__py3-none-any.whl

cli/c3.py

@@ -92,7 +92,7 @@ console = Console() if HAS_RICH else None
 # Config
 CONFIG_DIR = ".c3"
 CONFIG_FILE = ".c3/config.json"
-__version__ = "2.54.0"
+__version__ = "2.55.0"
 
 
 def _command_deps() -> CommandDeps:
@@ -248,6 +248,7 @@ _C3_MCP_ALLOW = [
     "mcp__c3__c3_memory", "mcp__c3__c3_validate", "mcp__c3__c3_edit",
     "mcp__c3__c3_agent", "mcp__c3__c3_delegate", "mcp__c3__c3_edits",
     "mcp__c3__c3_impact", "mcp__c3__c3_shell", "mcp__c3__c3_bitbucket",
+    "mcp__c3__c3_jira",
     "mcp__c3__c3_project", "mcp__c3__c3_task", "mcp__c3__c3_artifacts",
 ]
 
@@ -5737,6 +5738,204 @@ def _bb_cmd_set_default(args, project_path: str) -> None:
     print(f"[OK] Default repo: {args.project}/{args.repo}")
 
 
+def cmd_jira(args):
+    """Jira Cloud / Data Center credential + workspace management."""
+    sub = getattr(args, "jira_cmd", None)
+    if not sub:
+        print("Usage: c3 jira {login,logout,status,use,set-default} [args]")
+        return
+
+    project_path = getattr(args, "project_path", ".") or "."
+
+    if sub == "login":
+        _jira_cmd_login(args, project_path)
+    elif sub == "logout":
+        _jira_cmd_logout(args, project_path)
+    elif sub == "status":
+        _jira_cmd_status(args, project_path)
+    elif sub == "use":
+        _jira_cmd_use(args, project_path)
+    elif sub == "set-default":
+        _jira_cmd_set_default(args, project_path)
+    else:
+        print(f"Unknown jira subcommand: {sub}")
+
+
+def _jira_deployment_for(args, base_url: str) -> str:
+    """Explicit --deployment wins; *.atlassian.net infers cloud; else unknown."""
+    dep = getattr(args, "deployment", "") or ""
+    if dep:
+        return dep
+    host = base_url.split("//", 1)[-1].split("/", 1)[0].lower()
+    if host.endswith(".atlassian.net") or host.endswith(".jira.com"):
+        return "cloud"
+    return ""
+
+
+def _jira_cmd_login(args, project_path: str) -> None:
+    import getpass
+
+    from services import jira_credentials as jr_creds
+    from services.jira_client import JiraClient, JiraError
+
+    # --global stores the account in ~/.c3/config.json so it is reusable in
+    # every C3 project (load_jira_config falls back to it automatically).
+    if getattr(args, "use_global", False):
+        project_path = str(Path.home())
+
+    base_url = (args.url or "").rstrip("/")
+    deployment = _jira_deployment_for(args, base_url)
+    if not deployment:
+        print("[error] --deployment cloud|data_center is required for self-hosted URLs.")
+        return
+    name = getattr(args, "name", "") or ""
+    if not name:
+        host = base_url.split("//", 1)[-1].split("/", 1)[0]
+        name = host.split(".")[0] or "default"
+
+    prompt_label = "Email" if deployment == "cloud" else "Username"
+    username = args.username or input(f"{prompt_label} for {base_url}: ").strip()
+    if not username:
+        print("Login cancelled -- username required.")
+        return
+    token_label = "API token" if deployment == "cloud" else "Personal Access Token"
+    token = args.token or getpass.getpass(f"{token_label} for {username}: ").strip()
+    if not token:
+        print("Login cancelled -- token required.")
+        return
+
+    try:
+        jr_creds.save_credentials(
+            name, base_url, username, token,
+            deployment=deployment,
+            project_path=project_path,
+            set_default=not getattr(args, "no_set_default", False),
+            verify_tls=not getattr(args, "insecure", False),
+            ca_bundle=getattr(args, "ca_bundle", "") or "",
+            allow_insecure=getattr(args, "insecure", False),
+        )
+    except jr_creds.JiraCredentialError as exc:
+        print(f"[error] {exc}")
+        return
+
+    scope = "global (~/.c3)" if getattr(args, "use_global", False) else "project"
+    print(f"[OK] Stored credentials for {username}@{base_url} as '{name}' [{deployment}, {scope}]")
+
+    # Connection probe -- skippable for offline setup (--no-verify-login) and
+    # non-fatal on failure (token might be valid but the network blocked).
+    if getattr(args, "no_verify_login", False):
+        print("     Connection probe skipped (--no-verify-login) -- verify later with `c3 jira status`.")
+        return
+    try:
+        client = JiraClient(
+            base_url, username, token,
+            deployment=deployment,
+            verify_tls=not getattr(args, "insecure", False),
+            ca_bundle=getattr(args, "ca_bundle", "") or "",
+        )
+        info = client.server_info()
+        print(f"     Server: Jira {info.get('version', '?')} ({base_url})")
+    except (JiraError, ValueError) as exc:
+        print(f"[warn] Connection probe failed: {exc}")
+        print("       Token saved anyway -- re-test with `c3 jira status`.")
+        return
+    try:
+        me = client.myself()
+        if me:
+            print(
+                f"     Auth as: {me.get('displayName', username)} "
+                f"<{me.get('emailAddress', '?')}>"
+            )
+    except JiraError:
+        pass
+
+
+def _jira_cmd_logout(args, project_path: str) -> None:
+    from core.config import load_jira_config
+    from services import jira_credentials as jr_creds
+
+    name = getattr(args, "name", "") or ""
+    if not name:
+        name = load_jira_config(project_path).get("default_account", "")
+    if not name:
+        print("[error] No account specified and no default account configured.")
+        return
+    removed = jr_creds.delete_credentials(name, project_path=project_path)
+    if removed:
+        print(f"[OK] Removed Jira account '{name}'")
+    else:
+        print(f"[warn] Nothing to remove for '{name}'")
+
+
+def _jira_cmd_status(args, project_path: str) -> None:
+    from core.config import load_jira_config
+    from services import jira_credentials as jr_creds
+    from services.jira_client import JiraClient, JiraError
+
+    cfg = load_jira_config(project_path)
+    accounts = cfg.get("accounts") or {}
+    default = cfg.get("default_account", "")
+
+    print("[jira:status]")
+    print(f"  Default : {default or '-'}")
+    print(f"  Accounts ({len(accounts)}):")
+    for acct_name, a in accounts.items():
+        if not isinstance(a, dict):
+            continue
+        marker = "*" if acct_name == default else " "
+        print(
+            f"    {marker} {acct_name}: {a.get('username', '?')}@{a.get('base_url', '?')} "
+            f"[{a.get('deployment', '?')}] project={a.get('default_project') or '-'}"
+        )
+
+    entry = accounts.get(default) if isinstance(accounts.get(default), dict) else None
+    if not entry:
+        print("  Connection: (no default account)")
+        return
+    token = jr_creds.load_token(entry.get("base_url", ""), entry.get("username", ""))
+    if not token:
+        print("  Connection: FAIL -- no token in keyring")
+        return
+    try:
+        client = JiraClient(
+            entry["base_url"], entry.get("username", ""), token,
+            deployment=entry.get("deployment", "cloud"),
+            verify_tls=bool(entry.get("verify_tls", True)),
+            ca_bundle=entry.get("ca_bundle", ""),
+        )
+        info = client.server_info()
+        me = client.myself()
+        print(
+            f"  Connection: OK (Jira {info.get('version', '?')} "
+            f"as {me.get('displayName', '?')})"
+        )
+    except (JiraError, ValueError) as exc:
+        print(f"  Connection: FAIL -- {exc}")
+
+
+def _jira_cmd_use(args, project_path: str) -> None:
+    from services import jira_credentials as jr_creds
+    try:
+        jr_creds.set_default_account(args.name, project_path=project_path)
+    except jr_creds.JiraCredentialError as exc:
+        print(f"[error] {exc}")
+        return
+    print(f"[OK] Default Jira account: {args.name}")
+
+
+def _jira_cmd_set_default(args, project_path: str) -> None:
+    from services import jira_credentials as jr_creds
+    try:
+        jr_creds.set_default_project(
+            args.project, name=getattr(args, "name", "") or "",
+            project_path=project_path,
+        )
+    except jr_creds.JiraCredentialError as exc:
+        print(f"[error] {exc}")
+        return
+    print(f"[OK] Default Jira project: {args.project}")
+
+
 def cmd_oracle(args):
     """Oracle dashboard server + Discovery API key management."""
     sub = getattr(args, "oracle_cmd", None)
@@ -6836,6 +7035,7 @@ def main():
         "sub": cmd_sub,
         "hub": cmd_hub,
         "bitbucket": cmd_bitbucket,
+        "jira": cmd_jira,
         "oracle": cmd_oracle,
         "upgrade": cmd_upgrade,
     }

cli/commands/parser.py

@@ -359,6 +359,48 @@ def build_parser(version: str, parse_cli_ide_arg):
     bb_default.add_argument("--repo", required=True, help="Repository slug")
     bb_default.add_argument("project_path", nargs="?", default=".")
 
+    # ── Jira Cloud / Data Center (v2.56.0) ──────────────────────────────
+    p_jira = subparsers.add_parser(
+        "jira",
+        help="Jira Cloud / Data Center credential + workspace management",
+    )
+    jira_subs = p_jira.add_subparsers(dest="jira_cmd")
+
+    jr_login = jira_subs.add_parser(
+        "login",
+        help="Authenticate with a Jira site (interactive token prompt)",
+    )
+    jr_login.add_argument("--url", required=True, help="Jira base URL (e.g. https://yoursite.atlassian.net)")
+    jr_login.add_argument("--deployment", choices=["cloud", "data_center"], default="", help="Deployment type (inferred as 'cloud' for *.atlassian.net URLs; required otherwise)")
+    jr_login.add_argument("--name", default="", help="Account name in the registry (default: derived from URL host)")
+    jr_login.add_argument("--username", help="Email (Cloud) or username (Data Center); prompted if omitted")
+    jr_login.add_argument("--token", help="API token (Cloud) / PAT (Data Center); prompted via getpass if omitted — preferred")
+    jr_login.add_argument("--no-set-default", action="store_true", help="Do not make this the default account")
+    jr_login.add_argument("--no-verify-login", action="store_true", help="Skip the connection probe (store credentials offline)")
+    jr_login.add_argument("--insecure", action="store_true", help="Disable TLS verification / allow http:// (local dev only)")
+    jr_login.add_argument("--ca-bundle", default="", help="Path to a custom CA bundle for self-signed enterprise certs")
+    jr_login.add_argument("--global", dest="use_global", action="store_true", help="Store the account in the global ~/.c3/config.json so it is reusable in every C3 project")
+    jr_login.add_argument("project_path", nargs="?", default=".")
+
+    jr_logout = jira_subs.add_parser("logout", help="Remove a Jira account from keyring + config")
+    jr_logout.add_argument("--name", default="", help="Account name (defaults to the default account)")
+    jr_logout.add_argument("project_path", nargs="?", default=".")
+
+    jr_status = jira_subs.add_parser("status", help="Show configured Jira accounts and connectivity")
+    jr_status.add_argument("project_path", nargs="?", default=".")
+
+    jr_use = jira_subs.add_parser("use", help="Switch the default Jira account")
+    jr_use.add_argument("--name", required=True, help="Registered account name")
+    jr_use.add_argument("project_path", nargs="?", default=".")
+
+    jr_default = jira_subs.add_parser(
+        "set-default",
+        help="Set the default Jira project key on an account",
+    )
+    jr_default.add_argument("--project", required=True, help="Jira project key (e.g. PROJ)")
+    jr_default.add_argument("--name", default="", help="Account name (defaults to the default account)")
+    jr_default.add_argument("project_path", nargs="?", default=".")
+
     # ── Oracle Discovery API (v2.32.0) ──────────────────────────────────
     p_oracle = subparsers.add_parser(
         "oracle",

cli/mcp_server.py

@@ -778,6 +778,50 @@ async def c3_bitbucket(
     )
 
 
+@mcp.tool()
+async def c3_jira(
+    action: str,
+    issue: str = "",
+    jql: str = "",
+    project: str = "",
+    issue_type: str = "",
+    summary: str = "",
+    description: str = "",
+    body: str = "",
+    body_format: str = "text",
+    transition: str = "",
+    user: str = "",
+    query: str = "",
+    fields: str = "",
+    status_category: str = "",
+    account: str = "",
+    cursor: str = "",
+    limit: int = 25,
+    ctx: Context = None,
+) -> str:
+    """JIRA (Cloud + Data Center) — search, read, create, comment, transition, assign issues.
+    actions: status, whoami, search (jql), get_issue (issue), my_issues,
+    list_projects, list_transitions (issue), get_create_metadata (project, issue_type),
+    search_users (query), create_issue (project, issue_type, summary [description] [fields=JSON]),
+    comment (issue, body), transition (issue, transition=id|name [body]), assign (issue, user).
+    project falls back to the account's default_project; account to jira.default_account.
+    Mutating actions are ledger-logged. Tokens live in the OS keyring — `c3 jira login` first."""
+    svc = _svc(ctx)
+
+    def finalize(fname, fargs, fresp, fsumm, **kw):
+        return _finalize_response(ctx, fname, fargs, fresp, fsumm, **kw)
+
+    from cli.tools.jira import handle_jira
+    return await asyncio.to_thread(
+        handle_jira, action, svc, finalize,
+        issue=issue, jql=jql, project=project, issue_type=issue_type,
+        summary=summary, description=description, body=body,
+        body_format=body_format, transition=transition, user=user,
+        query=query, fields=fields, status_category=status_category,
+        account=account, cursor=cursor, limit=limit,
+    )
+
+
 @mcp.tool()
 async def c3_project(
     action: str,

cli/server.py

@@ -199,6 +199,7 @@ _UI_JS_FILES = [
     "ui/components/tasks.js",
     "ui/components/edits.js",
     "ui/components/bitbucket.js",
+    "ui/components/jira.js",
     "ui/components/instructions.js",
     "ui/components/settings.js",
     "ui/components/chat.js",
@@ -3588,6 +3589,234 @@ def api_bitbucket_permissions():
     })
 
 
+# ─── Jira (Cloud / Data Center) ──────────────────────────
+def _jira_client_and_entry():
+    """Return (client, account_entry, error_response_or_None)."""
+    from core.config import load_jira_config
+    from services import jira_credentials as jr_creds
+    from services.jira_client import JiraClient
+
+    cfg = load_jira_config(str(PROJECT_PATH))
+    name = cfg.get("default_account", "")
+    entry = (cfg.get("accounts") or {}).get(name)
+    if not isinstance(entry, dict) or not entry.get("base_url"):
+        return None, {}, (jsonify({"error": "no Jira account — run `c3 jira login`"}), 400)
+    try:
+        token = jr_creds.load_token(entry["base_url"], entry.get("username", ""))
+    except RuntimeError as exc:
+        return None, {}, (jsonify({"error": str(exc)}), 500)
+    if not token:
+        return None, {}, (jsonify({
+            "error": f"no keyring token for {entry.get('username')}@{entry['base_url']}",
+        }), 400)
+    try:
+        client = JiraClient(
+            entry["base_url"], entry.get("username", ""), token,
+            deployment=entry.get("deployment", "cloud"),
+            verify_tls=bool(entry.get("verify_tls", True)),
+            ca_bundle=entry.get("ca_bundle", ""),
+        )
+    except ValueError as exc:
+        return None, {}, (jsonify({"error": str(exc)}), 400)
+    return client, {**entry, "name": name}, None
+
+
+def _jira_handle(call):
+    """Run a Jira API closure; translate JiraError to an HTTP response."""
+    from services.jira_client import JiraError
+    try:
+        return jsonify(call())
+    except JiraError as exc:
+        return jsonify({
+            "error": str(exc),
+            "status": exc.status,
+            "path": exc.path,
+        }), 502 if exc.status == 0 else exc.status
+    except Exception as exc:
+        return jsonify({"error": f"{type(exc).__name__}: {exc}"}), 500
+
+
+def _jira_my_jql(entry: dict) -> str:
+    clauses = ["assignee = currentUser()"]
+    project = request.args.get("project") or entry.get("default_project", "")
+    if project:
+        safe = project.replace("\\", "\\\\").replace('"', '\\"')
+        clauses.append(f'project = "{safe}"')
+    return " AND ".join(clauses) + " ORDER BY updated DESC"
+
+
+@app.route('/api/jira/status')
+def api_jira_status():
+    """Accounts registry, default account, and a connection probe."""
+    from core.config import load_jira_config
+    from services import jira_credentials as jr_creds
+    from services.jira_client import JiraClient, JiraError
+
+    cfg = load_jira_config(str(PROJECT_PATH))
+    out = {"config": cfg, "connection": {"ok": False}}
+    name = cfg.get("default_account", "")
+    entry = (cfg.get("accounts") or {}).get(name)
+    if not isinstance(entry, dict) or not entry.get("base_url"):
+        out["connection"]["error"] = "no default account"
+        return jsonify(out)
+    try:
+        token = jr_creds.load_token(entry["base_url"], entry.get("username", ""))
+    except RuntimeError as exc:
+        out["connection"]["error"] = str(exc)
+        return jsonify(out)
+    if not token:
+        out["connection"]["error"] = "no keyring token"
+        return jsonify(out)
+    try:
+        client = JiraClient(
+            entry["base_url"], entry.get("username", ""), token,
+            deployment=entry.get("deployment", "cloud"),
+            verify_tls=bool(entry.get("verify_tls", True)),
+            ca_bundle=entry.get("ca_bundle", ""),
+        )
+        info = client.server_info()
+        me = client.myself()
+        out["connection"] = {
+            "ok": True,
+            "version": info.get("version", "?"),
+            "user": me.get("displayName", ""),
+            "deployment": entry.get("deployment", ""),
+        }
+    except (JiraError, ValueError) as exc:
+        out["connection"] = {"ok": False, "error": str(exc)}
+    return jsonify(out)
+
+
+@app.route('/api/jira/issues/my')
+def api_jira_my_issues():
+    client, entry, err = _jira_client_and_entry()
+    if err is not None:
+        return err
+    return _jira_handle(lambda: client.search(
+        _jira_my_jql(entry),
+        limit=int(request.args.get("limit", 50)),
+        cursor=request.args.get("cursor", ""),
+    ))
+
+
+@app.route('/api/jira/board')
+def api_jira_board():
+    """My issues grouped by status category — the v1 'board' derives from
+    plain JQL statusCategory grouping, no agile API involved."""
+    client, entry, err = _jira_client_and_entry()
+    if err is not None:
+        return err
+
+    def call():
+        result = client.search(_jira_my_jql(entry),
+                               limit=int(request.args.get("limit", 100)))
+        columns = {"new": [], "indeterminate": [], "done": []}
+        for issue in result.get("issues", []):
+            columns.setdefault(
+                issue.get("status_category") or "new", columns["new"]
+            ).append(issue)
+        return {"columns": columns, "next_cursor": result.get("next_cursor", "")}
+    return _jira_handle(call)
+
+
+@app.route('/api/jira/search')
+def api_jira_search():
+    client, entry, err = _jira_client_and_entry()
+    if err is not None:
+        return err
+    jql = (request.args.get("jql") or "").strip()
+    if not jql:
+        return jsonify({"error": "jql query parameter is required"}), 400
+    return _jira_handle(lambda: client.search(
+        jql,
+        limit=int(request.args.get("limit", 50)),
+        cursor=request.args.get("cursor", ""),
+    ))
+
+
+@app.route('/api/jira/issue/<key>')
+def api_jira_get_issue(key: str):
+    client, entry, err = _jira_client_and_entry()
+    if err is not None:
+        return err
+
+    def call():
+        issue = client.get_issue(key)
+        issue["transitions"] = client.list_transitions(key)
+        return issue
+    return _jira_handle(call)
+
+
+@app.route('/api/jira/issue', methods=['POST'])
+def api_jira_create_issue():
+    client, entry, err = _jira_client_and_entry()
+    if err is not None:
+        return err
+    data = request.get_json(force=True) or {}
+    project = data.get("project") or entry.get("default_project", "")
+    issue_type = data.get("issue_type", "")
+    summary = data.get("summary", "")
+    if not project or not issue_type or not summary:
+        return jsonify({"error": "project, issue_type, and summary are required"}), 400
+    return _jira_handle(lambda: client.create_issue(
+        project, issue_type, summary,
+        description=data.get("description", ""),
+        fields=data.get("fields") or None,
+    ))
+
+
+@app.route('/api/jira/issue/<key>/transition', methods=['POST'])
+def api_jira_transition(key: str):
+    client, entry, err = _jira_client_and_entry()
+    if err is not None:
+        return err
+    data = request.get_json(force=True) or {}
+    transition_id = str(data.get("transition", "")).strip()
+    if not transition_id:
+        return jsonify({"error": "transition id is required"}), 400
+    return _jira_handle(lambda: client.transition_issue(
+        key, transition_id, comment=data.get("comment", ""),
+    ) or {"ok": True})
+
+
+@app.route('/api/jira/issue/<key>/comment', methods=['POST'])
+def api_jira_comment(key: str):
+    client, entry, err = _jira_client_and_entry()
+    if err is not None:
+        return err
+    data = request.get_json(force=True) or {}
+    body = data.get("body", "")
+    if not str(body).strip():
+        return jsonify({"error": "body is required"}), 400
+    return _jira_handle(lambda: client.add_comment(key, body))
+
+
+@app.route('/api/jira/activity')
+def api_jira_activity():
+    """Local issue-key activity — current branch + edit-ledger scan.
+    Pure local (no Jira call), so it works without a configured account."""
+    from services import jira_links
+    out = jira_links.branch_issue_keys(str(PROJECT_PATH))
+    out["entries"] = jira_links.ledger_activity(
+        str(PROJECT_PATH),
+        key=request.args.get("key", ""),
+        limit=int(request.args.get("limit", 25)),
+    )
+    return jsonify(out)
+
+
+@app.route('/api/jira/issue/<key>/assign', methods=['POST'])
+def api_jira_assign(key: str):
+    client, entry, err = _jira_client_and_entry()
+    if err is not None:
+        return err
+    data = request.get_json(force=True) or {}
+    user = (data.get("user") or "").strip()
+    if not user:
+        return jsonify({"error": "user (deployment-native id) is required"}), 400
+    return _jira_handle(lambda: client.assign_issue(key, user) or {"ok": True})
+
+
 # ─── Launch ──────────────────────────────────────────────
 def find_free_port(start: int = 3333, max_tries: int = 20) -> int:
     """Return the first free TCP port starting from *start*."""