pipulate 2.44__tar.gz → 2.45__tar.gz

{pipulate-2.44/pipulate.egg-info → pipulate-2.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipulate
-Version: 2.44
+Version: 2.45
 Summary: AI-readiness for the agentic web — local-first, Nix-reproducible workflows. The successor to AI SEO software.
 Author-email: Mike Levin <pipulate@gmail.com>
 License-Expression: AGPL-3.0-or-later

{pipulate-2.44 → pipulate-2.45}/__init__.py

@@ -12,7 +12,7 @@ Usage:
     pipulate
 """
 
-__version__ = "2.44"
+__version__ = "2.45"
 # APOSTROPHES RESTORED (2026-08-04). They were stripped as a workaround for
 # flake.nix's descMatch regex, whose character class excluded ' from the
 # CAPTURE and truncated the banner to "(So)". That regex was fixed in the same
@@ -23,7 +23,7 @@ __version__ = "2.44"
 # is not a property of the system; the regex is. Blast radius is one banner:
 # nothing but flake.nix reads this name -- version_sync.py syncs __version__
 # and __description__, never this. So'wI' chu' -- "engage the cloaking device."
-__version_description__ = "Massaging Install Paths"
+__version_description__ = "Shoshinification"
 # SPDX expression, single source of truth, synced into pyproject.toml by
 # scripts/release/version_sync.py. "-or-later" (not bare AGPL-3.0, which is
 # deprecated SPDX) because the header below grants "any later version".

{pipulate-2.44 → pipulate-2.45}/cli.py

@@ -316,11 +316,108 @@ def run_install_script(app_name):
     console.print(f"✅ Installation complete!")
     return target_dir
 
+# --- MARKER DISCOVERY -------------------------------------------------------
+# THE DERIVED-PATH RULE, aimed at DISCOVERY instead of at writing:
+# root = f(marker), never root = f(guessed name). A directory is a workshop
+# because it CARRIES the marker, never because it is SPELLED like one.
+#
+# THE MARKER IS A TRACKED TRIPLE, NOT whitelabel.txt. whitelabel.txt is listed
+# in .gitignore and is written by the flake's runScript on first entry, so a
+# fresh `git clone` has none -- and neither does any workshop only ever entered
+# through `.#quiet`, which skips runScript entirely. A marker that is ABSENT ON
+# A LEGITIMATE WORKSHOP is worse than no marker at all: it turns a false
+# negative into a confident refusal. whitelabel.txt is therefore the
+# DISAMBIGUATOR, never the certificate -- the identical split
+# assets/installer/mck.sh made in v0.2.0, and this is deliberately its parity
+# implementation. Two readers, ONE definition of "workshop"; if these drift,
+# the launcher and the CLI disagree about what is installed, silently.
+WORKSHOP_MARKERS = ("flake.nix", "scripts/mother_cat.py", "assets/trails")
+def is_workshop(path):
+    """True when this directory CARRIES the marker, whatever it is named."""
+    try:
+        return all((path / marker).exists() for marker in WORKSHOP_MARKERS)
+    except OSError:
+        return False
+def workshop_label(path):
+    """Read the disambiguator; fall back to the directory name.
+    Case-folded because whitelabel.txt has TWO writers with TWO spellings:
+    install.sh writes the name it was handed (lowercase by default) and the
+    flake writes a capitalized literal. mck.sh records the same conviction.
+    """
+    try:
+        label_file = path / "whitelabel.txt"
+        if label_file.is_file():
+            lines = label_file.read_text(encoding="utf-8").splitlines()
+            if lines and lines[0].strip():
+                return lines[0].strip().lower()
+    except (OSError, UnicodeDecodeError):
+        pass
+    return path.name.lower()
+def find_workshops(app_name):
+    """Ordered candidates; every one must still pass is_workshop().
+    Order mirrors mck.sh's find_checkouts: explicit env, then upward from CWD,
+    then ONE bounded level under the usual parents. Deliberately no recursive
+    sweep -- a CLI must not walk a stranger's home directory to find itself.
+    The guessed path rides LAST, demoted from ANSWER to CANDIDATE: the name
+    proposes a place to LOOK, the marker alone certifies a place to USE.
+    """
+    candidates = []
+    env_root = os.environ.get("PIPULATE_ROOT")
+    if env_root:
+        candidates.append(Path(env_root).expanduser())
+    here = Path.cwd().resolve()
+    candidates.append(here)
+    candidates.extend(here.parents)
+    home = Path.home()
+    for parent in (home, home / "repos", home / "src", home / "code",
+                   home / "dev", home / "Projects", home / "projects"):
+        try:
+            candidates.extend(sorted(p for p in parent.iterdir() if p.is_dir()))
+        except OSError:
+            continue
+    candidates.append(home / app_name)
+    found, seen = [], set()
+    for candidate in candidates:
+        key = str(candidate)
+        if key in seen:
+            continue
+        seen.add(key)
+        if is_workshop(candidate):
+            found.append(candidate)
+    return found
+def resolve_workshop(app_name):
+    """Return the selected workshop, or None. Never invents a path.
+    THE FALLBACK IS VISIBLE ON PURPOSE. Selecting by label and falling back to
+    first-found used to print the IDENTICAL line, which is how a selector went
+    unwitnessed for the entire life of a feature (SINGLE-CANDIDATE BLINDNESS,
+    convicted 2026-08-01 against this same head -n 1 shape in mck.sh). When
+    more than one workshop exists and none carries the requested label, say so
+    and name the losers, so selection and fallback print DIFFERENT things.
+    """
+    found = find_workshops(app_name)
+    if not found:
+        return None
+    wanted = (os.environ.get("PIPULATE_WHITELABEL") or app_name).lower()
+    for candidate in found:
+        if workshop_label(candidate) == wanted:
+            return candidate
+    if len(found) > 1:
+        console.print(f"⚠️  No workshop labeled '{wanted}'; falling back to first found.")
+        for candidate in found:
+            console.print(f"   • {candidate} (label: {workshop_label(candidate)})")
+    return found[0]
 def run_pipulate(app_name):
     """Runs an existing Pipulate installation."""
     target_dir = Path.home() / app_name
+    discovered = resolve_workshop(app_name)
+    if discovered is not None:
+        target_dir = discovered
     if not (target_dir.exists() and (target_dir / "flake.nix").is_file()):
-        console.print(f"❌ No Pipulate installation found at [cyan]~/{app_name}[/cyan].")
+        console.print("❌ No workshop found. A workshop is a directory that CARRIES the")
+        console.print(f"   marker ({', '.join(WORKSHOP_MARKERS)}), not one merely NAMED it.")
+        console.print(f"   Searched: $PIPULATE_ROOT, upward from {Path.cwd()}, one level")
+        console.print(f"   under {Path.home()} and its repos/src/code/dev/Projects/projects,")
+        console.print(f"   then the name-derived path ~/{app_name} (which must also carry it).")
         console.print(f"To install, run: [bold]pipulate install {app_name}[/bold]")
         sys.exit(1)
 

{pipulate-2.44 → pipulate-2.45/pipulate.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pipulate
-Version: 2.44
+Version: 2.45
 Summary: AI-readiness for the agentic web — local-first, Nix-reproducible workflows. The successor to AI SEO software.
 Author-email: Mike Levin <pipulate@gmail.com>
 License-Expression: AGPL-3.0-or-later

{pipulate-2.44 → pipulate-2.45}/pipulate.egg-info/SOURCES.txt

@@ -72,6 +72,7 @@ pipulate.egg-info/dependency_links.txt
 pipulate.egg-info/entry_points.txt
 pipulate.egg-info/requires.txt
 pipulate.egg-info/top_level.txt
+tests/test_apply_airlock.py
 tests/test_mck_rep2.py
 tools/__init__.py
 tools/advanced_automation_tools.py

{pipulate-2.44 → pipulate-2.45}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "pipulate"
 # VERSION NOTE: Synced from pipulate/__init__.py.__version__ via python version_sync.py
-version = "2.44"
+version = "2.45"
 authors = [
   { name="Mike Levin", email="pipulate@gmail.com" },
 ]

pipulate-2.45/tests/test_apply_airlock.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Regression tests for apply.py's autolink contamination airlock.
+
+Verifies that self-referential markdown autolinks -- the shape a chat renderer
+produces from a bare www-prefixed host between the compiler and the model --
+are refused before disk mutation on non-.md targets, while the deliberate .md
+exemption is preserved.
+
+Every forbidden signature is assembled at runtime from fragments so this file
+never contains the literal shape apply.py refuses. Otherwise the patch that
+creates this file would be refused by the very airlock it tests.
+"""
+import io
+import sys
+import tempfile
+import unittest
+from contextlib import redirect_stderr, redirect_stdout
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(REPO_ROOT))
+
+import apply
+
+
+def _make_autolink_www(domain="probe.invalid", scheme="https"):
+    prefix = "www."
+    host = prefix + domain
+    return f"[{host}]({scheme}://{host})"
+
+
+def _make_autolink_scheme(domain="probe.invalid", scheme="https"):
+    url = f"{scheme}://{domain}"
+    return f"[{url}]({url})"
+
+
+def _build_search_replace_payload(target, search, replace):
+    s_tag = "[" * 3 + "SEARCH" + "]" * 3
+    d_tag = "[" * 3 + "DIVIDER" + "]" * 3
+    r_tag = "[" * 3 + "REPLACE" + "]" * 3
+    return f"Target: {target}\n{s_tag}\n{search}\n{d_tag}\n{replace}\n{r_tag}\n"
+
+
+def _build_write_file_payload(target, content):
+    w_tag = "[" * 3 + "WRITE_FILE" + "]" * 3
+    e_tag = "[" * 3 + "END_WRITE_FILE" + "]" * 3
+    return f"Target: {target}\n{w_tag}\n{content}\n{e_tag}\n"
+
+
+class TestApplyAutolinkAirlock(unittest.TestCase):
+    def _apply(self, payload):
+        with redirect_stdout(io.StringIO()), redirect_stderr(io.StringIO()):
+            return apply.apply_search_replace_patch(payload)
+
+    def test_ordinary_search_replace_succeeds(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            target = Path(temp_dir) / "module.py"
+            target.write_text("x = 1\n", encoding="utf-8")
+            payload = _build_search_replace_payload(target, "x = 1", "x = 2")
+            self.assertTrue(self._apply(payload))
+            self.assertEqual(target.read_text(encoding="utf-8"), "x = 2\n")
+
+    def test_contaminated_search_replace_refuses_and_preserves_bytes(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            target = Path(temp_dir) / "module.py"
+            target.write_text("y = 3\n", encoding="utf-8")
+            bad_link = _make_autolink_www("airlock-test.invalid")
+            payload = _build_search_replace_payload(
+                target, "y = 3", f"# {bad_link}\ny = 4"
+            )
+            self.assertFalse(self._apply(payload))
+            self.assertEqual(target.read_text(encoding="utf-8"), "y = 3\n")
+
+    def test_clean_write_file_creation_succeeds(self):
+        # POSITIVE CONTROL for the WRITE_FILE lane. Without it, the two
+        # contaminated-WRITE_FILE tests below go green both when the airlock
+        # refuses AND when WRITE_FILE parsing silently breaks -- the
+        # no-blocks-found path also returns False and writes nothing. This
+        # test fails independently if the WRITE_FILE lane stops parsing, which
+        # is what lets the refusals below indict the airlock rather than a
+        # parse miss. Sibling of the constitution's SUCCESS-ONLY WITNESS: the
+        # WRITE_FILE success branch was otherwise unobserved.
+        with tempfile.TemporaryDirectory() as temp_dir:
+            target = Path(temp_dir) / "fresh_module.py"
+            payload = _build_write_file_payload(target, "created = True\n")
+            self.assertTrue(self._apply(payload))
+            self.assertTrue(target.exists())
+            self.assertEqual(target.read_text(encoding="utf-8"), "created = True\n")
+
+    def test_contaminated_write_file_creation_refuses_and_creates_no_target(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            target = Path(temp_dir) / "new_module.py"
+            bad_link = _make_autolink_www("airlock-create.invalid")
+            payload = _build_write_file_payload(target, f"# {bad_link}\nz = 10\n")
+            self.assertFalse(self._apply(payload))
+            self.assertFalse(target.exists())
+
+    def test_contaminated_write_file_overwrite_refuses_and_preserves_bytes(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            target = Path(temp_dir) / "existing_module.py"
+            target.write_text("status = 'unmodified'\n", encoding="utf-8")
+            bad_link = _make_autolink_www("airlock-overwrite.invalid")
+            payload = _build_write_file_payload(
+                target, f"# {bad_link}\nstatus = 'corrupted'\n"
+            )
+            self.assertFalse(self._apply(payload))
+            self.assertEqual(
+                target.read_text(encoding="utf-8"), "status = 'unmodified'\n"
+            )
+
+    def test_both_regex_alternatives_are_refused(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            target_www = Path(temp_dir) / "alt_www.py"
+            target_www.write_text("val = 100\n", encoding="utf-8")
+            link_www = _make_autolink_www("branch-one.invalid")
+            payload_www = _build_search_replace_payload(
+                target_www, "val = 100", f"# {link_www}\nval = 101"
+            )
+
+            target_scheme = Path(temp_dir) / "alt_scheme.py"
+            target_scheme.write_text("val = 200\n", encoding="utf-8")
+            link_scheme = _make_autolink_scheme("branch-two.invalid")
+            payload_scheme = _build_search_replace_payload(
+                target_scheme, "val = 200", f"# {link_scheme}\nval = 201"
+            )
+
+            self.assertFalse(self._apply(payload_www))
+            self.assertFalse(self._apply(payload_scheme))
+            self.assertEqual(target_www.read_text(encoding="utf-8"), "val = 100\n")
+            self.assertEqual(target_scheme.read_text(encoding="utf-8"), "val = 200\n")
+
+    def test_markdown_files_are_deliberately_exempt(self):
+        # The .md exemption is intentional: self-referential markdown links are
+        # legitimate in articles and documentation, so a blanket refusal there
+        # would make normal .md files uneditable. A green here requires the
+        # airlock to SKIP the check for .md, so the exemption is witnessed, not
+        # merely assumed.
+        with tempfile.TemporaryDirectory() as temp_dir:
+            target = Path(temp_dir) / "document.md"
+            target.write_text("# Documentation\n\nOriginal draft.\n", encoding="utf-8")
+            link_md = _make_autolink_www("doc-reference.invalid")
+            payload = _build_search_replace_payload(
+                target, "Original draft.", f"Updated draft with reference: {link_md}"
+            )
+            self.assertTrue(self._apply(payload))
+            self.assertIn(link_md, target.read_text(encoding="utf-8"))
+
+
+if __name__ == "__main__":
+    unittest.main()

{pipulate-2.44 → pipulate-2.45}/tools/scraper_tools.py

@@ -345,7 +345,7 @@ async def _selenium_capture(params: dict, checkpoint=None) -> dict:
         # defaults, 2026-07-29) skipped the bind, and urlparse(final_url)
         # after the CAPTURE checkpoint died with UnboundLocalError.
         _host = urlparse(params.get("url", "")).netloc.split(":")[0]
-        _labels = [l for l in _host.split(".") if l]
+        _labels = [label for label in _host.split(".") if label]
         _slug = _labels[-2] if len(_labels) >= 2 else (_labels[0] if _labels else "")
         if _slug and Path(f"data/uc_profiles/{_slug}").exists():
             profile_name = _slug