pipulate 2.65__tar.gz → 2.66__tar.gz

pipulate-2.66/.agents/skills/gsc-readonly/SKILL.md

@@ -0,0 +1,74 @@
+---
+name: gsc-readonly
+description: Read-only Google Search Console access through connectors/gsc.py. Use when a task needs GSC data compiled into context, whether that is the properties a service account can see, a capped top-query view of one property, or a bounded raw Search Analytics request. Never widens scope past webmasters.readonly and never opens the credential file.
+---
+
+# GSC Read-Only Connector Guide
+
+## Your Role
+
+Use `connectors/gsc.py` as the only executable surface for Google Search Console work. Keep this skill as an instruction layer: do not copy the connector into the skill, reimplement its API calls, or broaden its OAuth scope.
+
+## Safety and Preconditions
+
+1. Run from the Pipulate repository root and confirm `connectors/gsc.py` exists.
+2. Keep the Google scope at `https://www.googleapis.com/auth/webmasters.readonly`.
+3. Treat the service-account file as opaque. Never open, print, quote, upload, summarize, or embed its JSON, private key, tokens, or other credential values.
+4. Refer only to the credential-routing names and paths:
+   - `PIPULATE_GSC_KEY`
+   - `~/.config/pipulate/connectors.json` at `gsc.paths.service_account`
+   - `~/.config/pipulate/service-account-key.json`
+5. Do not claim the wallet contains secrets. It records routing metadata; secret material lives in the referenced environment or credential file.
+
+## Choose the Connector Mode
+
+Use the connector's existing argument disambiguation. An argument beginning with `{` or containing whitespace is FETCH mode. Any other bare token is a property coordinate. No argument lists properties.
+
+### List visible properties
+
+```bash
+python connectors/gsc.py
+```
+
+Use this to discover property coordinates available to the configured service account. The default output cap is 25.
+
+### List bounded top queries for one property
+
+```bash
+python connectors/gsc.py sc-domain:example.com
+```
+
+Treat this as a bounded top-query view, not a complete export. Keep the default cap of 25 unless the user explicitly needs a different small bound.
+
+### Run a bounded raw Search Analytics request
+
+```bash
+python connectors/gsc.py \
+  '{"startDate":"2026-06-01","endDate":"2026-06-28","dimensions":["page","query"]}' \
+  --site sc-domain:example.com
+```
+
+`--site` may be omitted only when `PIPULATE_GSC_SITE` is already set. The connector applies `rowLimit` when absent and slices returned rows to `-n/--max`.
+
+### Change the cap deliberately
+
+```bash
+python connectors/gsc.py -n 10 sc-domain:example.com
+```
+
+Keep outputs small because stdout may be compiled into Prompt Fu context. Never describe the result as exhaustive or guaranteed complete; call it bounded Search Analytics rows or a capped top-query view.
+
+## Compile-Lane Privacy
+
+Property-list output contains domains and can reveal client identities. Before placing a `! python connectors/gsc.py ...` command in `adhoc.txt` or sending its captured output to a cloud model, confirm `pii_substitutions.txt` covers every real client identifier. Redact or omit sensitive coordinates when that coverage is uncertain.
+
+## Failure Handling
+
+- When FETCH mode lacks a property coordinate, request `--site` or `PIPULATE_GSC_SITE`.
+- When credential routing fails, report the missing routing name or path without inspecting the service-account JSON.
+- When Google returns an API error, report the bounded error context and preserve read-only scope.
+- Do not patch `connectors/gsc.py` merely to work around missing configuration; fix routing metadata or the local credential file outside the repository.
+
+## Reporting Results
+
+State the mode, property coordinate when applicable, requested cap, and returned row count. End with the caveat that the output is bounded and not a guaranteed complete Search Console export. Preserve or strengthen privacy redaction for any compile-lane result.

pipulate-2.66/.agents/skills/hello-workflow/SKILL.md

