gozu 0.3.7__py3-none-any.whl

cli/__init__.py

@@ -0,0 +1,3 @@
+# Copyright (c) 2026 Calfus Inc.
+# Author: Wasiullah Rafeeq S
+

cli/config_cmd/__init__.py

@@ -0,0 +1,92 @@
+# Copyright (c) 2026 Calfus Inc.
+# Author: Wasiullah Rafeeq S
+#
+# Depends on: src/config/store.py - listing/deleting saved configs
+# Depends on: src/cli/config_lookup.py - resolving a config name typed by the user
+# Depends on: src/cli/stack/__init__.py - ensuring the config store is ready before use
+# Depends on: src/cli/stack/backup.py - backing up the database before a destructive delete
+
+"""
+`gozu config list/edit/delete` - managing saved configs after `gozu init`
+has created them, without needing to recreate one from scratch just to
+fix a typo or remove a throwaway config. `edit` lives in its own module
+(src/cli/config_cmd/edit.py) given its size; list/delete are small enough to
+live here directly.
+"""
+
+import questionary
+import typer
+
+import config.store as config_store
+from cli.config_cmd.edit import edit_command
+from cli.config_lookup import resolve_config_or_prompt
+from cli.prompts import ask_or_exit
+from cli.stack import ensure_config_store_ready
+from cli.stack.backup import create_backup, next_backup_path
+from cli.status import success, waiting
+from scripts.paths import STACK_DIR
+
+__all__ = ["delete_command", "edit_command", "list_command"]
+
+
+def list_command() -> None:
+    ensure_config_store_ready()
+    configs = config_store.list_configs()
+    if not configs:
+        typer.echo("No configs found - run `gozu init` to create one.")
+        return
+
+    typer.echo("Configs:")
+    for config in configs:
+        typer.echo(
+            f"  {config['name']:<20} scanner={config['scanner_type']}  mode={config['scanner_mode']:<6}  "
+            f"trigger={config['trigger_mode']}"
+        )
+
+
+def delete_command(name: str) -> None:
+    """
+    Deletes only this one config's own rows (its config_credentials
+    cascade via the FK - see config_store.delete_config()) - never the
+    ticket_destination it references, even if this was the last config
+    using it. A single y/N confirmation, not --wipe's typed-word ritual -
+    this is scoped to one config, not the whole store.
+
+    Still takes the same full-database backup --wipe does beforehand
+    (src/cli/stack/backup.py's create_backup()/next_backup_path(), reused
+    as-is - same 7-day retention, same file, no separate backup logic to
+    maintain) - a single config's blast radius doesn't warrant --wipe's
+    typed-word ritual, but losing one with nothing to restore from is the
+    exact incident --wipe's own backup step was added to prevent in the
+    first place, and that risk applies here too.
+    """
+    ensure_config_store_ready()
+    config = resolve_config_or_prompt(name)
+    # Use the resolved config's own name from here on, not the (possibly
+    # wrong) `name` argument - resolve_config_or_prompt() may have picked
+    # a different config via its "did you mean" recovery picker.
+    name = config["name"]
+
+    typer.echo(f"This will delete config '{name}':")
+    typer.echo(f"  scanner:  {config['scanner_type']} ({config['scanner_mode']})")
+    typer.echo(f"  trigger:  {config['trigger_mode']}")
+
+    destination_id = config.get("ticket_destination_id")
+    if destination_id is not None:
+        destination = config_store.get_ticket_destination_by_id(destination_id)
+        destination_name = destination["name"] if destination else f"id={destination_id}"
+        typer.echo(f"  ticket destination: '{destination_name}' (shared - this destination itself is NOT deleted)")
+    else:
+        typer.echo("  ticket destination: embedded credentials on this config (not shared with anything else)")
+
+    if not ask_or_exit(questionary.confirm(f"Delete '{name}'?", default=False)):
+        typer.echo("Cancelled - nothing was deleted.")
+        return
+
+    backup_path = next_backup_path()
+    waiting("Backing up gozu's database before deleting ...")
+    create_backup(backup_path, STACK_DIR)
+    success(f"Backup written: {backup_path}")
+
+    config_store.delete_config(name)
+    success(f"Deleted config '{name}'.")

cli/config_cmd/edit.py

