@m13v/s4l 1.6.197-rc.10

package/scripts/apply_onboarding_selections.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+"""
+apply_onboarding_selections.py -- PROTOTYPE handler for the S4L bundled-question
+widget. Turns the widget's sendPrompt confirmation into concrete actions:
+
+  1. Engagement lanes -> saps_mode.py enable/disable (DRY-RUN by default so a
+     prototype never flips the LIVE autopilot; pass --commit-lanes to really run).
+  2. History consent   -> history_context.set_optin(...) (persisted sidecar).
+  3. If consent == yes  -> history_context.pull(project) and summarize candidates.
+
+The widget sends a line like:
+  "... personal_brand lane: ON, product lane: OFF, read past Claude
+   conversations: YES. Apply these ..."
+
+so this handler also accepts that raw text via --from-prompt, or explicit flags.
+
+Usage:
+  python3 scripts/apply_onboarding_selections.py --project S4L \
+      --personal-brand on --product off --read-history yes
+  python3 scripts/apply_onboarding_selections.py --project S4L \
+      --from-prompt "personal_brand lane: ON, product lane: OFF, read past Claude conversations: YES"
+  # add --commit-lanes to actually toggle saps_mode (default is dry-run)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import history_context as hc  # noqa: E402
+
+S4L_MODE = Path(__file__).resolve().parent / "saps_mode.py"
+
+
+def parse_from_prompt(text: str) -> dict:
+    """Extract the three toggles from the widget's confirmation sentence."""
+    t = text.lower()
+
+    def flag(label: str, on_words=("on", "yes")) -> bool | None:
+        m = re.search(re.escape(label) + r"[^:]*:\s*(on|off|yes|no)", t)
+        return None if not m else m.group(1) in on_words
+
+    return {
+        "personal_brand": flag("personal_brand"),
+        "product_mode": flag("product lane"),
+        "read_history": flag("read past claude conversations"),
+    }
+
+
+def apply_lanes(personal_brand: bool, product: bool, commit: bool) -> list[str]:
+    """Return the saps_mode commands, running them only when commit=True."""
+    plan = [
+        [sys.executable, str(S4L_MODE),
+         "enable" if personal_brand else "disable", "personal_brand"],
+        [sys.executable, str(S4L_MODE),
+         "enable" if product else "disable", "promotion"],
+    ]
+    rendered = [" ".join(c) for c in plan]
+    if commit:
+        for c in plan:
+            subprocess.run(c, check=False)
+    return rendered
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--project", required=True)
+    ap.add_argument("--from-prompt", help="raw widget confirmation text")
+    ap.add_argument("--personal-brand", choices=["on", "off"])
+    ap.add_argument("--product", choices=["on", "off"])
+    ap.add_argument("--read-history", choices=["yes", "no"])
+    ap.add_argument("--commit-lanes", action="store_true",
+                    help="actually toggle saps_mode (default: dry-run print only)")
+    args = ap.parse_args()
+
+    sel = {"personal_brand": None, "product_mode": None, "read_history": None}
+    if args.from_prompt:
+        sel.update({k: v for k, v in parse_from_prompt(args.from_prompt).items()
+                    if v is not None})
+    if args.personal_brand:
+        sel["personal_brand"] = args.personal_brand == "on"
+    if args.product:
+        sel["product_mode"] = args.product == "on"
+    if args.read_history:
+        sel["read_history"] = args.read_history == "yes"
+
+    for k in sel:
+        if sel[k] is None:
+            raise SystemExit(f"missing selection for '{k}'")
+
+    out = {"project": args.project, "selections": sel, "actions": {}}
+
+    lane_cmds = apply_lanes(sel["personal_brand"], sel["product_mode"],
+                            commit=args.commit_lanes)
+    out["actions"]["lanes"] = {
+        "committed": args.commit_lanes,
+        "commands": lane_cmds,
+    }
+
+    optin = hc.set_optin(sel["read_history"])
+    out["actions"]["history_optin"] = optin
+
+    if sel["read_history"]:
+        pull = hc.pull(args.project, terms=None, limit=40)
+        if pull.get("ok"):
+            summary = {
+                "sessions": pull["session_count"],
+                "snippets": pull["snippet_count"],
+                "scope": pull["scope"],
+                "sample": [
+                    {"session": sid[:8],
+                     "recent_previews": [s["preview"][:140] for s in snips[:2]]}
+                    for sid, snips in list(pull["sessions"].items())[:5]
+                ],
+            }
+            out["actions"]["history_pull"] = summary
+        else:
+            out["actions"]["history_pull"] = pull
+    else:
+        out["actions"]["history_pull"] = {"skipped": "consent=no"}
+
+    print(json.dumps(out, indent=2)[:6000])
+
+
+if __name__ == "__main__":
+    main()