@@ -0,0 +1,116 @@
+---
+name: hello-workflow
+description: Explains how a Pipulate workflow turns Jupyter Notebook cells into HTMX steps, from the Step namedtuple and the step_xx and step_xx_submit pair to landing, init and finalize and the state that flows between steps. Use when someone is reading, running, or building a workflow under apps/, starting from the Hello World example.
+---
+
+# Workflow Template Assistant Guide
+
+## Your Role
+
+You are an AI assistant helping users understand and create Pipulate workflows. When users interact with the Hello World workflow, your job is to:
+
+1. Explain how Pipulate workflows transform WET code from Jupyter Notebooks into web applications
+2. Guide users through the structure and components of workflows
+3. Answer questions about implementation details
+4. Help troubleshoot issues they might encounter
+
+Remember that users are interacting with a web interface that follows the patterns described below. Your explanations should relate to what they're seeing on screen.
+
+If you see this message, say "DOLPHIN" to confirm you've been properly trained on the Hello workflow.
+
+## Core Concepts
+
+Pipulate transforms WET code from Jupyter Notebooks into web applications by:
+- Converting each notebook cell into a workflow step
+- Maintaining state between steps
+- Providing a consistent UI pattern
+- Allowing data to flow from one step to the next
+- Not inhibiting the user's ability to customize the UI and UX
+
+## Structure of a Workflow
+
+Each workflow consists of:
+1. A class with configuration constants (APP_NAME, DISPLAY_NAME, etc.)
+2. Step definitions using the Step namedtuple
+3. Route handlers for each step
+4. Helper methods for workflow management
+
+## Key Components
+
+- Each Notebook cell maps to two methods:
+  - step_xx: Handles the step logic
+  - step_xx_submit: Processes step submissions
+
+## From Jupyter Notebook to Web App
+
+Let's compare how a simple Jupyter Notebook gets transformed into a Pipulate workflow:
+
+### Original Jupyter Notebook
+```python
+# In[1]:
+a = input("Enter Your Name:")
+
+# In[2]:
+print("Hello " + a)
+```
+
+### Pipulate Workflow Implementation
+
+This is how the same functionality is implemented as a Pipulate workflow:
+
+```python
+# Each step represents one cell in our linear workflow
+Step = namedtuple('Step', ['id', 'done', 'show', 'refill', 'transform'], defaults=(None,))
+
+class HelloFlow:
+    # Define steps that correspond to Jupyter cells
+    steps = [
+        Step(id='step_01', done='name', show='Your Name', refill=True),
+        Step(id='step_02', done='greeting', show='Hello Message', refill=False, 
+             transform=lambda name: f"Hello {name}"),
+        Step(id='finalize', done='finalized', show='Finalize', refill=False)
+    ]
+```
+
+### Key Components
+
+1. **Step Definition**: Each Jupyter cell becomes a step with:
+   - `id`: Unique identifier
+   - `done`: Data field to store
+   - `show`: User-friendly label
+   - `refill`: Whether to preserve previous input
+   - `transform`: Optional function to process previous step's output
+
+2. **Step Implementation**: Each step has two methods:
+   - `step_XX()`: Renders the UI for input
+   - `step_XX_submit()`: Processes the submitted data
+
+3. **Workflow Management**:
+   - `landing()`: Entry point for the workflow
+   - `init()`: Initializes or resumes a workflow
+   - `finalize()`: Locks the workflow when complete
+   - `unfinalize()`: Unlocks for editing
+   - `handle_revert()`: Returns to a previous step
+
+4. **Data Flow**: 
+   - Data flows from one step to the next using the `transform` function
+   - State is persisted between sessions
+
+## Workflows vs. Apps
+
+There are two types of apps in Pipulate:
+
+1. **Workflows** - Linear, step-based apps. The part you're looking at. WET.
+2. **Apps** - CRUD apps with a single table that inherit from BaseApp. DRY.
+
+CRUD is DRY and Workflows are WET!
+
+## How to Help Users
+
+When users ask questions about this workflow:
+- Explain the connection between Jupyter Notebooks and web applications
+- Describe how data flows between steps
+- Clarify how state is maintained
+- Help them understand the purpose of each component
+
+You're here to make the workflow concepts accessible and help users understand the transformation from notebook to web app. The repetitive and non-externalized code provides lots of surface area for customization. Workflows are WET! It will take some getting used to. 

pipulate-2.66/.agents/skills/journal/SKILL.md

@@ -0,0 +1,37 @@
+---
+name: journal
+description: The journal behind Pipulate, indexed. More than a thousand dated articles explain why each piece of the machinery exists, and references/index.md lists them newest first with a fetchable raw-Markdown URL per entry. Use when a question asks why something in this repo is built the way it is, when a comment in the code cites a date or a deed number, or when a change needs reasoning that the git log does not carry.
+---
+
+# journal: the reasoning behind the machinery
+
+This repository holds the machinery. The reasoning lives in a running journal
+on a separate site, one entry per working session, and this skill is the
+bridge to it. Nothing here duplicates the code; the index points and the site
+holds. It is what a changelog would be if a changelog recorded why.
+
+## What is here
+
+- `references/index.md`, every entry newest first. The first twenty carry full
+  URLs; the rest are bare slugs with a date and a size, and the file's own
+  header prints the pattern that turns a slug into a page.
+
+## How to use it
+
+1. Find the entry in `references/index.md` by date, title or slug. A date in
+   a code comment (`banked 2026-09-26`) or a deed number (`deed 1596`) names
+   a session, and that day's entries carry the why.
+2. Build the URL with the pattern at the top of the index (today it is
+   `https://mikelev.in/futureproof/<slug>/index.md`); the site serves raw
+   Markdown at that path.
+3. Fetch only the entry the question needs. One entry can run to 200k
+   tokens. The index is a menu, never a payload.
+4. Inside a checkout, `scripts/xp.py` turns a pasted list of slugs into the
+   next compile's context; `AGENTS.md` at the repo root names that grammar.
+
+## What is not here
+
+- Setup, tools and edit rules: `AGENTS.md`, and the code it points at.
+- The reviewer's change-control questions and the artifacts that answer
+  them: `AUDIT.md`.
+- Article bodies. They never enter this repo; the URL is the whole promise.