postgres-aiops 0.2.0__tar.gz → 0.2.1__tar.gz

postgres_aiops-0.2.1/.github/workflows/mcp-publish.yml

@@ -0,0 +1,23 @@
+name: mcp-publish
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish-mcp:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install mcp-publisher
+        run: |
+          curl -sL "https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz" | tar xz mcp-publisher
+      - name: Login to MCP Registry (GitHub OIDC)
+        run: ./mcp-publisher login github-oidc
+      - name: Publish server.json
+        run: ./mcp-publisher publish

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/CHANGELOG.md

@@ -1,5 +1,19 @@
 # Changelog
 
+## v0.2.1 — 2026-07-16
+
+### Fixed
+- **`secrets.enc` now follows `POSTGRES_AIOPS_HOME`** (secretstore hardcoded the real
+  home directory; config/audit/undo already relocated — found in live verification).
+- **Audit fidelity**: failures sanitized into `{"error": ...}` results by the MCP error
+  layer are now audited as `status=error` (they previously read as `ok`, hiding failed
+  attempts from exception reports), and no undo is recorded for a call that failed.
+- Undo replay fix: `create_index` accepts a `definition` (captured `pg_get_indexdef` statement, shape-validated), making `drop_index`'s undo descriptor replayable.
+
+### Tests
+- `doctor` and the `init` wizard are now fully covered (previously ~10–20%); plus a
+  regression test for the sanitized-failure audit status.
+
 ## v0.2.0 — 2026-07-13
 
 Security-hardening release from a line-wide code review.

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: postgres-aiops
-Version: 0.2.0
+Version: 0.2.1
 Summary: Governed AI-ops for PostgreSQL DBA operations: slow-query RCA, bloat/vacuum & blocking-lock analysis with a built-in governance harness (audit, budget, undo, risk tiers)
 Author-email: wei <zhouwei008@gmail.com>
 License-Expression: MIT

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/mcp_server/tools/remediation.py

@@ -162,12 +162,13 @@ def run_analyze(table: str, dry_run: bool = False, target: Optional[str] = None)
 @governed_tool(risk_level="medium", undo=_create_index_undo)
 @tool_errors("dict")
 def create_index(
-    table: str,
-    columns: list[str],
+    table: Optional[str] = None,
+    columns: Optional[list[str]] = None,
     name: Optional[str] = None,
     unique: bool = False,
     concurrently: bool = False,
     method: Optional[str] = None,
+    definition: Optional[str] = None,
     dry_run: bool = False,
     target: Optional[str] = None,
 ) -> dict:
