@m13v/s4l 1.6.197-rc.7

package/scripts/learned_preferences.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""Per-project learned_preferences: the agent-owned config block distilled from
+human card decisions (review_events).
+
+The feedback loop:
+  1. The menubar review card ships every approve/reject (with reason chips,
+     free-text note, link-click interactions, dwell) to /api/v1/review-events.
+  2. scripts/feedback_digest.py (scheduled) claims unprocessed events per
+     project and asks Claude for a conservative mutation plan.
+  3. apply_mutations() here writes that plan into config.json under the
+     project's `learned_preferences` block, whitelist-enforced, with flock +
+     backup + atomic replace.
+  4. Enforcement is SOFT (prompt-level, never a deterministic filter): the
+     twitter prep prompt embeds every project entry verbatim via
+     ALL_PROJECTS_JSON, so the block (with its self-describing _instruction)
+     reaches the judging/drafting model automatically. prompt_block() renders
+     the same content for prompts that want an explicit section.
+
+Block shape (inside a config.json project entry):
+
+  "learned_preferences": {
+    "_instruction": "<how the drafting model should apply this block>",
+    "enabled": true,
+    "audience_avoid":    ["crypto/web3-native authors ..."],
+    "audience_prefer":   [],
+    "thread_avoid":      ["engagement-bait question threads ..."],
+    "draft_style_notes": [],
+    "updated_at": "...",
+    "history": [{"ts", "change", "rationale", "source_events": [ids]}]
+  }
+
+WHITELIST: this module writes ONLY learned_preferences plus (append-only)
+voice.never and content_guardrails.do_not. Nothing else in a project entry is
+touchable through this path; unknown keys in a mutation plan are dropped and
+counted, never applied. Facts (content_angle, links, identity fields) are
+deliberately unreachable so a bad digest can never poison grounding.
+"""
+from __future__ import annotations
+
+import datetime
+import fcntl
+import json
+import os
+import shutil
+import sys
+from pathlib import Path
+
+# Lists the digest may fully manage inside learned_preferences.
+MANAGED_LISTS = ("audience_avoid", "audience_prefer", "thread_avoid", "draft_style_notes")
+# Existing config fields the digest may APPEND to (never remove from).
+APPEND_ONLY_FIELDS = ("voice_never_add", "guardrails_do_not_add")
+
+MAX_ENTRIES_PER_LIST = 10
+MAX_ENTRY_CHARS = 200
+MAX_HISTORY = 50
+
+# Travels inside the JSON the prep prompt embeds (ALL_PROJECTS_JSON is the
+# full project entry), so the drafting model reads its own operating manual
+# for the block. Soft steering by design: judgment, not a hard ban.
+DEFAULT_INSTRUCTION = (
+    "Human review feedback for this project, distilled from the user's "
+    "approve/reject decisions on draft cards. When judging candidates and "
+    "drafting replies: treat audience_avoid and thread_avoid as strong "
+    "negative signals (prefer rejecting matching candidates, citing "
+    "'learned_preference' in the reason), treat audience_prefer as a "
+    "positive signal, and follow draft_style_notes when writing. These are "
+    "preferences, not hard bans; use judgment when a candidate is "
+    "exceptionally on-topic despite a match."
+)
+
+
+def config_path() -> str:
+    explicit = os.environ.get("S4L_CONFIG_PATH")
+    if explicit:
+        return explicit
+    repo = os.environ.get("S4L_REPO_DIR")
+    if repo:
+        return os.path.join(repo, "config.json")
+    return os.path.expanduser("~/social-autoposter/config.json")
+
+
+def _now_iso() -> str:
+    return datetime.datetime.now(datetime.timezone.utc).isoformat()
+
+
+def normalized(block) -> dict:
+    """Coerce whatever is in config into the canonical block shape."""
+    b = block if isinstance(block, dict) else {}
+    out = {
+        "_instruction": str(b.get("_instruction") or DEFAULT_INSTRUCTION),
+        "enabled": b.get("enabled", True) is not False,
+    }
+    for key in MANAGED_LISTS:
+        vals = b.get(key)
+        out[key] = [str(v).strip()[:MAX_ENTRY_CHARS] for v in vals if str(v).strip()] if isinstance(vals, list) else []
+    out["updated_at"] = b.get("updated_at")
+    hist = b.get("history")
+    out["history"] = list(hist)[-MAX_HISTORY:] if isinstance(hist, list) else []
+    return out
+
+
+def get_block(project_cfg) -> dict:
+    return normalized((project_cfg or {}).get("learned_preferences"))
+
+
+def prompt_block(project_cfg) -> str:
+    """Explicit prompt section for callers that don't embed the raw project
+    JSON (mirrors the engagement_styles STYLES_BLOCK pattern). Empty string
+    when the block is disabled or has no entries."""
+    b = get_block(project_cfg)
+    if not b["enabled"]:
+        return ""
+    lines = []
+    labels = {
+        "audience_avoid": "Avoid audiences/authors like",
+        "audience_prefer": "Prefer audiences/authors like",
+        "thread_avoid": "Avoid threads like",
+        "draft_style_notes": "Drafting notes",
+    }
+    for key in MANAGED_LISTS:
+        for v in b[key]:
+            lines.append(f"- {labels[key]}: {v}")
+    if not lines:
+        return ""
+    return (
+        "## LEARNED PREFERENCES (from this user's own approve/reject decisions)\n"
+        + b["_instruction"]
+        + "\n"
+        + "\n".join(lines)
+        + "\n"
+    )
+
+
+def _validate_add_list(raw, cap=MAX_ENTRIES_PER_LIST):
+    out = []
+    if not isinstance(raw, list):
+        return out
+    for v in raw:
+        s = str(v).strip()
+        if s:
+            out.append(s[:MAX_ENTRY_CHARS])
+        if len(out) >= cap:
+            break
+    return out
+
+
+def apply_mutations(project_name: str, plan: dict, source_event_ids=None, cfg_path: str | None = None) -> dict:
+    """Apply a digest mutation plan to config.json. Returns a summary dict:
+    {ok, applied: [change strings], dropped: [reasons], project_found: bool}.
+
+    plan shape (all optional):
+      {"changes": {<managed list>: {"add": [...], "remove": [...]}},
+       "voice_never_add": [...], "guardrails_do_not_add": [...],
+       "rationale": "..."}
+
+    flock on <config>.lock serializes against other writers (setup tools, a
+    concurrent digest); backup + atomic replace mirrors mcp/src/setup.ts
+    applySetup(). Unknown keys are DROPPED, never applied: the whitelist is
+    enforced here in code, not in the digest prompt.
+    """
+    cfg_path = cfg_path or config_path()
+    applied, dropped = [], []
+    plan = plan if isinstance(plan, dict) else {}
+    changes = plan.get("changes") if isinstance(plan.get("changes"), dict) else {}
+    rationale = str(plan.get("rationale") or "").strip()[:500]
+
+    lock_path = cfg_path + ".lock"
+    Path(lock_path).parent.mkdir(parents=True, exist_ok=True)
+    with open(lock_path, "w") as lock_f:
+        fcntl.flock(lock_f, fcntl.LOCK_EX)
+        try:
+            cfg = json.loads(Path(cfg_path).read_text())
+        except Exception as e:
+            return {"ok": False, "error": f"config unreadable: {e}", "applied": [], "dropped": [], "project_found": False}
+        projects = cfg.get("projects") or []
+        proj = next((p for p in projects if p.get("name") == project_name), None)
+        if proj is None:
+            return {"ok": False, "error": "project not in config", "applied": [], "dropped": [], "project_found": False}
+
+        block = get_block(proj)
+
+        for key, ops in changes.items():
+            if key not in MANAGED_LISTS:
+                dropped.append(f"unknown list '{key}'")
+                continue
+            if not isinstance(ops, dict):
+                dropped.append(f"bad ops for '{key}'")
+                continue
+            for v in _validate_add_list(ops.get("remove")):
+                # Fuzzy-tolerant remove: exact match only; a miss is not an error.
+                if v in block[key]:
+                    block[key].remove(v)
+                    applied.append(f"{key} removed: {v}")
+            for v in _validate_add_list(ops.get("add")):
+                if v in block[key]:
+                    continue
+                if len(block[key]) >= MAX_ENTRIES_PER_LIST:
+                    dropped.append(f"{key} at cap ({MAX_ENTRIES_PER_LIST}), skipped: {v}")
+                    continue
+                block[key].append(v)
+                applied.append(f"{key} added: {v}")
+
+        # Append-only extensions of existing curated fields.
+        for v in _validate_add_list(plan.get("voice_never_add"), cap=3):
+            voice = proj.setdefault("voice", {})
+            never = voice.setdefault("never", [])
+            if isinstance(never, list) and v not in never:
+                never.append(v)
+                applied.append(f"voice.never added: {v}")
+        for v in _validate_add_list(plan.get("guardrails_do_not_add"), cap=3):
+            guard = proj.setdefault("content_guardrails", {})
+            do_not = guard.setdefault("do_not", [])
+            if isinstance(do_not, list) and v not in do_not:
+                do_not.append(v)
+                applied.append(f"content_guardrails.do_not added: {v}")
+
+        for key in set(plan.keys()) - {"changes", "voice_never_add", "guardrails_do_not_add", "rationale", "project"}:
+            dropped.append(f"unknown top-level key '{key}'")
+
+        if not applied:
+            return {"ok": True, "applied": [], "dropped": dropped, "project_found": True}
+
+        block["updated_at"] = _now_iso()
+        block["history"] = (block["history"] + [
+            {
+                "ts": _now_iso(),
+                "change": "; ".join(applied)[:1000],
+                "rationale": rationale,
+                "source_events": list(source_event_ids or [])[:100],
+            }
+        ])[-MAX_HISTORY:]
+        proj["learned_preferences"] = block
+
+        # Backup + atomic replace (same shape as setup.ts applySetup).
+        stamp = _now_iso().replace(":", "-").replace(".", "-")
+        try:
+            if os.path.exists(cfg_path):
+                shutil.copyfile(cfg_path, f"{cfg_path}.bak-{stamp}")
+        except Exception:
+            pass
+        tmp = cfg_path + ".tmp"
+        Path(tmp).write_text(json.dumps(cfg, indent=2) + "\n")
+        os.replace(tmp, cfg_path)
+
+    return {"ok": True, "applied": applied, "dropped": dropped, "project_found": True}
+
+
+if __name__ == "__main__":
+    import argparse
+
+    ap = argparse.ArgumentParser(description="Inspect/render learned_preferences")
+    ap.add_argument("command", choices=["show", "block"], help="show = raw JSON, block = prompt block")
+    ap.add_argument("project")
+    args = ap.parse_args()
+    cfg = json.loads(Path(config_path()).read_text())
+    proj = next((p for p in (cfg.get("projects") or []) if p.get("name") == args.project), None)
+    if proj is None:
+        print(f"project {args.project!r} not found", file=sys.stderr)
+        sys.exit(1)
+    if args.command == "show":
+        print(json.dumps(get_block(proj), indent=2))
+    else:
+        print(prompt_block(proj))

package/scripts/li_discovery.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+"""LinkedIn Phase A discovery helpers, HTTP-backed (no DATABASE_URL).
+
+Replaces the raw psql SELECT/INSERT lines that engage-linkedin.sh Phase A
+embedded in its Claude prompt (Steps 1-3 dedup reads, Step 7 reply insert /
+post create). Everything routes through the s4l.ai HTTP API so the engage
+runner works on a machine with no direct DB access.
+
+Subcommands (each prints to stdout in the same shape the old psql `-t -A`
+output produced, so the prompt's downstream parsing is unchanged):
+
+  comment-ids
+      One their_comment_id per line. Phase A Step 1 dedup list.
+
+  engaged-pairs
+      One "author|||our_url" per line. Phase A Step 2 dedup list.
+
+  posts
+      One "id|our_url" per line. Phase A Step 3 post-matching index.
+
+  insert-reply --post-id N --comment-urn URN --author A --content C --href URL
+      Find-or-create a pending linkedin reply. Idempotent: a duplicate
+      (platform, their_comment_id) returns 409 which we treat as success.
+      Prints the resulting reply id (or "gated"/"duplicate") for the log.
+
+  create-post --activity-id ID --project NAME --author A
+      Create (or reuse) a linkedin post row for a discovered thread when no
+      existing post matched the activity id. Prints the post id. 409
+      duplicate_thread reuses the existing row's id.
+
+All three read subcommands hit GET /api/v1/linkedin-discovery-context once
+and slice the field they need, so a caller that needs all three can also just
+run `context` to dump the raw JSON.
+"""
+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
+
+
+def _context():
+    resp = api_get("/api/v1/linkedin-discovery-context")
+    return resp.get("data") or {}
+
+
+def cmd_comment_ids():
+    for cid in _context().get("existing_comment_ids") or []:
+        print(cid)
+
+
+def cmd_engaged_pairs():
+    for pair in _context().get("engaged_pairs") or []:
+        print(pair)
+
+
+def cmd_posts():
+    for p in _context().get("posts") or []:
+        print(f"{p['id']}|{p['our_url']}")
+
+
+def cmd_context():
+    print(json.dumps(_context(), indent=2))
+
+
+def cmd_insert_reply(args):
+    resp = api_post(
+        "/api/v1/replies",
+        {
+            "platform": "linkedin",
+            "post_id": args.post_id,
+            "their_comment_id": args.comment_urn,
+            "their_author": args.author,
+            "their_content": args.content or "",
+            "their_comment_url": args.href or "",
+            "depth": 1,
+            "status": "pending",
+        },
+        ok_on_conflict=True,
+    )
+    error = resp.get("error") or {}
+    if error.get("code") == "duplicate_reply":
+        print("duplicate")
+        return
+    data = resp.get("data") or {}
+    # The blocklist / velocity gate returns ok with reply:null + gated reason.
+    if data.get("gated"):
+        print("gated:%s" % data.get("gated"))
+        return
+    reply = data.get("reply") or {}
+    print(reply.get("id", "inserted"))
+
+
+def cmd_create_post(args):
+    our_url = (
+        "https://www.linkedin.com/feed/update/"
+        "urn:li:activity:%s/" % args.activity_id
+    )
+    resp = api_post(
+        "/api/v1/posts",
+        {
+            "platform": "linkedin",
+            "thread_url": our_url,
+            "our_url": our_url,
+            "our_content": "[discovered via notification, no original content tracked]",
+            "project": args.project or "general",
+            "thread_author": args.author or "(unknown)",
+            "our_account": "Matthew Diakonov",
+            "engagement_style": "discovered_via_notification",
+            "status": "active",
+        },
+        ok_on_conflict=True,
+    )
+    error = resp.get("error") or {}
+    if error.get("code") == "duplicate_thread":
+        print((error.get("details") or {}).get("existing_post_id"))
+        return
+    post = (resp.get("data") or {}).get("post") or {}
+    print(post.get("id", ""))
+
+
+def main():
+    p = argparse.ArgumentParser(description="LinkedIn Phase A discovery helpers (HTTP).")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    sub.add_parser("comment-ids")
+    sub.add_parser("engaged-pairs")
+    sub.add_parser("posts")
+    sub.add_parser("context")
+
+    ins = sub.add_parser("insert-reply")
+    ins.add_argument("--post-id", type=int, required=True)
+    ins.add_argument("--comment-urn", required=True)
+    ins.add_argument("--author", required=True)
+    ins.add_argument("--content", default="")
+    ins.add_argument("--href", default="")
+
+    cp = sub.add_parser("create-post")
+    cp.add_argument("--activity-id", required=True)
+    cp.add_argument("--project", default="general")
+    cp.add_argument("--author", default="")
+
+    args = p.parse_args()
+    if args.cmd == "comment-ids":
+        cmd_comment_ids()
+    elif args.cmd == "engaged-pairs":
+        cmd_engaged_pairs()
+    elif args.cmd == "posts":
+        cmd_posts()
+    elif args.cmd == "context":
+        cmd_context()
+    elif args.cmd == "insert-reply":
+        cmd_insert_reply(args)
+    elif args.cmd == "create-post":
+        cmd_create_post(args)
+
+
+if __name__ == "__main__":
+    main()

package/scripts/link_edit_helper.py

@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""link_edit_helper.py — CLI wrapper used by the three link-edit pipelines
+(skill/link-edit-{reddit,github,moltbook}.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 ($(...)) and string/int compares are
+unchanged.
+
+Subcommands:
+  eligible --platform P [--age-hours N] [--min-upvotes-exclusive N]
+           [--page-gen-rate-pct N] [--order upvotes|posted_at]
+      -> GET /api/v1/posts/link-edit-eligible?...
+      -> prints the json_agg() array of eligible posts, or the literal `null`
+         when none match (matches Postgres json_agg-over-empty-set, so the
+         shell `[ "$EDITABLE" = "null" ]` guard still fires).
+  mark-edited --post-id N --content "<text>" [--source "<src>"]
+      -> PATCH /api/v1/posts/N  { link_edited_now, link_edit_content, link_source? }
+         (was: UPDATE posts SET link_edited_at=NOW(), link_edit_content=..,
+          link_source=.. WHERE id=..)
+  mark-skipped --post-id N --reason "<reason>"
+      -> PATCH /api/v1/posts/N  { link_edited_now, link_edit_content:"SKIPPED: <reason>" }
+         (was: UPDATE posts SET link_edited_at=NOW(),
+          link_edit_content='SKIPPED: ..' WHERE id=..)
+  set-project --post-id N --project "<name>"
+      -> PATCH /api/v1/posts/N  { project_name }
+         (was: UPDATE posts SET project_name=.. WHERE id=..)
+  edited-count --platform P
+      -> GET /api/v1/posts/count?platform=P&link_edited=true
+      -> prints the integer all-time edited count (was: SELECT COUNT(*) FROM
+         posts WHERE platform=P AND link_edited_at IS NOT NULL)
+"""
+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_patch  # noqa: E402
+
+
+def cmd_eligible(args) -> int:
+    query = {
+        "platform": args.platform,
+        "age_hours": args.age_hours,
+        "page_gen_rate_pct": args.page_gen_rate_pct,
+        "order": args.order,
+    }
+    if args.min_upvotes_exclusive is not None:
+        query["min_upvotes_exclusive"] = args.min_upvotes_exclusive
+    resp = api_get("/api/v1/posts/link-edit-eligible", query=query)
+    posts = (resp.get("data") or {}).get("posts") or []
+    if not posts:
+        # Mirror Postgres json_agg() over an empty set, which returns NULL and
+        # which psql -t -A prints as the bare string `null`. The shells guard
+        # on `[ "$EDITABLE" = "null" ]`, so emit exactly that.
+        print("null")
+        return 0
+    json.dump(posts, sys.stdout, separators=(",", ":"))
+    sys.stdout.write("\n")
+    return 0
+
+
+def _patch_post(post_id: int, body: dict) -> int:
+    api_patch(f"/api/v1/posts/{post_id}", body=body)
+    return 0
+
+
+def cmd_mark_edited(args) -> int:
+    body: dict = {
+        "link_edited_now": True,
+        "link_edit_content": args.content,
+    }
+    if args.source is not None:
+        body["link_source"] = args.source
+    return _patch_post(args.post_id, body)
+
+
+def cmd_mark_skipped(args) -> int:
+    return _patch_post(
+        args.post_id,
+        {
+            "link_edited_now": True,
+            "link_edit_content": f"SKIPPED: {args.reason}",
+        },
+    )
+
+
+def cmd_set_project(args) -> int:
+    return _patch_post(args.post_id, {"project_name": args.project})
+
+
+def cmd_edited_count(args) -> int:
+    resp = api_get(
+        "/api/v1/posts/count",
+        query={"platform": args.platform, "link_edited": "true"},
+    )
+    print(int((resp.get("data") or {}).get("count") or 0))
+    return 0
+
+
+def main() -> int:
+    p = argparse.ArgumentParser()
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    e = sub.add_parser("eligible")
+    e.add_argument("--platform", required=True)
+    e.add_argument("--age-hours", type=int, default=6)
+    e.add_argument("--min-upvotes-exclusive", type=int, default=None)
+    e.add_argument("--page-gen-rate-pct", type=int, default=0)
+    e.add_argument("--order", default="upvotes", choices=["upvotes", "posted_at"])
+
+    me = sub.add_parser("mark-edited")
+    me.add_argument("--post-id", type=int, required=True)
+    me.add_argument("--content", required=True)
+    me.add_argument("--source", default=None)
+
+    ms = sub.add_parser("mark-skipped")
+    ms.add_argument("--post-id", type=int, required=True)
+    ms.add_argument("--reason", required=True)
+
+    sp = sub.add_parser("set-project")
+    sp.add_argument("--post-id", type=int, required=True)
+    sp.add_argument("--project", required=True)
+
+    ec = sub.add_parser("edited-count")
+    ec.add_argument("--platform", required=True)
+
+    args = p.parse_args()
+    return {
+        "eligible": cmd_eligible,
+        "mark-edited": cmd_mark_edited,
+        "mark-skipped": cmd_mark_skipped,
+        "set-project": cmd_set_project,
+        "edited-count": cmd_edited_count,
+    }[args.cmd](args)
+
+
+if __name__ == "__main__":
+    sys.exit(main())