@@ -0,0 +1,223 @@
+# Copyright (c) 2026 Calfus Inc.
+# Author: Wasiullah Rafeeq S
+# Editor: Prakrit Mohanty
+#
+# Depends on: src/config/store.py - reading and updating a config's fields/credentials
+# Depends on: src/cli/config_lookup.py - resolving a config name typed by the user
+# Depends on: src/cli/init_wizard/jira_step.py - reusing its Jira credential prompt functions
+# Depends on: src/cli/init_wizard/llm_step.py - reusing its Anthropic API key prompt function
+# Depends on: src/cli/init_wizard/sonar_cloud.py - reusing its SonarQube Cloud credential prompt functions
+# Depends on: src/cli/init_wizard/sonar_local.py - reusing its SonarQube Local credential prompt functions
+# Depends on: src/cli/stack/__init__.py - ensuring the config store is ready before editing
+# Depends on: src/cli/wizard_engine.py - the shared review/edit engine this command drives
+
+"""
+`gozu config edit <name>` - reuses src/cli/wizard_engine.py, skipping
+straight to the review screen pre-populated from the config's current
+values. scanner_type/scanner_mode/sonar_plan/trigger_mode are structural
+(decided once at `gozu init` time) and are never offered here.
+"""
+
+import questionary
+import typer
+
+import config.store as config_store
+from cli.config_lookup import resolve_config_or_prompt
+from cli.init_wizard.jira_step import (
+    prompt_jira_api_token,
+    prompt_jira_email,
+    prompt_jira_project_key,
+    prompt_jira_url,
+)
+from cli.init_wizard.llm_step import prompt_anthropic_api_key
+from cli.init_wizard.semgrep_step import prompt_project_label
+from cli.init_wizard.sonar_cloud import (
+    prompt_premium_branches,
+    prompt_sonar_organization,
+    prompt_sonar_token_cloud,
+)
+from cli.init_wizard.sonar_local import prompt_project_key, prompt_sonar_token_local
+from cli.prompts import ask_or_exit, generate_or_prompt_secret, prompt_text
+from cli.stack import ensure_config_store_ready
+from cli.status import success, warning
+from cli.wizard_engine import WizardField, run_wizard
+
+# Mirrors src/config/store.py's own _DESTINATION_RESOLVED_KEYS - decides
+# whether to show the multi-config warning before writing.
+_DESTINATION_RESOLVED_KEYS = {"jira_url", "jira_email", "jira_api_token", "jira_project_key"}
+
+# Plain columns (config_store.update_config_fields()); every other
+# editable field is a credential (update_config_credential()).
+_PLAIN_COLUMN_KEYS = {"project_key", "branches", "ticket_cap"}
+
+
+def _prompt_ticket_cap(current: int | None) -> int | None:
+    """The persistent per-config default (`gozu run -t` is a separate,
+    one-off override). Blank always means "use the built-in fallback",
+    never an explicit 0."""
+    default = str(current) if current is not None else ""
+    while True:
+        answer = ask_or_exit(
+            questionary.text("Per-run ticket cap (blank = use the default):", default=default)
+        )
+        answer = answer.strip()
+        if not answer:
+            return None
+        try:
+            value = int(answer)
+        except ValueError:
+            warning("Enter a positive whole number, or leave blank to use the default.")
+            continue
+        if value <= 0:
+            warning("Enter a positive whole number, or leave blank to use the default.")
+            continue
+        return value
+
+
+def _build_edit_fields(config: dict, state: dict) -> list[WizardField]:
+    credentials = config["credentials"]
+    scanner_type = config["scanner_type"]
+    scanner_mode = config["scanner_mode"]
+    trigger_mode = config["trigger_mode"]
+
+    state["ticket_cap"] = config.get("ticket_cap")
+    project_key_field = (
+        None
+        if scanner_type == "trivy"
+        # No project_key, no credentials, no branches at all - see
+        # src/cli/init_wizard/__init__.py's _build_fields() Trivy branch
+        # for why. Only ticket_cap and the shared Jira fields below apply.
+        else WizardField("project_key", "Project label", lambda: prompt_project_label(state.get("project_key", "")))
+        if scanner_type == "semgrep"
+        else WizardField(
+            "project_key", "SonarQube project key", lambda: prompt_project_key(state.get("project_key", ""))
+        )
+    )
+    fields = [
+        *([project_key_field] if project_key_field is not None else []),
+        WizardField(
+            "ticket_cap",
+            "Per-run ticket cap (blank = default)",
+            lambda: _prompt_ticket_cap(state.get("ticket_cap")),
+        ),
+    ]
+
+    if project_key_field is not None:
+        state["project_key"] = config.get("project_key") or ""
+
+    if scanner_type in ("trivy", "semgrep"):
+        pass  # no scanner credentials to edit - trivy needs none, semgrep's trigger_mode "direct" needs none
+    elif scanner_mode == "local":
+        state["sonar_token"] = credentials.get("sonar_token", "")
+        state["sonar_host_url"] = credentials.get("sonar_host_url", "")
+        fields += [
+            WizardField(
+                "sonar_token", "SonarQube token", lambda: prompt_sonar_token_local(state.get("sonar_token", "")), secret=True
+            ),
+            WizardField(
+                "sonar_host_url",
+                "SonarQube host URL",
+                lambda: prompt_text("SonarQube host URL:", default=state.get("sonar_host_url", "")),
+            ),
+        ]
+    else:
+        state["sonar_token"] = credentials.get("sonar_token", "")
+        state["sonar_organization"] = credentials.get("sonar_organization", "")
+        state["branches"] = config.get("branches") or ""
+        fields += [
+            WizardField(
+                "sonar_token",
+                "SonarQube Cloud token",
+                lambda: prompt_sonar_token_cloud(state.get("sonar_token", "")),
+                secret=True,
+            ),
+            WizardField(
+                "sonar_organization",
+                "SonarQube Cloud organization key",
+                lambda: prompt_sonar_organization(state.get("sonar_organization", "")),
+            ),
+            # prompt_premium_branches()'s comma-join degrades to a single
+            # value for a one-branch string, so it's reused here rather than
+            # adding a third near-identical branches prompt just for edit.
+            WizardField(
+                "branches", "Branches to track", lambda: prompt_premium_branches(state.get("branches", "main"))
+            ),
+        ]
+
+    if trigger_mode == "webhook":
+        state["webhook_secret"] = credentials.get("webhook_secret", "")
+        fields.append(
+            WizardField("webhook_secret", "Webhook secret", lambda: generate_or_prompt_secret("Webhook secret"), secret=True)
+        )
+
+    state["jira_url"] = credentials.get("jira_url", "")
+    state["jira_email"] = credentials.get("jira_email", "")
+    state["jira_api_token"] = credentials.get("jira_api_token", "")
+    state["jira_project_key"] = credentials.get("jira_project_key", "")
+    fields += [
+        WizardField("jira_url", "Jira URL", lambda: prompt_jira_url(state.get("jira_url", ""))),
+        WizardField("jira_email", "Jira account email", lambda: prompt_jira_email(state.get("jira_email", ""))),
+        WizardField(
+            "jira_api_token",
+            "Jira API token",
+            lambda: prompt_jira_api_token(state.get("jira_api_token", "")),
+            secret=True,
+        ),
+        WizardField(
+            "jira_project_key", "Jira project key", lambda: prompt_jira_project_key(state.get("jira_project_key", ""))
+        ),
+    ]
+
+    state["anthropic_api_key"] = credentials.get("anthropic_api_key", "")
+    fields.append(
+        WizardField(
+            "anthropic_api_key",
+            "Anthropic API key (optional)",
+            lambda: prompt_anthropic_api_key(state.get("anthropic_api_key", "")),
+            secret=True,
+        )
+    )
+    return fields
+
+
+def edit_command(name: str) -> None:
+    ensure_config_store_ready()
+    config = resolve_config_or_prompt(name)
+    # Use the resolved config's own name from here - resolve_config_or_prompt()
+    # may have picked a different one via its "did you mean" recovery picker.
+    name = config["name"]
+
+    state: dict = {}
+    fields = _build_edit_fields(config, state)
+    original = dict(state)
+
+    final_state = run_wizard(fields, state, walk_first=False)
+    changed_keys = [key for key, value in final_state.items() if original.get(key) != value]
+
+    if not changed_keys:
+        typer.echo("Nothing changed.")
+        return
+
+    changed_destination_keys = [key for key in changed_keys if key in _DESTINATION_RESOLVED_KEYS]
+    destination_id = config.get("ticket_destination_id")
+    if changed_destination_keys and destination_id is not None:
+        affected_count = config_store.count_configs_using_destination(destination_id, exclude_config_name=name)
+        if affected_count > 0:
+            warning(
+                f"'{name}' shares its Jira credentials with {affected_count} other config(s) via a shared ticket "
+                f"destination - changing {', '.join(changed_destination_keys)} will affect them too, not just '{name}'."
+            )
+            if not ask_or_exit(questionary.confirm("Continue anyway?", default=False)):
+                typer.echo("Cancelled - nothing was changed.")
+                return
+
+    plain_field_updates = {key: final_state[key] for key in changed_keys if key in _PLAIN_COLUMN_KEYS}
+    if plain_field_updates:
+        config_store.update_config_fields(name, **plain_field_updates)
+
+    for key in changed_keys:
+        if key in _PLAIN_COLUMN_KEYS:
+            continue
+        config_store.update_config_credential(name, key, final_state[key])
+
+    success(f"Updated '{name}': {', '.join(changed_keys)}")

