sawz/last30days-skill
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: vs mode N full passes + --competitors auto-discovery + (/Last30Days) title (#312)

Browse Source 
* feat: vs mode runs N full passes; --competitors wraps vs with auto-discovery

Unifies vs-mode and --competitors onto one fanout architecture. A topic
containing "vs" / "versus" now runs N full pipeline.run() calls in parallel
(reverting the one-pass latency optimization that removed per-entity
depth); --competitors becomes a SKILL.md-level shortcut where the hosting
reasoning model (Claude Code, Codex, Hermes, Gemini) discovers N peers via
its own WebSearch, runs Step 0.55 per entity, and invokes the engine with
a vs-topic + --competitors-plan JSON.

Changed:
- vs-mode: N full passes in parallel via fanout (was 1 merged pass).
- --competitors: SKILL.md shortcut for vs-mode-with-discovery. Engine flag
  kept for headless/cron use. LAW 7-style stderr reframed to lead with the
  hosting-model path (use WebSearch + --competitors-plan) instead of
  BRAVE_API_KEY. Footer BRAVE/SERPER nudge suppressed when --plan or
  --competitors-plan present (hosting model already has WebSearch).

Added:
- --competitors-plan JSON flag: per-entity {x_handle, x_related, subreddits,
  github_user, github_repos, context}. Accepts inline JSON or file path.
  subrun_kwargs_for helper is the single source of truth for per-entity
  kwargs — no closure-default fallthrough from main scope.
- Per-entity save files: each entity's sub-run produces its own
  {slug}-raw.md with a single-row Resolved Entities block.
- --polymarket-keywords filter for ambiguous single-token topics.

Fixed:
- test_competitor_subrun_isolation regression suite locks in 3.0.12's
  no-leak invariant (main flags do not inherit into peer sub-runs).
- Updates test_regression.py for the new comparison-mode payload shape.

Bumps plugin.json to 3.0.13. 1,219 tests passing.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

* fix: comparison title attribution — (Last 30 Days) → (/Last30Days)

User feedback on 3.0.13 dogfood runs (Kanye vs Drake, Mercer Island,
Figma): the comparison-mode synthesis title should attribute to the
slash command rather than restate the date range.

Three SKILL.md occurrences updated. Pure documentation change. Bumps to
3.0.14.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

---------

Co-authored-by: Matt Van Horn <455140+mvanhorn@users.noreply.github.com>
Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Matt Van Horn
2026-04-22 21:31:00 -07:00
committed by GitHub
parent 00d01933e0
commit 949bcf8942
18 changed files with 2022 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scripts/last30days.py
+250 -27
View File
@@ -241,9 +241,138 @@ def build_parser() -> argparse.ArgumentParser:
dest="competitors_list",
help="Comma-separated competitor entities to skip discovery (e.g., 'Anthropic,xAI,Google Gemini'). Implies --competitors.",
)
parser.add_argument(
"--polymarket-keywords",
dest="polymarket_keywords",
help=(
"Comma-separated keywords that Polymarket market titles must match "
"to be included. Use for ambiguous single-token topics like 'Warriors' "
"(nba,gsw,golden-state) to filter out Glasgow Warriors rugby, Honor "
"of Kings Rogue Warriors, etc. When omitted, Polymarket returns all "
"matching markets — so expect cross-entity noise on generic topics."
),
)
parser.add_argument(
"--competitors-plan",
dest="competitors_plan",
help=(
"JSON mapping of per-entity Step 0.55 targeting for competitor / vs-mode "
"sub-runs. Schema: {entity_name: {x_handle?, x_related?, subreddits?, "
"github_user?, github_repos?, context?}}. Accepts inline JSON or a file "
"path. Implies --competitors. Preferred over --competitors-list when the "
"hosting model has already resolved per-entity handles and subs."
),
)
return parser
def parse_competitors_plan(raw: str | None) -> dict[str, dict]:
"""Parse a --competitors-plan argument into a {entity_name_lower: plan_entry} dict.
Accepts inline JSON or a file path (matches --plan). Returns {} on None/empty.
Validation: top-level must be a dict; each value must be a dict. Unknown fields
in entry values log a warning but do not abort. Invalid JSON or non-dict shape
raises SystemExit(2) with a clear stderr message.
"""
if not raw:
return {}
plan_str = raw
if os.path.isfile(plan_str):
try:
plan_str = open(plan_str).read()
except OSError as exc:
sys.stderr.write(f"[CompetitorsPlan] Cannot read plan file: {exc}\n")
raise SystemExit(2)
try:
parsed = json.loads(plan_str)
except json.JSONDecodeError as exc:
sys.stderr.write(f"[CompetitorsPlan] Invalid JSON: {exc}\n")
raise SystemExit(2)
if not isinstance(parsed, dict):
sys.stderr.write(
f"[CompetitorsPlan] Top-level must be a dict of "
f"{{entity: {{targeting}}}}, got {type(parsed).__name__}\n"
)
raise SystemExit(2)
known_fields = {
"x_handle", "x_related", "subreddits",
"github_user", "github_repos", "context",
}
normalized: dict[str, dict] = {}
for entity, entry in parsed.items():
if not isinstance(entry, dict):
sys.stderr.write(
f"[CompetitorsPlan] Entry for {entity!r} must be a dict, "
f"got {type(entry).__name__}; skipping.\n"
)
continue
unknown = set(entry.keys()) - known_fields
if unknown:
sys.stderr.write(
f"[CompetitorsPlan] Unknown fields in {entity!r}: "
f"{sorted(unknown)}; ignoring.\n"
)
normalized[entity.strip().lower()] = {
k: v for k, v in entry.items() if k in known_fields
}
return normalized
def subrun_kwargs_for(
entity: str,
plan_entry: dict,
*,
resolved: dict,
) -> dict:
"""Build an explicit per-entity kwargs dict for pipeline.run().
Plan values win over auto_resolve values. Returns keys for all per-entity
targeting flags so callers never fall through to closure defaults.
This helper is the single source of truth for sub-run kwargs — main-topic
flags can only leak if a caller bypasses it.
"""
def _choose(plan_key: str, resolved_key: str | None = None):
if plan_key in plan_entry and plan_entry[plan_key]:
return plan_entry[plan_key]
if resolved_key is not None and resolved.get(resolved_key):
return resolved[resolved_key]
return None
x_handle = _choose("x_handle", "x_handle")
if isinstance(x_handle, str):
x_handle = x_handle.lstrip("@") or None
subreddits = _choose("subreddits", "subreddits")
if isinstance(subreddits, list):
subreddits = [s.strip().lstrip("r/") for s in subreddits if s.strip()] or None
x_related = plan_entry.get("x_related")
if isinstance(x_related, list):
x_related = [h.strip().lstrip("@") for h in x_related if h.strip()] or None
else:
x_related = None
github_user = _choose("github_user", "github_user")
if isinstance(github_user, str):
github_user = github_user.lstrip("@").lower() or None
github_repos = _choose("github_repos", "github_repos")
if isinstance(github_repos, list):
github_repos = [r.strip() for r in github_repos if r.strip() and "/" in r.strip()] or None
context = plan_entry.get("context") or resolved.get("context") or ""
return {
"x_handle": x_handle,
"x_related": x_related,
"subreddits": subreddits,
"github_user": github_user,
"github_repos": github_repos,
"_context": context,
}
COMPETITORS_MIN = 1
COMPETITORS_MAX = 6
COMPETITORS_DEFAULT = 2
@@ -322,7 +451,12 @@ def _missing_sources_for_promo(diag: dict[str, object]) -> str | None:
return missing[0]
def _show_runtime_ui(report: schema.Report, progress: ui.ProgressDisplay, diag: dict[str, object]) -> None:
def _show_runtime_ui(
report: schema.Report,
progress: ui.ProgressDisplay,
diag: dict[str, object],
suppress_web_promo: bool = False,
) -> None:
counts = {source: len(items) for source, items in report.items_by_source.items()}
display_sources = list(
dict.fromkeys(
@@ -339,7 +473,19 @@ def _show_runtime_ui(report: schema.Report, progress: ui.ProgressDisplay, diag:
display_sources=display_sources,
)
promo = _missing_sources_for_promo(diag)
# The `web` promo nudges users to set BRAVE_API_KEY / SERPER_API_KEY, which
# is wrong advice when a hosting reasoning model (Claude Code, Codex,
# Hermes, Gemini) is driving — those already have WebSearch and can
# pre-resolve Step 0.55 themselves. Suppress the web promo when a hosting
# model signal is present (--plan or --competitors-plan was passed).
if promo:
if suppress_web_promo and promo == "web":
return
if suppress_web_promo and promo == "both":
# "both" means reddit + web both missing; still nudge reddit but
# skip the web line. show_promo has a per-source variant.
progress.show_promo("reddit", diag=diag)
return
progress.show_promo(promo, diag=diag)
@@ -461,6 +607,36 @@ def main() -> int:
config["INCLUDE_SOURCES"] = f"{include},perplexity" if include else "perplexity"
comp_enabled, comp_count, comp_explicit = resolve_competitors_args(args)
comp_plan = parse_competitors_plan(args.competitors_plan)
# Polymarket disambiguation: if user passed --polymarket-keywords,
# store on config so the polymarket adapter can filter matches.
if args.polymarket_keywords:
keywords = [
k.strip().lower()
for k in args.polymarket_keywords.split(",")
if k.strip()
]
if keywords:
config["_polymarket_keywords"] = keywords
# vs-mode: if the topic string contains " vs " / " versus " and the
# planner can split it into >=2 entities, route through the same
# N-pass fanout path as --competitors. The first entity becomes the
# main topic; remaining entities become the competitor list. User's
# outer --x-handle / --subreddits apply to the first entity unless
# --competitors-plan covers it.
from lib import planner as _planner
vs_entities = _planner._comparison_entities(topic)
if len(vs_entities) >= 2 and not comp_enabled:
topic = vs_entities[0]
comp_enabled = True
comp_count = len(vs_entities) - 1
comp_explicit = vs_entities[1:]
sys.stderr.write(
f"[Competitors] vs-mode: routing to N-pass fanout: "
f"{' vs '.join(vs_entities)}\n"
)
def _main_runner() -> schema.Report:
r = pipeline.run(
@@ -500,15 +676,26 @@ def main() -> int:
else:
if not resolve_mod._has_backend(config) and not args.mock:
sys.stderr.write(
"[Competitors] --competitors requires either a configured web "
"search backend (BRAVE_API_KEY / EXA_API_KEY / SERPER_API_KEY / "
"PARALLEL_API_KEY) or an explicit --competitors-list. If you are "
"the hosting reasoning model (Claude Code, Codex, Hermes, "
"Gemini, or any agent runtime), generate a comma-separated list "
"of 2-6 peer entities for the topic and re-invoke with "
"--competitors-list=\"A,B,C\". You do not need API keys; you ARE "
"the LLM. The web-search discovery path below is the headless / "
"credentialed path only.\n"
"[Competitors] Cannot auto-discover peers without help.\n"
"\n"
"RECOMMENDED PATH (hosting reasoning models — Claude Code, Codex, "
"Hermes, Gemini, any agent with a WebSearch tool): YOU have "
"WebSearch. Use it to run full Step 0.55 per entity, then invoke "
"the engine with a vs-topic plus --competitors-plan:\n"
" 1. WebSearch for '{topic} competitors' or '{topic} alternatives'.\n"
" 2. For each peer, WebSearch for handles/subs/github (Step 0.55).\n"
" 3. Re-invoke: /last30days '{topic} vs {peer1} vs {peer2}' "
"--competitors-plan '{\"Peer1\":{\"x_handle\":\"h1\",\"subreddits\":"
"[\"s1\"],...},\"Peer2\":{...}}'.\n"
"See SKILL.md 'Competitor mode' for the full protocol.\n"
"\n"
"HEADLESS / CRON PATH (no hosting model available): set "
"BRAVE_API_KEY / EXA_API_KEY / SERPER_API_KEY / PARALLEL_API_KEY / "
"OPENROUTER_API_KEY and re-run.\n"
"\n"
"MINIMUM ESCAPE HATCH: pass --competitors-list 'A,B,C' to skip "
"discovery. Without --competitors-plan, peer sub-runs fall back to "
"planner defaults and produce visibly thinner data than the main.\n"
)
return 2
discovered = competitors_mod.discover_competitors(
@@ -530,6 +717,7 @@ def main() -> int:
# leak across sub-runs. Each sub-run writes its own
# `_auto_resolve_context` into its local config copy.
entity_config = dict(config)
plan_entry = comp_plan.get(entity.strip().lower(), {})
resolved = {
"entity": entity,
"x_handle": "",
@@ -538,7 +726,18 @@ def main() -> int:
"github_repos": [],
"context": "",
}
if not args.mock and resolve_mod._has_backend(entity_config):
# Skip engine-internal auto_resolve when the hosting model
# pre-resolved via --competitors-plan (saves a redundant
# round-trip and makes per-entity Step 0.55 purely
# hosting-model-driven).
plan_covers_fully = bool(plan_entry.get("x_handle")) and bool(
plan_entry.get("subreddits")
)
if (
not args.mock
and not plan_covers_fully
and resolve_mod._has_backend(entity_config)
):
try:
r = resolve_mod.auto_resolve(entity, entity_config)
except Exception as exc:
@@ -552,29 +751,41 @@ def main() -> int:
resolved["github_user"] = r.get("github_user", "") or ""
resolved["github_repos"] = list(r.get("github_repos") or [])
resolved["context"] = r.get("context", "") or ""
if resolved["context"]:
entity_config["_auto_resolve_context"] = resolved["context"]
sys.stderr.write(
f"[Competitors] {entity}: "
f"x=@{resolved['x_handle'] or '-'} "
f"subs={len(resolved['subreddits'])} "
f"gh={resolved['github_user'] or '-'}\n"
)
kwargs = subrun_kwargs_for(entity, plan_entry, resolved=resolved)
# Record effective per-entity targeting for the Resolved block.
resolved_effective = {
"entity": entity,
"x_handle": kwargs["x_handle"] or "",
"subreddits": kwargs["subreddits"] or [],
"github_user": kwargs["github_user"] or "",
"github_repos": kwargs["github_repos"] or [],
"context": kwargs["_context"],
}
if kwargs["_context"]:
entity_config["_auto_resolve_context"] = kwargs["_context"]
sys.stderr.write(
f"[Competitors] {entity}: "
f"x=@{resolved_effective['x_handle'] or '-'} "
f"subs={len(resolved_effective['subreddits'])} "
f"gh={resolved_effective['github_user'] or '-'} "
f"({'plan' if plan_entry else 'auto'})\n"
)
report = pipeline.run(
topic=entity,
config=entity_config,
depth=depth,
requested_sources=requested_sources,
mock=args.mock,
x_handle=resolved["x_handle"] or None,
subreddits=resolved["subreddits"] or None,
github_user=resolved["github_user"] or None,
github_repos=resolved["github_repos"] or None,
x_handle=kwargs["x_handle"],
x_related=kwargs["x_related"],
subreddits=kwargs["subreddits"],
github_user=kwargs["github_user"],
github_repos=kwargs["github_repos"],
web_backend=args.web_backend,
lookback_days=args.lookback_days,
internal_subrun=True,
)
report.artifacts["resolved"] = resolved
report.artifacts["resolved"] = resolved_effective
return report
entity_reports = fanout.run_competitor_fanout(
@@ -592,14 +803,17 @@ def main() -> int:
)
return 1
report = entity_reports[0][1]
report.artifacts["competitor_reports"] = entity_reports
else:
entity_reports = None
report = _main_runner()
except Exception as exc:
progress.end_processing()
progress.show_error(str(exc))
raise
_show_runtime_ui(report, progress, diag)
_show_runtime_ui(
report, progress, diag,
suppress_web_promo=bool(external_plan or comp_plan),
)
if args.store:
counts = persist_report(report)
sys.stderr.write(
@@ -638,7 +852,6 @@ def main() -> int:
)
report.artifacts["pre_research_flags_present"] = pre_research_flags_present
entity_reports = report.artifacts.get("competitor_reports") if hasattr(report, "artifacts") else None
if entity_reports:
rendered = emit_comparison_output(
entity_reports, args.emit, fun_level=fun_level, save_path=footer_save_path,
@@ -648,8 +861,18 @@ def main() -> int:
report, args.emit, fun_level=fun_level, save_path=footer_save_path,
)
if args.save_dir:
# Save the main topic's raw file (single-entity or comparison main).
save_path = save_output(report, args.emit, args.save_dir, suffix=args.save_suffix or "")
sys.stderr.write(f"[last30days] Saved output to {save_path}\n")
# Competitor / vs-mode: also save a per-entity raw file for each peer.
# Matches historical vs-mode behavior (N passes → N save files).
if entity_reports and len(entity_reports) > 1:
for label, entity_report in entity_reports[1:]:
peer_path = save_output(
entity_report, args.emit, args.save_dir,
suffix=args.save_suffix or "",
)
sys.stderr.write(f"[last30days] Saved output to {peer_path}\n")
sys.stderr.flush()
print(rendered)
return 0