@@ -175,21 +176,34 @@ def create_index(
 
     Supports CONCURRENTLY (non-blocking build). The created name is returned so
     the harness records an undo that drops exactly this index. Pass dry_run=True
-    to preview.
+    to preview. Alternatively pass ``definition`` (a captured pg_get_indexdef
+    statement — this is how drop_index's undo descriptor replays) INSTEAD of
+    table/columns.
 
     Args:
-        table: Table to index (optionally schema-qualified).
-        columns: Column names to index.
+        table: Table to index (optionally schema-qualified). Required unless
+            ``definition`` is given.
+        columns: Column names to index. Required unless ``definition`` is given.
         name: Index name (auto-generated from table+columns when omitted).
         unique: Create a UNIQUE index.
         concurrently: Build with CONCURRENTLY (no table lock).
         method: Index method — btree/hash/gist/gin/brin/spgist (default btree).
+        definition: A full CREATE [UNIQUE] INDEX statement to execute verbatim
+            (shape-validated). Mutually exclusive with table/columns.
         dry_run: If True, preview without creating.
         target: Target name from config; omit for the default.
     """
+    if definition and (table or columns):
+        raise ValueError("Pass either definition OR table+columns, not both.")
+    if not definition and not (table and columns):
+        raise ValueError("create_index requires table+columns (or a definition).")
     conn = _get_connection(target)
     if dry_run:
+        if definition:
+            return {"dryRun": True, "wouldExecute": definition}
         return {"dryRun": True, "wouldCreate": {"table": table, "columns": columns, "name": name}}
+    if definition:
+        return ops.create_index_from_definition(conn, definition)
     return ops.create_index(
         conn, table, columns, name=name, unique=unique,
         concurrently=concurrently, method=method,

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/postgres_aiops/governance/decorators.py

@@ -317,6 +317,8 @@ def _record_undo(state: _CallState, result: Any) -> None:
     """
     if state.undo is None:
         return
+    if isinstance(result, dict) and result.get("error"):
+        return  # sanitized failure — no change happened, so no inverse to record
     try:
         descriptor = state.undo(state.safe_params, result)
     except Exception:  # noqa: BLE001 — undo computation must not fail the call
@@ -356,6 +358,12 @@ def _capture_error(state: _CallState, exc: Exception) -> None:
 
 def _finalize(state: _CallState) -> None:
     """Audit + circuit-breaker bookkeeping. Runs in the wrapper's finally."""
+    # A sanitized failure (@tool_errors converts exceptions into {"error": ...}
+    # dicts BEFORE this harness sees them) must not be audited as success —
+    # compliance exception reports are built from this status.
+    if state.status == "ok" and isinstance(state.result, dict) and state.result.get("error"):
+        state.status = "error"
+
     duration = int((time.time() - state.start) * 1000)
 
     # Accumulate wall-time toward the cumulative time budget (best-effort).

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/postgres_aiops/ops/remediation.py

@@ -162,6 +162,36 @@ def create_index(
     }
 
 
+# Shape gate for replaying a captured pg_get_indexdef statement. Server-generated
+# (never user-composed), but validated anyway: single statement, CREATE INDEX only.
+_INDEXDEF_RE = re.compile(
+    r"^CREATE\s+(?:UNIQUE\s+)?INDEX\s+(?:CONCURRENTLY\s+)?(?:IF\s+NOT\s+EXISTS\s+)?"
+    r'("?[A-Za-z_][A-Za-z0-9_$]*"?)\s+ON\s+',
+    re.IGNORECASE,
+)
+
+
+def create_index_from_definition(conn: Any, definition: str) -> dict:
+    """[WRITE] Recreate an index from a captured ``pg_get_indexdef`` statement.
+
+    This is the replay path for ``drop_index``'s undo descriptor: the exact
+    definition captured before the drop is executed verbatim after a shape
+    check (single statement, must be CREATE [UNIQUE] INDEX ... ON ...).
+    """
+    stmt = (definition or "").strip().rstrip(";").strip()
+    if not stmt or ";" in stmt:
+        raise ValueError("definition must be a single CREATE INDEX statement.")
+    m = _INDEXDEF_RE.match(stmt)
+    if not m:
+        raise ValueError("definition must start with CREATE [UNIQUE] INDEX ... ON ...")
+    conn.execute(stmt)  # nosec B608 — shape-validated pg_get_indexdef output
+    return {
+        "action": "create_index",
+        "index": m.group(1).strip('"'),
+        "fromDefinition": True,
+    }
+
+
 def drop_index(conn: Any, name: str, concurrently: bool = False) -> dict:
     """[WRITE] Drop an index. Reversible: captures pg_get_indexdef first so undo recreates it."""
     ident = qualify(name)

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/postgres_aiops/secretstore.py

@@ -39,9 +39,11 @@ from cryptography.exceptions import InvalidKey
 from cryptography.fernet import Fernet, InvalidToken
 from cryptography.hazmat.primitives.kdf.scrypt import Scrypt
 
+from postgres_aiops.governance.paths import ops_home
+
 # ─── Tool-specific constants (change these three to vendor for another tool) ──
 APP_NAME = "postgres-aiops"
-CONFIG_DIR = Path.home() / ".postgres-aiops"
+CONFIG_DIR = ops_home()
 MASTER_PASSWORD_ENV = "POSTGRES_AIOPS_MASTER_PASSWORD"  # nosec B105 — env-var name
 # ──────────────────────────────────────────────────────────────────────────────
 

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "postgres-aiops"
-version = "0.2.0"
+version = "0.2.1"
 description = "Governed AI-ops for PostgreSQL DBA operations: slow-query RCA, bloat/vacuum & blocking-lock analysis with a built-in governance harness (audit, budget, undo, risk tiers)"
 readme = "README.md"
 license = "MIT"

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/AIops-tools/Postgres-AIops",
     "source": "github"
   },
-  "version": "0.2.0",
+  "version": "0.2.1",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "postgres-aiops",
-      "version": "0.2.0",
+      "version": "0.2.1",
       "transport": {
         "type": "stdio"
       }

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/skills/postgres-aiops/SKILL.md

@@ -105,6 +105,7 @@ Pass data straight to the analysis tools — `slow_query_rca(statements=[...])`,
 
 - Every tool is audited to `~/.postgres-aiops/audit.db` (relocatable via `POSTGRES_AIOPS_HOME`).
 - High-risk ops can require a named approver: set `POSTGRES_AUDIT_APPROVED_BY` and `POSTGRES_AUDIT_RATIONALE` (the env-var names the bundled harness reads).
+- **Secure by default (v0.2.0+)**: with no `~/.postgres-aiops/rules.yaml`, high/critical operations are denied unless `POSTGRES_AUDIT_APPROVED_BY` names an approver (set `POSTGRES_AUDIT_RATIONALE` too). `postgres-aiops init` seeds a starter rules.yaml; an operator-authored rules file is honoured as-is.
 - Writes support `--dry-run` / `dry_run=True` and double confirmation at the CLI.
 - Reversible writes fetch the real before-state and record an inverse descriptor; irreversible ops (terminate/cancel, vacuum/analyze, reindex, reset stats) record prior stats only.
 - All values are bound query parameters; identifiers that cannot be parameterised are validated and quoted.

postgres_aiops-0.2.1/tests/test_doctor.py

@@ -0,0 +1,184 @@
+"""Tests for ``run_doctor`` — environment and connectivity diagnostics.
+
+Everything is redirected to a tmp dir (config, secret store) and the
+connection layer is faked at the ``ConnectionManager`` boundary, so no test
+ever touches a real PostgreSQL server or ``~/.postgres-aiops``.
+"""
+
+from __future__ import annotations
+
+import pytest
+import yaml
+from rich.console import Console
+
+import postgres_aiops.config as config_mod
+import postgres_aiops.connection as connection_mod
+import postgres_aiops.doctor as doctor_mod
+import postgres_aiops.secretstore as ss
+from postgres_aiops.doctor import run_doctor
+
+MASTER_PW = "test-master-pw"
+
+
+@pytest.fixture
+def doctor_home(tmp_path, monkeypatch):
+    """Isolate config + secret store paths under tmp_path."""
+    config_file = tmp_path / "config.yaml"
+    env_file = tmp_path / ".env"
+    secrets_file = tmp_path / "secrets.enc"
+    monkeypatch.setenv("POSTGRES_AIOPS_HOME", str(tmp_path))
+    monkeypatch.setattr(config_mod, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(config_mod, "CONFIG_FILE", config_file)
+    monkeypatch.setattr(config_mod, "ENV_FILE", env_file)
+    monkeypatch.setattr(doctor_mod, "CONFIG_FILE", config_file)
+    monkeypatch.setattr(doctor_mod, "ENV_FILE", env_file)
+    monkeypatch.setattr(doctor_mod, "SECRETS_FILE", secrets_file)
+    monkeypatch.setattr(ss, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(ss, "SECRETS_FILE", secrets_file)
+    monkeypatch.setattr(ss, "LEGACY_ENV_FILE", env_file)
+    monkeypatch.setattr(ss, "_cached", None)
+    # Wide console so long messages don't wrap mid-assertion.
+    monkeypatch.setattr(doctor_mod, "_console", Console(width=500))
+    monkeypatch.delenv("PG_PRIMARY_PASSWORD", raising=False)
+    return tmp_path
+
+
+def _write_config(tmp_path, targets: list[dict]) -> None:
+    (tmp_path / "config.yaml").write_text(yaml.safe_dump({"targets": targets}), "utf-8")
+
+
+def _seed_secret(monkeypatch, name: str = "primary", value: str = "s3cret") -> None:
+    monkeypatch.setenv("POSTGRES_AIOPS_MASTER_PASSWORD", MASTER_PW)
+    ss.SecretStore.unlock(MASTER_PW).set(name, value)
+
+
+_TARGET = {"name": "primary", "host": "db1.example.com", "port": 5432}
+
+
+class _HealthyManager:
+    """Stands in for ConnectionManager: every connect() succeeds."""
+
+    def __init__(self, config) -> None:
+        self._config = config
+
+    def connect(self, name):
+        class _Conn:
+            def query_one(self, sql):
+                return {"version": "PostgreSQL 16.4 on x86_64-pc-linux-gnu"}
+
+        return _Conn()
+
+
+class _UnreachableManager:
+    """Stands in for ConnectionManager: every connect() fails."""
+
+    def __init__(self, config) -> None:
+        self._config = config
+
+    def connect(self, name):
+        raise ConnectionError("connection to server at 'db1.example.com' refused")
+
+
+@pytest.mark.unit
+def test_doctor_missing_config_fails_with_init_hint(doctor_home, capsys):
+    assert run_doctor() == 1
+    out = capsys.readouterr().out
+    assert "Config file missing" in out
+    assert "postgres-aiops init" in out
+
+
+@pytest.mark.unit
+def test_doctor_config_load_failure_reported_not_raised(doctor_home, capsys):
+    (doctor_home / "config.yaml").write_text("targets: [unclosed", "utf-8")
+    assert run_doctor() == 1
+    assert "Config load failed" in capsys.readouterr().out
+
+
+@pytest.mark.unit
+def test_doctor_no_targets_configured(doctor_home, capsys):
+    _write_config(doctor_home, [])
+    assert run_doctor() == 1
+    assert "No targets configured" in capsys.readouterr().out
+
+
+@pytest.mark.unit
+def test_doctor_all_healthy_exit_zero(doctor_home, monkeypatch, capsys):
+    _write_config(doctor_home, [_TARGET])
+    _seed_secret(monkeypatch)
+    monkeypatch.setattr(connection_mod, "ConnectionManager", _HealthyManager)
+    assert run_doctor() == 0
+    out = capsys.readouterr().out
+    assert "Config file present" in out
+    assert "1 target(s) configured" in out
+    assert "Encrypted secret store present" in out
+    assert "password present for 'primary'" in out
+    assert "Connected to 'primary' (db1.example.com:5432)" in out
+    assert "PostgreSQL 16.4" in out
+
+
+@pytest.mark.unit
+def test_doctor_skip_auth_skips_connectivity(doctor_home, monkeypatch, capsys):
+    _write_config(doctor_home, [_TARGET])
+    _seed_secret(monkeypatch)
+
+    def _boom(config):  # doctor must not even construct a manager
+        raise AssertionError("ConnectionManager should not be used with --skip-auth")
+
+    monkeypatch.setattr(connection_mod, "ConnectionManager", _boom)
+    assert run_doctor(skip_auth=True) == 0
+    out = capsys.readouterr().out
+    assert "Skipping connectivity check" in out
+    assert "Connected" not in out
+
+
+@pytest.mark.unit
+def test_doctor_unreachable_target_exit_one(doctor_home, monkeypatch, capsys):
+    _write_config(doctor_home, [_TARGET])
+    _seed_secret(monkeypatch)
+    monkeypatch.setattr(connection_mod, "ConnectionManager", _UnreachableManager)
+    assert run_doctor() == 1
+    out = capsys.readouterr().out
+    assert "Connect to 'primary' failed" in out
+    assert "refused" in out
+
+
+@pytest.mark.unit
+def test_doctor_no_secret_store_and_no_password(doctor_home, capsys):
+    _write_config(doctor_home, [_TARGET])
+    assert run_doctor(skip_auth=True) == 1
+    out = capsys.readouterr().out
+    assert "No secret store yet" in out
+    assert "No password for target 'primary'" in out
+
+
+@pytest.mark.unit
+def test_doctor_legacy_env_file_warns_migrate(doctor_home, monkeypatch, capsys):
+    _write_config(doctor_home, [_TARGET])
+    (doctor_home / ".env").write_text("PG_PRIMARY_PASSWORD=legacy\n", "utf-8")
+    monkeypatch.setenv("PG_PRIMARY_PASSWORD", "legacy")
+    assert run_doctor(skip_auth=True) == 0
+    out = capsys.readouterr().out
+    assert "legacy plaintext .env" in out
+    assert "secret migrate" in out
+
+
+@pytest.mark.unit
+def test_doctor_warns_on_loose_secret_permissions(doctor_home, monkeypatch, capsys):
+    _write_config(doctor_home, [_TARGET])
+    _seed_secret(monkeypatch)
+    (doctor_home / "secrets.enc").chmod(0o644)
+    assert run_doctor(skip_auth=True) == 0
+    assert "should be 600" in capsys.readouterr().out
+
+
+@pytest.mark.unit
+def test_cli_doctor_command_exits_with_doctor_code(doctor_home, monkeypatch):
+    from typer.testing import CliRunner
+
+    from postgres_aiops.cli import app
+
+    _write_config(doctor_home, [_TARGET])
+    _seed_secret(monkeypatch)
+    result = CliRunner().invoke(app, ["doctor", "--skip-auth"])
+    assert result.exit_code == 0
+    assert "Skipping connectivity check" in result.output

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/tests/test_governance_persistence.py

@@ -146,3 +146,25 @@ def test_real_write_tool_persists_priorstate_undo(gov_home, monkeypatch, fake_pg
     audit = _rows(gov_home / "audit.db", "audit_log")
     assert [r["tool"] for r in audit] == ["drop_index"]
     assert audit[0]["risk_level"] == "high"
+
+@pytest.mark.unit
+def test_sanitized_error_result_is_audited_as_error_and_records_no_undo(gov_home):
+    """@tool_errors converts exceptions to {"error": ...} dicts before the harness
+    sees them — those must land in the audit log as status=error (not ok), and no
+    undo may be recorded for a call that changed nothing."""
+
+    @governed_tool(
+        risk_level="low",
+        undo=lambda p, r: {"tool": "never_recorded", "params": {}},
+    )
+    def _broken_widget(target: str = "") -> dict:
+        return {"error": "boom (sanitized upstream)"}
+
+    result = _broken_widget(target="t1")
+    assert result["error"]
+    assert "_undo_id" not in result
+
+    audit = _rows(gov_home / "audit.db", "audit_log")
+    assert audit[-1]["tool"] == "_broken_widget"
+    assert audit[-1]["status"] == "error"
+    assert not (gov_home / "undo.db").exists() or not _rows(gov_home / "undo.db", "undo_log")

postgres_aiops-0.2.1/tests/test_init.py

@@ -0,0 +1,122 @@
+"""Tests for the ``postgres-aiops init`` onboarding wizard.
+
+The wizard is driven end-to-end through Typer's CliRunner with every path
+(config.yaml, secrets.enc, rules.yaml) isolated under tmp_path. The master
+password comes from POSTGRES_AIOPS_MASTER_PASSWORD (the non-interactive path)
+and the hidden target-password prompt is patched at the getpass boundary.
+"""
+
+from __future__ import annotations
+
+import getpass as getpass_mod
+
+import pytest
+import yaml
+from typer.testing import CliRunner
+
+import postgres_aiops.cli.init as init_mod
+import postgres_aiops.config as config_mod
+import postgres_aiops.doctor as doctor_mod
+import postgres_aiops.secretstore as ss
+
+MASTER_PW = "init-master-pw"
+DB_PW = "db-role-pa55word"
+
+# Wizard answers: name, host, then accept defaults for port/dbname/user/sslmode,
+# no second target, decline the trailing doctor run.
+WIZARD_INPUT = "primary\ndb1.example.com\n\n\n\n\nn\nn\n"
+
+
+@pytest.fixture
+def init_home(tmp_path, monkeypatch):
+    """Isolate config + secret store + governance home under tmp_path."""
+    config_file = tmp_path / "config.yaml"
+    secrets_file = tmp_path / "secrets.enc"
+    monkeypatch.setenv("POSTGRES_AIOPS_HOME", str(tmp_path))
+    monkeypatch.setenv("POSTGRES_AIOPS_MASTER_PASSWORD", MASTER_PW)
+    monkeypatch.setattr(init_mod, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(init_mod, "CONFIG_FILE", config_file)
+    monkeypatch.setattr(config_mod, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(config_mod, "CONFIG_FILE", config_file)
+    monkeypatch.setattr(ss, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(ss, "SECRETS_FILE", secrets_file)
+    monkeypatch.setattr(ss, "LEGACY_ENV_FILE", tmp_path / ".env")
+    monkeypatch.setattr(ss, "_cached", None)
+    # The hidden per-target password prompt bypasses CliRunner stdin.
+    monkeypatch.setattr(getpass_mod, "getpass", lambda prompt="": DB_PW)
+    return tmp_path
+
+
+def _run_init(input_text: str = WIZARD_INPUT):
+    from postgres_aiops.cli import app
+
+    return CliRunner().invoke(app, ["init"], input=input_text)
+
+
+@pytest.mark.unit
+def test_init_writes_config_with_entered_values(init_home):
+    result = _run_init()
+    assert result.exit_code == 0, result.output
+    raw = yaml.safe_load((init_home / "config.yaml").read_text("utf-8"))
+    assert raw["targets"] == [
+        {
+            "name": "primary",
+            "host": "db1.example.com",
+            "port": 5432,
+            "dbname": "postgres",
+            "user": "postgres",
+            "sslmode": "prefer",  # accepted default must land in config
+        }
+    ]
+
+
+@pytest.mark.unit
+def test_init_stores_secret_encrypted_not_in_config(init_home):
+    result = _run_init()
+    assert result.exit_code == 0, result.output
+    # Password is readable back through the secret store API...
+    assert ss.SecretStore.unlock(MASTER_PW).get("primary") == DB_PW
+    # ...and never lands in plaintext in config.yaml or secrets.enc.
+    assert DB_PW not in (init_home / "config.yaml").read_text("utf-8")
+    assert DB_PW not in (init_home / "secrets.enc").read_text("utf-8")
+
+
+@pytest.mark.unit
+def test_init_seeds_default_rules_with_dual_control_tier(init_home):
+    result = _run_init()
+    assert result.exit_code == 0, result.output
+    rules = yaml.safe_load((init_home / "rules.yaml").read_text("utf-8"))
+    tiers = {r["name"]: r for r in rules["risk_tiers"]}
+    assert "high-risk-requires-approver" in tiers
+    assert tiers["high-risk-requires-approver"]["tier"] == "dual"
+    assert tiers["high-risk-requires-approver"]["min_risk_level"] == "high"
+
+
+@pytest.mark.unit
+def test_init_rerun_does_not_clobber_existing_rules(init_home):
+    sentinel = "# operator-authored rules — must survive re-init\nrisk_tiers: []\n"
+    (init_home / "rules.yaml").write_text(sentinel, "utf-8")
+    result = _run_init()
+    assert result.exit_code == 0, result.output
+    assert (init_home / "rules.yaml").read_text("utf-8") == sentinel
+
+
+@pytest.mark.unit
+def test_init_accepting_doctor_confirm_runs_doctor(init_home, monkeypatch):
+    calls: list[bool] = []
+    monkeypatch.setattr(doctor_mod, "run_doctor", lambda: calls.append(True) or 0)
+    # Empty last answer accepts the confirm's default=True.
+    result = _run_init("primary\ndb1.example.com\n\n\n\n\nn\n\n")
+    assert result.exit_code == 0, result.output
+    assert calls == [True]
+
+
+@pytest.mark.unit
+def test_init_overwrite_existing_target(init_home):
+    result = _run_init()
+    assert result.exit_code == 0, result.output
+    # Same name again: confirm overwrite, new host, accept defaults.
+    result = _run_init("primary\ny\ndb2.example.com\n\n\n\n\nn\nn\n")
+    assert result.exit_code == 0, result.output
+    raw = yaml.safe_load((init_home / "config.yaml").read_text("utf-8"))
+    assert [t["host"] for t in raw["targets"]] == ["db2.example.com"]

postgres_aiops-0.2.1/tests/test_undo_replay.py

@@ -0,0 +1,66 @@
+"""drop_index → create_index(definition=…) undo REPLAY — the descriptor recorded
+by _drop_index_undo must be executable by the tool it names (found broken in the
+line-wide undo-replayability sweep: create_index had no ``definition`` param)."""
+
+from __future__ import annotations
+
+import pytest
+
+from mcp_server.tools import remediation as gov
+from postgres_aiops.ops import remediation as ops
+
+INDEXDEF = 'CREATE UNIQUE INDEX idx_orders_ts ON public.orders USING btree (ts)'
+
+
+@pytest.mark.unit
+def test_drop_index_descriptor_replays_through_create_index(fake_pg, monkeypatch):
+    fake = fake_pg(scalars={"pg_get_indexdef": INDEXDEF})
+    monkeypatch.setattr(gov, "_get_connection", lambda target=None: fake)
+
+    dropped = gov.drop_index(name="idx_orders_ts")
+    assert dropped["priorState"]["indexdef"] == INDEXDEF
+
+    descriptor = gov._drop_index_undo({"name": "idx_orders_ts"}, dropped)
+    assert descriptor["tool"] == "create_index"
+
+    replay = gov.create_index(**descriptor["params"])
+    assert replay["index"] == "idx_orders_ts"
+    assert replay["fromDefinition"] is True
+    assert (INDEXDEF, None) in fake.executed
+
+
+@pytest.mark.unit
+def test_create_index_definition_and_columns_are_mutually_exclusive(fake_pg, monkeypatch):
+    fake = fake_pg()
+    monkeypatch.setattr(gov, "_get_connection", lambda target=None: fake)
+    result = gov.create_index(table="t", columns=["a"], definition=INDEXDEF)
+    assert "not both" in result["error"]
+    result = gov.create_index()
+    assert "requires table+columns" in result["error"]
+    assert fake.executed == []
+
+
+@pytest.mark.unit
+@pytest.mark.parametrize(
+    "bad",
+    [
+        "DROP TABLE users",
+        "CREATE INDEX a ON t (c); DROP TABLE users",
+        "SELECT 1",
+        "",
+    ],
+)
+def test_create_index_from_definition_rejects_non_indexdef_shapes(fake_pg, bad):
+    fake = fake_pg()
+    with pytest.raises(ValueError):
+        ops.create_index_from_definition(fake, bad)
+    assert fake.executed == []
+
+
+@pytest.mark.unit
+def test_create_index_definition_dry_run_executes_nothing(fake_pg, monkeypatch):
+    fake = fake_pg()
+    monkeypatch.setattr(gov, "_get_connection", lambda target=None: fake)
+    result = gov.create_index(definition=INDEXDEF, dry_run=True)
+    assert result["dryRun"] is True and result["wouldExecute"] == INDEXDEF
+    assert fake.executed == []

{postgres_aiops-0.2.0 → postgres_aiops-0.2.1}/uv.lock

@@ -484,7 +484,7 @@ wheels = [
 
 [[package]]
 name = "postgres-aiops"
-version = "0.2.0"
+version = "0.2.1"
 source = { editable = "." }
 dependencies = [
     { name = "cryptography" },