cli/config_lookup.py

@@ -0,0 +1,87 @@
+# Copyright (c) 2026 Calfus Inc.
+# Author: Wasiullah Rafeeq S
+#
+# Depends on: src/config/store.py - looking up and listing saved configs
+
+"""
+Shared "a --config <name> was given but doesn't match anything" recovery,
+used everywhere a config is looked up by name that the caller typed
+explicitly (gozu run --config, gozu up --config, gozu config edit/delete)
+- as opposed to src/cli/scan_runner/config_select.py's select_config(), which
+this module is a sibling to, not a replacement for: select_config() also
+handles the *no name given at all* picker (auto-select the only one,
+or choose among several), which is a different situation from a name
+that was given but wrong. Kept here instead of folded into
+config_select.py so src/cli/config_cmd and src/cli/stack don't have to import a
+module named for scan_runner just to reuse this.
+
+Never falls through to any default behavior on a miss - either the user
+picks a real config from what actually exists, or explicitly exits.
+"""
+
+import questionary
+import typer
+
+import config.store as config_store
+from cli.status import error
+
+
+def resolve_config_or_prompt(name: str) -> dict:
+    """
+    Looks up a config by `name`. If found, returns it unchanged (the
+    normal, correct-name path). If not:
+
+    - Explains why the lookup failed ("No config named '<name>' found.")
+    - If no configs exist at all, says so plainly and points at
+      `gozu init` - there is nothing to pick from, so no picker is shown
+    - Otherwise shows a questionary.select() of every existing config
+      (name + scanner_mode + trigger_mode, the same informative format
+      select_config() uses for its own no-name-given picker), plus a
+      final "Exit" choice
+
+    Picking a real config returns it - same shape as if that name had
+    been passed correctly to begin with, so the caller proceeds exactly
+    as normal. Picking "Exit" (or Ctrl-C, which questionary also surfaces
+    as None) exits cleanly via typer.Exit - no traceback, no partial
+    side effects, and never a silent fall-through to some default config.
+    """
+    config = config_store.get_config(name)
+    if config is not None:
+        return config
+
+    error(f"No config named '{name}' found.")
+
+    configs = config_store.list_configs()
+    if not configs:
+        typer.echo("No configs exist yet - run `gozu init` to create one.")
+        raise typer.Exit(code=1)
+
+    # A distinct sentinel, not None - questionary.Choice() defaults an
+    # unset `value` to its own `title`, so a bare `value=None` here would
+    # actually come back as the string "__exit__"... no, worse: it would
+    # come back as the literal title "Exit", indistinguishable from a
+    # real (if oddly named) config. Confirmed live: an earlier version of
+    # this using value=None surfaced "Config 'Exit' disappeared before it
+    # could be loaded." instead of exiting cleanly.
+    _EXIT = "__exit__"
+    answer = questionary.select(
+        "Did you mean one of these instead?",
+        choices=[
+            questionary.Choice(
+                title=f"{c['name']}  ({c['scanner_mode']}, trigger={c['trigger_mode']})",
+                value=c["name"],
+            )
+            for c in configs
+        ]
+        + [questionary.Choice(title="Exit", value=_EXIT)],
+    ).ask()
+    if answer is None or answer == _EXIT:
+        raise typer.Exit(code=1)
+
+    resolved = config_store.get_config(answer)
+    if resolved is None:
+        # Vanishingly unlikely (deleted between list_configs() and here), but
+        # get_config() can genuinely return None, so this has to be handled.
+        error(f"Config '{answer}' disappeared before it could be loaded.")
+        raise typer.Exit(code=1)
+    return resolved

