pythia-plsql 0.4.6__tar.gz → 0.4.8__tar.gz

{pythia_plsql-0.4.6/scripts/pythia_plsql.egg-info → pythia_plsql-0.4.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.4.6
+Version: 0.4.8
 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.4.6 → pythia_plsql-0.4.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pythia-plsql"
-version = "0.4.6"
+version = "0.4.8"
 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.4.6 → pythia_plsql-0.4.8}/scripts/pythia.py

@@ -185,6 +185,114 @@ def paint_diff_line(ln, enabled):
     return ln
 
 
+NL = chr(10)   # a literal escape does not survive every editing path
+
+
+def offer_path_fix(scripts_dir, interactive, forced=False):
+    """Put pythia on PATH for the developer instead of handing them a command
+    to run. Only ever touches the user PATH, and only with a yes."""
+    if not scripts_dir or os.name != "nt":
+        return False
+    if not forced:
+        if not interactive:
+            return False
+        try:
+            answer = input(NL + "Add it to your PATH now? [Y/n] ").strip().lower()
+        except (EOFError, KeyboardInterrupt):
+            print()
+            return False
+        if answer not in ("", "y", "yes"):
+            return False
+    try:
+        changed = add_to_user_path(scripts_dir)
+    except OSError as e:
+        print(f"Could not update your PATH: {e}")
+        return False
+    print(NL + f"  {'Added' if changed else 'Already in'} your user PATH: {scripts_dir}")
+    warn = path_length_warning(os.environ.get("PATH", ""))
+    if warn:
+        print("  " + warn)
+    print("  Open a NEW terminal for it to take effect — an already-running")
+    print("  one keeps the environment it started with, and so do its tabs.")
+    print(f"  Until then: {pathlib.Path(sys.executable).stem} -m pythia <command>")
+    return True
+
+
+def path_length_warning(combined):
+    """Windows tooling still truncates PATH around 2047 characters, and a
+    freshly appended entry sits last -- so it is the first thing lost, and it
+    is lost silently. The usual cause is a PATH that had the system entries
+    copied into the user's."""
+    n = len(combined or "")
+    if n < 1900:
+        return None
+    return (f"Your PATH is {n} characters; Windows truncates near 2047, and the "
+            "entry just added is last in line.\n"
+            "  The usual cause is duplicate entries — the system PATH copied "
+            "into the user PATH by\n"
+            "  a `$env:PATH` one-liner. Compare the two scopes and remove what "
+            "appears in both.")
+
+
+def stored_path_has(directory):
+    """Is the directory in the PATH as *stored*, rather than the one this
+    process inherited? The two differ for every terminal opened before the
+    last change, which is the common confusion."""
+    if not directory or os.name != "nt":
+        return False
+    try:
+        return path_contains(_read_user_path(), directory)
+    except OSError:
+        return False
+
+
+def path_contains(path_value, directory):
+    """Is this directory already listed in a PATH string? Compared the way
+    the platform does: case-insensitively on Windows, ignoring trailing
+    separators and empty entries."""
+    want = os.path.normcase(os.path.normpath(str(directory)))
+    return any(os.path.normcase(os.path.normpath(p)) == want
+               for p in str(path_value).split(os.pathsep) if p.strip())
+
+
+def _read_user_path():
+    import winreg
+    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Environment") as k:
+        try:
+            return winreg.QueryValueEx(k, "Path")[0]
+        except FileNotFoundError:
+            return ""
+
+
+def _write_user_path(value):
+    import winreg
+    with winreg.OpenKey(winreg.HKEY_CURRENT_USER, "Environment", 0,
+                        winreg.KEY_SET_VALUE) as k:
+        winreg.SetValueEx(k, "Path", 0, winreg.REG_EXPAND_SZ, value)
+
+
+def add_to_user_path(directory, read=None, write=None):
+    """Append a directory to the *user* PATH, returning whether anything
+    changed.
+
+    Reads the stored user value, never `os.environ["PATH"]`. The process
+    environment is the system and user values merged, so writing it back into
+    user scope copies every system entry into the user's -- doubling the
+    effective PATH and leaving a stale snapshot that shadows the real system
+    one after it next changes. That mistake is easy to make and outlives the
+    install, which is why this function exists rather than a one-line command.
+    """
+    read = read or _read_user_path
+    write = write or _write_user_path
+    current = read() or ""
+    if path_contains(current, directory):
+        return False
+    joined = str(directory) if not current.strip() else \
+        current.rstrip(os.pathsep) + os.pathsep + str(directory)
+    write(joined)
+    return True
+
+
 def installed_scripts_dir():
     """The directory pip put our executable in. The default scheme is wrong
     for `pip install --user` — the common case on Windows — so the candidate
@@ -203,7 +311,7 @@ def installed_scripts_dir():
     return candidates[-1] if candidates else None
 
 
-def entry_point_hint(found, scripts_dir):
+def entry_point_hint(found, scripts_dir, in_stored_path=False):
     """What to say when `pythia` will not resolve as a command. pip installs
     the executable into a scripts directory that is often not on PATH — the
     default for `pip install --user` on Windows — and the shell's