package/scripts/audience_pages.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+"""Audience-page routing helper.
+
+Each project in config.json can declare `landing_pages.audience_pages`, a list
+of curated deep landing pages (not auto-generated SEO /t/<slug> pages — those
+live in a separate rail). Each entry looks like:
+
+  {
+    "angle": "founder-ghostwriting",
+    "url": "https://s4l.ai/ghostwriting",
+    "match_keywords": ["ghostwriter", "tweet ghostwriter", ...],
+    "when": "human-readable trigger description for LLMs / docs"
+  }
+
+This module is the single source of truth for:
+
+  - loading audience_pages for a project
+  - matching a candidate's nominated topic/keyword to an audience-page angle
+  - mapping a URL back to its angle (for post-hoc tagging)
+  - formatting an audience_pages block for injection into post-draft prompts
+    (used once post_reddit.py and post_github.py are unlocked to consume it)
+
+Used by twitter_gen_links.py to short-circuit the A/B page-gen lane when a
+curated audience page exists for the candidate's topic.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Optional
+from urllib.parse import urlsplit
+
+REPO_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+CONFIG_PATH = os.path.join(REPO_DIR, "config.json")
+
+
+def _load_config() -> dict:
+    with open(CONFIG_PATH, "r") as f:
+        return json.load(f)
+
+
+def _find_project(cfg: dict, name: str) -> Optional[dict]:
+    if not name:
+        return None
+    name_lc = name.lower()
+    for p in cfg.get("projects", []):
+        if (p.get("name") or "").lower() == name_lc:
+            return p
+    return None
+
+
+def load_audience_pages(project_name: str) -> list[dict]:
+    """Return the audience_pages list for a project, or [] if none configured.
+
+    Each entry is the raw dict from config.json. Caller does not mutate.
+    """
+    try:
+        cfg = _load_config()
+    except Exception:
+        return []
+    proj = _find_project(cfg, project_name)
+    if not proj:
+        return []
+    lp = (proj.get("landing_pages") or {})
+    pages = lp.get("audience_pages") or []
+    out = []
+    for entry in pages:
+        if not isinstance(entry, dict):
+            continue
+        if not entry.get("url") or not entry.get("angle"):
+            continue
+        out.append(entry)
+    return out
+
+
+def _normalize(s: str) -> str:
+    """Lowercase + collapse whitespace + strip punctuation for substring match."""
+    if not s:
+        return ""
+    s = s.lower()
+    s = re.sub(r"[^a-z0-9\s]+", " ", s)
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
+
+
+def match_by_keyword(
+    project_name: str,
+    *,
+    keyword: Optional[str] = None,
+    topic: Optional[str] = None,
+    reply_text: Optional[str] = None,
+    thread_title: Optional[str] = None,
+) -> Optional[dict]:
+    """Pick the best-matching audience page for a candidate.
+
+    Match strategy: for each audience-page entry, check whether ANY of its
+    `match_keywords` (case-insensitive, normalized substring) appears in
+    ANY of the provided signals (keyword, topic, reply_text, thread_title).
+
+    Returns the matched entry dict (with `angle`, `url`, ...) or None.
+
+    First-match-wins ordered by audience_pages list order (so config.json
+    list ordering acts as priority). This is intentional: the most specific
+    angle should sit first.
+    """
+    pages = load_audience_pages(project_name)
+    if not pages:
+        return None
+
+    haystacks: list[str] = []
+    for v in (keyword, topic, reply_text, thread_title):
+        n = _normalize(v or "")
+        if n:
+            haystacks.append(n)
+    if not haystacks:
+        return None
+
+    for entry in pages:
+        kws = entry.get("match_keywords") or []
+        for kw in kws:
+            kw_norm = _normalize(kw)
+            if not kw_norm:
+                continue
+            for hay in haystacks:
+                if kw_norm in hay:
+                    return entry
+    return None
+
+
+def classify_url_as_audience_page(url: str, project_name: str) -> Optional[str]:
+    """Map a URL back to an audience-page angle, or None if not a known page.
+
+    Used for post-hoc tagging in `posts.link_source` when a URL was baked
+    into a draft directly (without going through resolve_link()). Match is
+    exact-URL OR same-host + same-path (ignoring query/fragment).
+    """
+    if not url or not project_name:
+        return None
+    pages = load_audience_pages(project_name)
+    if not pages:
+        return None
+    try:
+        target = urlsplit(url.strip())
+    except Exception:
+        return None
+    target_host = (target.netloc or "").lower().lstrip("www.")
+    target_path = (target.path or "/").rstrip("/") or "/"
+
+    for entry in pages:
+        try:
+            ep = urlsplit(entry["url"])
+        except Exception:
+            continue
+        ep_host = (ep.netloc or "").lower().lstrip("www.")
+        ep_path = (ep.path or "/").rstrip("/") or "/"
+        if ep_host == target_host and ep_path == target_path:
+            return entry.get("angle")
+    return None
+
+
+def prompt_block(project_name: str) -> str:
+    """Render an audience_pages block for injection into a post-draft LLM prompt.
+
+    Returns "" if the project has no audience_pages. Otherwise returns a short
+    markdown-friendly block the LLM can use to pick the right deep URL.
+    """
+    pages = load_audience_pages(project_name)
+    if not pages:
+        return ""
+    lines = [
+        "Curated audience landing pages for this project. Pick the BEST match",
+        "for the thread topic and bake the chosen URL into the reply text;",
+        "if none obviously match, link to the project homepage as usual.",
+        "",
+    ]
+    for entry in pages:
+        lines.append(f"- angle: {entry['angle']}")
+        lines.append(f"  url: {entry['url']}")
+        when = entry.get("when") or ""
+        if when:
+            lines.append(f"  when_to_use: {when}")
+        kws = entry.get("match_keywords") or []
+        if kws:
+            lines.append(f"  keyword_signals: {', '.join(kws[:12])}")
+        lines.append("")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+# ---------------------------------------------------------------------------
+# CLI for ops / testing
+# ---------------------------------------------------------------------------
+
+def _cli() -> int:
+    import argparse
+
+    ap = argparse.ArgumentParser(description="Audience-page lookup helper")
+    sub = ap.add_subparsers(dest="cmd", required=True)
+
+    p_list = sub.add_parser("list", help="List audience pages for a project")
+    p_list.add_argument("--project", required=True)
+
+    p_match = sub.add_parser("match", help="Match a keyword/topic to an audience page")
+    p_match.add_argument("--project", required=True)
+    p_match.add_argument("--keyword", default=None)
+    p_match.add_argument("--topic", default=None)
+    p_match.add_argument("--reply", default=None)
+    p_match.add_argument("--title", default=None)
+
+    p_classify = sub.add_parser("classify", help="Classify a URL as an audience page")
+    p_classify.add_argument("--project", required=True)
+    p_classify.add_argument("--url", required=True)
+
+    p_prompt = sub.add_parser("prompt", help="Render the prompt block for a project")
+    p_prompt.add_argument("--project", required=True)
+
+    args = ap.parse_args()
+    if args.cmd == "list":
+        print(json.dumps(load_audience_pages(args.project), indent=2))
+        return 0
+    if args.cmd == "match":
+        out = match_by_keyword(
+            args.project,
+            keyword=args.keyword,
+            topic=args.topic,
+            reply_text=args.reply,
+            thread_title=args.title,
+        )
+        print(json.dumps(out, indent=2) if out else "null")
+        return 0 if out else 1
+    if args.cmd == "classify":
+        angle = classify_url_as_audience_page(args.url, args.project)
+        print(angle or "")
+        return 0 if angle else 1
+    if args.cmd == "prompt":
+        print(prompt_block(args.project))
+        return 0
+    return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(_cli())

package/scripts/audit_helper.py

@@ -0,0 +1,120 @@
+#!/usr/bin/env python3
+"""audit_helper.py — CLI wrapper used by the audit pipelines
+(skill/audit.sh, skill/audit-dm-staleness.sh, skill/audit-reddit-resurrect.sh)
+to replace the inline `psql "$DATABASE_URL"` one-liners they used to embed. The
+direct-Postgres lane was removed 2026-06-01; DATABASE_URL is deliberately
+ignored, no DB, no fallback. Every subcommand prints exactly what the
+corresponding psql call printed so the surrounding shell capture ($(...)),
+integer compares, and `IFS='|' read` loops are unchanged.
+
+Subcommands:
+  twitter-active-count
+      -> GET /api/v1/posts/count?platform=twitter&status=active&has_our_url=true
+      -> prints int (was: COUNT(*) FROM posts WHERE platform='twitter'
+         AND status='active' AND our_url IS NOT NULL)
+  orphan-report
+      -> GET /api/v1/posts/status-breakdown
+      -> prints pipe-delimited "platform|status|count" lines (one per group),
+         empty when none (was: SELECT platform, status, COUNT(*) ... GROUP BY
+         ... for status NOT IN ('active','deleted','removed'))
+  broken-url-count
+      -> GET /api/v1/posts/count?status=active&broken_url=true
+      -> prints int (was: COUNT(*) FROM posts WHERE status='active'
+         AND (our_url IS NULL OR ''='' OR our_url NOT LIKE 'http%'))
+  status-count --status S
+      -> GET /api/v1/posts/count?status=S
+      -> prints int (was: COUNT(*) FROM posts WHERE status='S')
+  resurrect-candidates
+      -> GET /api/v1/posts/count?platform=reddit&status_in=deleted,removed
+             &within_seconds=5184000&has_our_url=true
+      -> prints int (was: COUNT(*) FROM posts WHERE platform='reddit'
+         AND status IN ('deleted','removed') AND posted_at > NOW() - 60 days
+         AND our_url IS NOT NULL)
+  dm-staleness-sweep
+      -> POST /api/v1/dms/staleness-sweep
+      -> prints JSON {aged, downgraded} (was: two UPDATE ... RETURNING CTEs)
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_get, api_post  # noqa: E402
+
+
+def _count(query: dict) -> int:
+    resp = api_get("/api/v1/posts/count", query=query)
+    return int((resp.get("data") or {}).get("count") or 0)
+
+
+def cmd_twitter_active_count(_args) -> int:
+    print(_count({"platform": "twitter", "status": "active", "has_our_url": "true"}))
+    return 0
+
+
+def cmd_orphan_report(_args) -> int:
+    resp = api_get("/api/v1/posts/status-breakdown")
+    rows = (resp.get("data") or {}).get("rows") or []
+    for r in rows:
+        print(f"{r.get('platform')}|{r.get('status')}|{int(r.get('count') or 0)}")
+    return 0
+
+
+def cmd_broken_url_count(_args) -> int:
+    print(_count({"status": "active", "broken_url": "true"}))
+    return 0
+
+
+def cmd_status_count(args) -> int:
+    print(_count({"status": args.status}))
+    return 0
+
+
+def cmd_resurrect_candidates(_args) -> int:
+    print(_count({
+        "platform": "reddit",
+        "status_in": "deleted,removed",
+        "within_seconds": 60 * 24 * 60 * 60,  # 60 days
+        "has_our_url": "true",
+    }))
+    return 0
+
+
+def cmd_dm_staleness_sweep(_args) -> int:
+    resp = api_post("/api/v1/dms/staleness-sweep", body={})
+    data = resp.get("data") or {}
+    out = {
+        "aged": int(data.get("aged") or 0),
+        "downgraded": int(data.get("downgraded") or 0),
+    }
+    json.dump(out, sys.stdout, separators=(",", ":"))
+    sys.stdout.write("\n")
+    return 0
+
+
+def main() -> int:
+    p = argparse.ArgumentParser()
+    sub = p.add_subparsers(dest="cmd", required=True)
+    sub.add_parser("twitter-active-count")
+    sub.add_parser("orphan-report")
+    sub.add_parser("broken-url-count")
+    sc = sub.add_parser("status-count")
+    sc.add_argument("--status", required=True)
+    sub.add_parser("resurrect-candidates")
+    sub.add_parser("dm-staleness-sweep")
+    args = p.parse_args()
+    return {
+        "twitter-active-count": cmd_twitter_active_count,
+        "orphan-report": cmd_orphan_report,
+        "broken-url-count": cmd_broken_url_count,
+        "status-count": cmd_status_count,
+        "resurrect-candidates": cmd_resurrect_candidates,
+        "dm-staleness-sweep": cmd_dm_staleness_sweep,
+    }[args.cmd](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())