cli/crash_handler.py

@@ -0,0 +1,62 @@
+# Copyright (c) 2026 Calfus Inc.
+# Author: Wasiullah Rafeeq S
+
+"""
+Last-resort handler for a genuinely unexpected exception escaping the
+whole `gozu` invocation - only reached for exceptions that aren't Typer/
+Click's own control-flow exceptions (typer.Exit, SystemExit,
+KeyboardInterrupt), which already exited cleanly on their own.
+
+Deliberately does NOT send email automatically - that would need gozu to
+hold its own SMTP/API credentials, could silently fail exactly when
+mail infra is what's broken, and risks an unreviewed traceback landing
+in an inbox. Instead a pre-filled mailto: link is shown, and the raw
+traceback only ever touches a timestamped file under LOGS_DIR.
+"""
+
+import traceback
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import quote
+
+import typer
+from rich.console import Console
+
+from core.constants import CONTACT_EMAILS
+from scripts.paths import LOGS_DIR
+
+
+def _write_traceback_log(exc: BaseException) -> Path:
+    LOGS_DIR.mkdir(parents=True, exist_ok=True)
+    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
+    log_path = LOGS_DIR / f"crash-{timestamp}.log"
+    log_path.write_text("".join(traceback.format_exception(type(exc), exc, exc.__traceback__)))
+    return log_path
+
+
+def _build_mailto_link(log_path: Path) -> str:
+    """mailto: links can't attach files or reliably fit a full traceback,
+    so the body just references the log file's path."""
+    recipients = ",".join(CONTACT_EMAILS)
+    subject = quote("Gozu error report")
+    body = quote(
+        "gozu hit an unexpected error.\n\n"
+        f"Full details were logged to: {log_path}\n\n"
+        "Please attach that file, or paste its contents below, before sending."
+    )
+    return f"mailto:{recipients}?subject={subject}&body={body}"
+
+
+def handle_unexpected_exception(exc: BaseException) -> None:
+    log_path = _write_traceback_log(exc)
+    mailto_link = _build_mailto_link(log_path)
+
+    typer.echo()
+    typer.echo("Something went wrong that gozu didn't expect.")
+    typer.echo(f"Full details were logged to: {log_path}")
+    typer.echo()
+    typer.echo("If you'd like to report this:")
+    # rich's link markup only emits the OSC 8 escape sequence for a real
+    # terminal; piped/redirected output gets plain visible text instead,
+    # never raw escape bytes dumped into a file.
+    Console().print(f"  [link={mailto_link}]Report this error[/link]")