@@ -211,13 +319,32 @@ def entry_point_hint(found, scripts_dir):
     step immediately after the install the docs tell you to run."""
     if found:
         return None
+    if in_stored_path:
+        # The directory is in the stored PATH but not in this process: the
+        # terminal started before the change. Sending someone to re-run the
+        # install here wastes their time -- it already worked.
+        return (NL.join([
+            "`pythia` is already on your PATH — this terminal just started "
+            "before that was true.",
+            "  Open a NEW terminal WINDOW. A new tab is not enough: tabs "
+            "inherit the",
+            "  environment of the window that spawned them, so if you use "
+            "Windows Terminal,",
+            "  VS Code or Cursor, restart the application itself.",
+            "  In this one, keep using: "
+            + pathlib.Path(sys.executable).stem + " -m pythia <command>",
+        ]))
     out = ["`pythia` is installed but not on your PATH."]
     if scripts_dir:
         out.append("  It lives in: " + str(scripts_dir))
         if os.name == "nt":
-            out.append("  Add it once, in PowerShell, then reopen the terminal:")
-            out.append("    [Environment]::SetEnvironmentVariable('PATH',")
-            out.append("      \"$env:PATH;" + str(scripts_dir) + "\", 'User')")
+            # Deliberately not a PowerShell one-liner over $env:PATH:
+            # that variable is system and user merged, so writing it
+            # back into user scope copies every system entry into the
+            # user's. Let the tool do it correctly instead.
+            out.append("  Put it there with: "
+                       + pathlib.Path(sys.executable).stem
+                       + " -m pythia install --add-to-path")
         else:
             out.append("  Add it to your shell profile:")
             out.append("    export PATH=\"$PATH:" + str(scripts_dir) + "\"")
@@ -1974,11 +2101,14 @@ def cmd_install(conn, schema, ns):
             clean_legacy_skills(ns.project_root)
     print(f"\nNext: fill in {path}")
     print(f"Then: {invocation()} check")
-    hint = entry_point_hint(shutil.which("pythia"),
-                             installed_scripts_dir())
+    scripts_dir = installed_scripts_dir()
+    hint = entry_point_hint(shutil.which("pythia"), scripts_dir,
+                            in_stored_path=stored_path_has(scripts_dir))
     if hint:
         print()
         print(hint)
+        offer_path_fix(scripts_dir, interactive,
+                       getattr(ns, "add_to_path", False))
 
 
 COMMANDS = {"check": cmd_check, "ls": cmd_ls, "src": cmd_src, "args": cmd_args,
@@ -2112,6 +2242,9 @@ def build_parser():
     s.add_argument("-g", "--global", dest="glob", action="store_true",
                    help="install the skill pack machine-wide (serves every "
                         "project; per-project installs then skip skills)")
+    s.add_argument("--add-to-path", action="store_true", dest="add_to_path",
+                   help="put the pythia command on your PATH without asking "
+                        "(Windows; user PATH only)")
     s.add_argument("--source", default=DEFAULT_SKILLS_SOURCE,
                    help="skills repo for `npx skills add` "
                         f"(default {DEFAULT_SKILLS_SOURCE})")

{pythia_plsql-0.4.6 → pythia_plsql-0.4.8/scripts/pythia_plsql.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pythia-plsql
-Version: 0.4.6
+Version: 0.4.8
 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.4.6 → pythia_plsql-0.4.8}/tests/test_install.py

@@ -5,6 +5,7 @@ no network, no npx needed.
 Run: python tests/test_install.py
 """
 import json
+import os
 import pathlib
 import sys
 import tempfile
@@ -187,9 +188,9 @@ def test_entry_point_hint_names_the_directory_to_add():
     """pip install --user on Windows puts pythia.exe in a Scripts directory
     that is not on PATH, so the very next documented command fails with
     CommandNotFound -- naming nothing that helps. Seen on a real machine."""
-    hint = pythia.entry_point_hint(found=None, scripts_dir=r"C:\Py\Scripts")
+    hint = pythia.entry_point_hint(found=None, scripts_dir=SCRIPTS)
     assert hint is not None
