pythia-plsql 0.11.0__tar.gz → 0.11.2__tar.gz

{pythia_plsql-0.11.0/scripts/pythia_plsql.egg-info → pythia_plsql-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.11.0
+Version: 0.11.2
 Summary: PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback.
 License: MIT
 Project-URL: Homepage, https://github.com/thaildhe172591/pythia

{pythia_plsql-0.11.0 → pythia_plsql-0.11.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythia-plsql"
-version = "0.11.0"
+version = "0.11.2"
 description = "PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback."
 readme = "README.md"
 license = { text = "MIT" }

{pythia_plsql-0.11.0 → pythia_plsql-0.11.2}/scripts/pythia.py

@@ -713,7 +713,12 @@ def plscope_message(name, has_any_data):
 GROUPS = ("plsql_source", "data_dml", "structural", "grants", "session")
 
 PLSQL_SOURCE_RE = re.compile(
-    r"^create\s+(?:or\s+replace\s+)?(?:(?:no)?editionable\s+|(?:no)?force\s+)*"
+    # NONEDITIONABLE, not "noeditionable": Oracle's keyword has the middle N,
+    # and missing it dropped every NONEDITIONABLE object into structural —
+    # deny by default, and counted by semicolons, so a PL/SQL body read as
+    # "more than one statement". Both spellings are accepted here; only the
+    # database decides whether the statement is valid.
+    r"^create\s+(?:or\s+replace\s+)?(?:(?:non?)?editionable\s+|(?:no)?force\s+)*"
     r"(procedure|function|package\s+body|package|trigger|view|type\s+body|type)\b",
     re.I | re.S)
 
@@ -1231,12 +1236,29 @@ def prune_expired_grants(root, now=None):
     return gone
 
 
-def render_restore(obj_type, name, before_text):
+EDITIONABLE_KW_RE = re.compile(
+    r"^create\s+(?:or\s+replace\s+)?((?:non?)?editionable)\b", re.I)
+
+
+def create_prefix(after_text):
+    """The CREATE header ALL_SOURCE does not store, rebuilt for the version
+    held in the database. The editionable keyword is read off the file being
+    applied, because the database's own answer is not in ALL_SOURCE and
+    Oracle refuses to *change* the property through CREATE OR REPLACE
+    (ORA-38824) — so a file that applies cleanly already spells the property
+    the object has. Getting this wrong costs twice: a restore that fails
+    exactly when it is needed, and a phantom line in the diff the developer
+    approves."""
+    m = EDITIONABLE_KW_RE.match(skip_leading_noise(after_text))
+    return "CREATE OR REPLACE " + (f"{m.group(1).upper()} " if m else "")
+
+
+def render_restore(obj_type, name, before_text, after_text=""):
     """The statement that puts things back. For an object that did not exist,
     undo means DROP — a genuinely different promise than restoring source, so
     the caller records created=True and the report says it plainly."""
     if before_text.strip():
-        return "CREATE OR REPLACE " + before_text.rstrip() + "\n"
+        return create_prefix(after_text) + before_text.rstrip() + "\n"
     return f"DROP {obj_type} {name}\n"
 
 
@@ -1256,7 +1278,7 @@ def write_journal_entry(root, obj_type, name, before, after, meta, now=None):
     d.mkdir(parents=True)
     (d / "before.sql").write_text(before, encoding="utf-8")
     (d / "after.sql").write_text(after, encoding="utf-8")
-    (d / "restore.sql").write_text(render_restore(obj_type, name, before),
+    (d / "restore.sql").write_text(render_restore(obj_type, name, before, after),
                                    encoding="utf-8")
     full = {"object": name, "type": obj_type, "created": not before.strip(),
             "entry": eid, **meta}
@@ -2105,8 +2127,10 @@ def run_apply(conn, schema, ns, file_text, origin=None):
 
     # 3. PREVIEW — diff like against like: ALL_SOURCE never stores the
     # CREATE OR REPLACE header, so prepend it before comparing, or an
-    # unchanged object would show a phantom two-line change forever.
-    base = ("CREATE OR REPLACE " + db_source) if db_source.strip() else ""
+    # unchanged object would show a phantom two-line change forever. The
+    # editionable keyword is part of that header, or a NONEDITIONABLE file
+    # shows its own first line as a change that is not one.
+    base = (create_prefix(stmt) + db_source) if db_source.strip() else ""
     diff_text, changed = render_diff(base, stmt)
     warn = privilege_warning(conn, schema, ns.conn_user)
     style = (naming_violation(otype, name, load_conventions(ns.project_root))
@@ -2307,10 +2331,17 @@ def token_mismatch_message(ns, row_set):
     base = ("The confirmation token does not match: the file or the "
             "database object changed since that preview. Preview again:\n"
             f"  {invocation()} apply {ns.file}")
-    if not row_set:
-        return base
     _, meta = find_preview_by_token(ns.project_root,
                                     str(ns.confirm).strip().lower())
+    if (meta or {}).get("applied"):
+        # the token names a preview that already ran. "the file changed" is
+        # the wrong story, and sends the agent hunting a difference that is
+        # not there
+        return (f"Token {str(ns.confirm).strip().lower()} was already applied "
+                "— one approval, one write.\nPreview again, then get the new "
+                f"token approved:\n  {invocation()} apply {ns.file}")
+    if not row_set:
+        return base
     then = (meta or {}).get("row_set") or {}
     if not then or fingerprint_text(then) == fingerprint_text(row_set):
         return base                       # the file moved, not the rows
@@ -3443,10 +3474,15 @@ def build_parser():
 def main(argv=None):
     argv = sys.argv[1:] if argv is None else argv
     forbid_write_flag(argv)
-    for stream in (sys.stdout, sys.stderr):
+    # stdin too, and before anything reads it: the AskUserQuestion hook
+    # payload is UTF-8, and Windows would decode it as cp1252 — an em dash
+    # arrives as mojibake and no approval card ever matches again.
+    # line_buffering keeps stdout in order with stderr when both are pipes,
+    # so a driver error lands after the preview it belongs to, not above it.
+    for stream in (sys.stdout, sys.stderr, sys.stdin):
         try:
-            stream.reconfigure(encoding="utf-8")
-        except AttributeError:
+            stream.reconfigure(encoding="utf-8", line_buffering=True)
+        except (AttributeError, ValueError):
             pass
     ns = build_parser().parse_args(argv)
     # refusals that need no database come first — an unreachable or locked

{pythia_plsql-0.11.0 → pythia_plsql-0.11.2/scripts/pythia_plsql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.11.0
+Version: 0.11.2
 Summary: PL/SQL development for AI agents on Oracle Database - expert data-dictionary queries, impact analysis, and a snapshot-verified write path with honest rollback.
 License: MIT
 Project-URL: Homepage, https://github.com/thaildhe172591/pythia

{pythia_plsql-0.11.0 → pythia_plsql-0.11.2}/tests/test_phase3.py

@@ -32,6 +32,11 @@ def test_classify_groups():
     assert c("alter table t_order add (x number)") == "structural"  # session tested first
     assert c("CREATE OR REPLACE PROCEDURE p AS BEGIN NULL; END;") == "plsql_source"
     assert c("create or replace editionable package body pkg_order as end;") == "plsql_source"
+    # Oracle's keyword is NONEDITIONABLE, with the middle N. Missing it sent
+    # every such object to structural — deny by default, and counted by
+    # semicolons, so a PL/SQL body came back as "more than one statement".
+    assert c("create or replace NONEDITIONABLE procedure p as begin null; end;") == "plsql_source"
+    assert c("CREATE OR REPLACE NONEDITIONABLE PACKAGE BODY pkg AS END;") == "plsql_source"
     assert c("CREATE OR REPLACE FORCE VIEW v AS SELECT 1 FROM dual") == "plsql_source"
     assert c("CREATE TABLE t (x number)") == "structural"  # other CREATE
     assert c("insert into t values (1)") == "data_dml"
@@ -54,6 +59,27 @@ def test_parse_object():
     assert (t, n, s) == ("TYPE BODY", "T_THING", None)
     t, n, s = pythia.parse_object("CREATE OR REPLACE TRIGGER trg_x BEFORE INSERT ON t BEGIN NULL; END;")
     assert (t, n, s) == ("TRIGGER", "TRG_X", None)
+    # the identity drives the snapshot, so the editionable keyword must not
+    # shift what is parsed out of the statement
+    t, n, s = pythia.parse_object(
+        "CREATE OR REPLACE NONEDITIONABLE PROCEDURE core_bh.pbh_file_nh AS BEGIN NULL; END;")
+    assert (t, n, s) == ("PROCEDURE", "PBH_FILE_NH", "CORE_BH")
+
+
+def test_restore_keeps_the_editionable_property():
+    """ALL_SOURCE holds no CREATE prefix, so the restore builds one. On an
+    editions-enabled schema a bare CREATE OR REPLACE over a NONEDITIONABLE
+    object is ORA-38824 — an undo that fails exactly when it is needed."""
+    body = "PROCEDURE p AS BEGIN NULL; END;"
+    assert pythia.render_restore("PROCEDURE", "P", body, "CREATE OR REPLACE " + body) \
+        == "CREATE OR REPLACE " + body + "\n"
+    assert pythia.render_restore(
+        "PROCEDURE", "P", body,
+        "create or replace noneditionable procedure p as begin null; end;") \
+        == "CREATE OR REPLACE NONEDITIONABLE " + body + "\n"
+    # a new object still has no source to put back: undo is a DROP
+    assert pythia.render_restore("PROCEDURE", "P", "", "CREATE OR REPLACE NONEDITIONABLE PROCEDURE p") \
+        == "DROP PROCEDURE P\n"
 
 
 def test_prepare_statement_terminators():
@@ -1475,6 +1501,38 @@ def test_apply_reads_a_bom_file_as_the_statement_it_is():
         assert "approve --card" in buf.getvalue()      # it previewed
 
 
+def test_apply_previews_a_noneditionable_object_end_to_end():
+    """The reported bug, from the outside: NONEDITIONABLE missed the
+    classifier, fell through to structural — which counts statements by
+    semicolon — and a PL/SQL body came back as 'more than one statement'.
+    The only escape was dropping the keyword, which Oracle then met with
+    ORA-38824. Preview must produce a token, and the restore must keep the
+    property."""
+    import contextlib
+    import io
+    import pathlib
+    src = ("CREATE OR REPLACE NONEDITIONABLE PACKAGE BODY pkg_order AS\n"
+           "  new line;\nEND;\n/\n")
+    with tempfile.TemporaryDirectory() as td:
+        f = pathlib.Path(td) / "f.sql"
+        f.write_text(src, encoding="utf-8")
+        buf = io.StringIO()
+        with contextlib.redirect_stdout(buf):
+            pythia.cmd_apply(FakeConn(base_script()), "APP",
+                             apply_ns(td, file=str(f)))
+        out = buf.getvalue()
+        assert "more than one statement" not in out
+        assert "approve --card" in out                  # it previewed
+        entry = pythia.list_journal_entries(td)[0]
+        restore = (pythia.journal_root(td) / entry / "restore.sql").read_text(
+            encoding="utf-8")
+        assert restore.startswith("CREATE OR REPLACE NONEDITIONABLE ")
+        # and the keyword is not shown as a change it is not: ALL_SOURCE holds
+        # no header, so the diff's base has to carry the same one
+        assert "-CREATE OR REPLACE" not in out and "+CREATE OR REPLACE" not in out
+        assert "2 lines changed" in out          # the body line, not the header
+
+
 def test_apply_refuses_when_the_session_schema_is_not_the_configured_one():
     """A proxy into another user, or a stale `schema` in connections.json:
     an unqualified CREATE would land in one schema while pythia snapshots
@@ -1507,5 +1565,49 @@ def main():
     print("OK")
 
 
+
+
+def test_hook_matches_a_card_with_a_non_ascii_dash_through_real_stdin():
+    """The whole hook, end to end, the way Claude Code runs it: UTF-8 bytes on
+    a pipe. Windows decodes stdin as cp1252 unless told otherwise, and the em
+    dash in the structural card would arrive as mojibake — no card would ever
+    match again. Subprocess on purpose: an in-process StringIO is already
+    decoded and cannot fail this way."""
+    import subprocess
+    with tempfile.TemporaryDirectory() as td:
+        stmt = "ALTER PROCEDURE PKG_ORDER COMPILE;"
+        pythia.write_journal_entry(
+            td, "STRUCTURAL", "STATEMENT", "", stmt,
+            {"token": "dc8d27", "connection": "DEV", "schema": "APP",
+             "group": "structural", "applied": False})
+        _, _, body = pythia.approval_card(td, "dc8d27")
+        card = "python -m pythia approve dc8d27\n" + "\n".join(body)
+        assert "—" in card, "the structural card is the non-ASCII one"
+        payload = json.dumps(_hook_payload(card, "Approve"), ensure_ascii=False)
+        p = subprocess.run(
+            [sys.executable,
+             str(pathlib.Path(pythia.__file__).resolve()), "approve", "--hook"],
+            input=payload.encode("utf-8"), cwd=td, capture_output=True)
+        assert p.returncode == 0, p.stderr.decode("utf-8", "replace")
+        g = pythia.read_grant(td, "dc8d27")
+        assert g and g["approver"] == "chat", p.stdout.decode("utf-8", "replace")
+
+
+def test_token_mismatch_names_an_already_applied_preview():
+    """A spent token is not a moved file. Saying 'the file or the object
+    changed' sends the agent looking for a difference that is not there."""
+    import argparse
+    with tempfile.TemporaryDirectory() as td:
+        pythia.write_journal_entry(
+            td, "PACKAGE BODY", "PKG_ORDER", OLD_SRC, NEW_FILE,
+            {"token": "7f3a91", "connection": "DEV", "schema": "APP",
+             "group": "plsql_source", "applied": True})
+        ns = argparse.Namespace(project_root=td, confirm="7f3a91",
+                                file="pkg.sql")
+        msg = pythia.token_mismatch_message(ns, None)
+        assert "already applied" in msg and "changed since that preview" not in msg
+
+
+
 if __name__ == "__main__":
     main()