cli/help_links.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2026 Calfus Inc.
+# Author: Wasiullah Rafeeq S
+# Editor: Prakrit Mohanty
+
+"""
+Doc links shown before each credential prompt in the init wizard, so a user
+who doesn't already know where e.g. a SonarQube token comes from isn't left
+guessing. Every URL here was looked up live (Sonar/Atlassian docs), not
+guessed - if a backend's docs move, update the entry here rather than
+re-guessing a plausible-looking URL.
+
+Keyed by a wizard-internal field name, not always the literal credential
+key stored in config_credentials (sonar_token has two entries, since the
+"how do I get one" instructions differ completely between self-hosted
+SonarQube and SonarQube Cloud).
+"""
+
+import typer
+
+HELP_LINKS: dict[str, str] = {
+    "sonar_token_local": "https://docs.sonarsource.com/sonarqube-server/latest/user-guide/managing-tokens/",
+    "sonar_token_cloud": "https://docs.sonarsource.com/sonarqube-cloud/managing-your-account/managing-tokens",
+    "sonar_organization": "https://docs.sonarsource.com/sonarqube-cloud/getting-started/viewing-organizations",
+    "sonar_project_key": "https://docs.sonarsource.com/sonarqube-server/project-administration/maintaining-project/changing-project-key",
+    "sonar_branch": "https://docs.sonarsource.com/sonarqube-cloud/analyzing-source-code/branch-analysis/branch-analysis",
+    "jira_api_token": "https://id.atlassian.com/manage-profile/security/api-tokens",
+    "jira_email": "https://id.atlassian.com/manage-profile/profile-and-visibility",
+    "jira_project_key": "https://confluence.atlassian.com/jirakb/how-to-get-project-id-from-the-jira-user-interface-827341414.html",
+    "webhook_secret": "https://docs.sonarsource.com/sonarqube-cloud/managing-your-projects/administering-your-projects/integrations/webhooks",
+    "anthropic_api_key": "https://platform.claude.com/settings/keys",
+}
+
+
+def print_help_link(field: str) -> None:
+    """Print a dimmed `-> docs: <url>` line for `field`, if a link is registered for it."""
+    url = HELP_LINKS.get(field)
+    if url:
+        typer.secho(f"  -> docs: {url}", dim=True)