-    assert r"C:\Py\Scripts" in hint          # the exact directory to add
+    assert SCRIPTS in hint          # the exact directory to add
     assert "-m pythia" in hint                # the fallback that works now
     # once the command resolves, say nothing
     assert pythia.entry_point_hint(found="/usr/local/bin/pythia",
@@ -235,6 +236,95 @@ def test_cmd_install_runs_end_to_end():
         assert env is not None
 
 
+# Native paths: on POSIX ':' is the PATH separator and would cut a
+# Windows path in half, so these are built from os.sep.
+SCRIPTS = os.path.join(os.sep + 'opt', 'a', 'Scripts')
+USERBIN = os.path.join(os.sep + 'opt', 'a', 'bin')
+SYS1 = os.sep + 'windows'
+SYS2 = os.path.join(os.sep + 'windows', 'system32')
+
+
+def test_path_contains_normalises_like_the_platform_does():
+    """Paths must be native: on POSIX the separator is ':', which cuts a
+    Windows path in half, and normcase does not fold case."""
+    import os
+    here = os.path.join(os.sep + "opt", "a", "Scripts")
+    other = os.path.join(os.sep + "opt", "a", "Other")
+    p = os.pathsep.join([os.sep + "usr", here, ""])   # trailing empty entry
+    assert pythia.path_contains(p, here)
+    assert pythia.path_contains(p, here + os.sep)     # trailing separator
+    assert not pythia.path_contains(p, other)
+    assert not pythia.path_contains("", here)
+    if os.name == "nt":                               # case folds on Windows only
+        assert pythia.path_contains(p, here.upper())
+
+
+def test_add_to_user_path_reads_the_stored_value_not_the_process_env():
+    """The process PATH is system+user merged. Writing that back into user
+    scope copies every system entry into the user's -- a mess that outlives
+    the install. This is the mistake this function exists to not repeat."""
+    import os
+    written = []
+    stored = USERBIN          # what the registry holds: user only
+    os.environ["PATH"] = os.pathsep.join(   # what the process sees: much more
+        [SYS1, SYS2, stored])
+    changed = pythia.add_to_user_path(SCRIPTS,
+                                      read=lambda: stored,
+                                      write=written.append)
+    assert changed is True
+    assert written == [stored + os.pathsep + SCRIPTS]
+    assert SYS1 not in written[0]      # no system entries leaked in
+
+
+def test_add_to_user_path_is_idempotent():
+    written = []
+    changed = pythia.add_to_user_path(SCRIPTS,
+                                      read=lambda: SCRIPTS,
+                                      write=written.append)
+    assert changed is False and written == []
+
+
+def test_add_to_user_path_handles_an_empty_and_untidy_value():
+    import os
+    written = []
+    pythia.add_to_user_path(SCRIPTS, read=lambda: "", write=written.append)
+    assert written == [SCRIPTS]
+    written.clear()
+    pythia.add_to_user_path(SCRIPTS, read=lambda: USERBIN + os.pathsep,
+                            write=written.append)
+    assert written == [USERBIN + os.pathsep + SCRIPTS]   # no doubled separator
+
+
+def test_hint_tells_a_stale_shell_apart_from_an_unconfigured_one():
+    """The directory being in the stored PATH while the running process
+    cannot see it means one thing only: this terminal started earlier. Saying
+    "not on your PATH" there sends people to re-run an install that already
+    worked -- which is exactly what happened in the field."""
+    stale = pythia.entry_point_hint(found=None, scripts_dir=SCRIPTS,
+                                    in_stored_path=True)
+    assert "already" in stale.lower()
+    assert "new" in stale.lower() and "tab" in stale.lower()   # window, not tab
+    assert "--add-to-path" not in stale        # nothing to redo
+    unconfigured = pythia.entry_point_hint(found=None, scripts_dir=SCRIPTS,
+                                           in_stored_path=False)
+    assert SCRIPTS in unconfigured and "-m pythia" in unconfigured
+    # how you fix it is platform-specific: pythia can edit the registry on
+    # Windows, while a POSIX shell profile is the developer's to edit
+    assert ("--add-to-path" if os.name == "nt" else "profile") in unconfigured
+    # and once the command resolves, still silence
+    assert pythia.entry_point_hint(found="/x/pythia", scripts_dir=SCRIPTS,
+                                   in_stored_path=True) is None
+
+
+def test_long_path_is_flagged_before_it_silently_truncates():
+    """Windows tooling still truncates PATH near 2047 characters, and the
+    entry we just appended is the last one -- the first to be lost."""
+    assert pythia.path_length_warning("x" * 1000) is None
+    w = pythia.path_length_warning("x" * 2040)
+    assert w is not None and "2047" in w
+    assert "duplicate" in w.lower()      # names the usual cause
+
+
 def main():
     failed = 0
     for name, fn in sorted(globals().items()):