Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Remove unused triage project sync workflow (#62992)
Lena84aaa5259525
diff --git a/.github/workflows/triage_project_sync.yml b/.github/workflows/triage_project_sync.ymldeleted file mode 100644index 9b8500db982..00000000000--- a/.github/workflows/triage_project_sync.yml+++ /dev/null@@ -1,174 +0,0 @@-# Sync triage state into "Zed weekly triage" (project #84).-#-# Runs in two modes:-# 1. Event-driven (primary): fires on issue events + new issue comments.-# Re-derives Status / Stale since / Aged? / Intake week for that one-# issue. Latency: ~10–30 seconds end-to-end.-# 2. Daily cron (safety net): re-derives across all project items at 06:00-# UTC. Catches any events that GH dropped under load.-#-# Auth: GitHub App `ZED_COMMUNITY_BOT_APP_ID` with-# `Organization Projects: Read and write` permission added. Token is-# requested with `owner: zed-industries` so it can mutate org-level project-# items (the default repo-scoped token is insufficient for org projects).-#-# This workflow only mutates the triage project (#84). It does not write-# labels, comments, or any issue metadata. Adding any other write capability-# requires a separate workflow.--name: Triage Project Sync (#84)--on:- issues:- types:- - opened- - reopened- - closed- - labeled- - unlabeled- - assigned- - unassigned- - edited- issue_comment:- types: [created]- schedule:- - cron: "0 6 * * *" # daily 06:00 UTC- workflow_dispatch:- inputs:- issue_number:- description: "Issue number to sync (leave blank to sync all)"- type: number- required: false- dry_run:- description: "Dry run (compute but don't mutate)"- type: boolean- default: false--# Coalesce rapid event bursts on the same issue (e.g., 5 labels added at once-# = 5 events). Cancel any in-progress run for the same issue when a new event-# arrives — the latest run will compute the most up-to-date state.-concurrency:- group: triage-sync-${{ github.event.issue.number || github.run_id }}- cancel-in-progress: true--# Default to no permissions for any job in this workflow. The single job below-# explicitly opts back in to `contents: read` for the sparse checkout. If a-# future job is added without its own `permissions:` block, it will inherit-# this empty default rather than the repo-wide token defaults.-permissions: {}--jobs:- sync:- name: Sync triage project- # Run only on the canonical repo (not forks); skip PR comments since this- # workflow is for issues only.- if: |- github.repository == 'zed-industries/zed' &&- (github.event_name != 'issue_comment' || github.event.issue.pull_request == null)- runs-on: ubuntu-latest- timeout-minutes: 15- permissions:- contents: read-- steps:- - name: Checkout (sparse — script only)- uses: actions/checkout@93cb6efe18208431cddfb8368fd83d5badbf9bfd # v5.0.1- with:- sparse-checkout: script/triage_project_sync.py- sparse-checkout-cone-mode: false- # Don't write GITHUB_TOKEN into .git/config. We never push from this- # workflow; we only read one file. Keeps the token out of any- # filesystem state that subsequent steps could access.- persist-credentials: false-- - name: Get App installation token- id: token- uses: actions/create-github-app-token@f8d387b68d61c58ab83c6c016672934102569859 # v3.0.0- with:- app-id: ${{ secrets.ZED_COMMUNITY_BOT_APP_ID }}- private-key: ${{ secrets.ZED_COMMUNITY_BOT_PRIVATE_KEY }}- # IMPORTANT: org-scoped token is required for org-level project- # mutations. Without `owner:`, the default token is repo-scoped and- # cannot write to org projects.- owner: zed-industries- repositories: zed- # Scope the token down to the minimum needed for this workflow.- # Even though the App may have broader permissions for other- # automations (e.g., Issues:Write for the dupe-bot), this token- # only carries what we list below. Per the action's docs, an- # unrequested permission is *not* available on the resulting token.- #- # Required:- # - organization-projects:write — mutate project items + read- # project schema- # - members:read — query the `staff` team membership- # - issues:read — fetch issue body, labels, comments- # - metadata:read — always required for any GH API access- permission-organization-projects: write- permission-members: read- permission-issues: read- permission-metadata: read-- - name: Setup Python- uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0- with:- python-version: "3.12"-- - name: Install dependencies- run: pip install requests-- - name: Sync (event-driven, single issue)- if: github.event_name == 'issues' || github.event_name == 'issue_comment'- env:- GITHUB_TOKEN: ${{ steps.token.outputs.token }}- ISSUE_NUMBER: ${{ github.event.issue.number }}- run: |- python script/triage_project_sync.py --issue "$ISSUE_NUMBER"-- - name: Sync (cron, all items)- if: github.event_name == 'schedule'- env:- GITHUB_TOKEN: ${{ steps.token.outputs.token }}- run: |- python script/triage_project_sync.py --all-- - name: Sync (manual dispatch — single)- if: github.event_name == 'workflow_dispatch' && inputs.issue_number != ''- env:- GITHUB_TOKEN: ${{ steps.token.outputs.token }}- ISSUE_NUMBER: ${{ inputs.issue_number }}- DRY_RUN: ${{ inputs.dry_run }}- run: |- if [ "$DRY_RUN" = "true" ]; then- python script/triage_project_sync.py --issue "$ISSUE_NUMBER" --dry-run- else- python script/triage_project_sync.py --issue "$ISSUE_NUMBER"- fi-- - name: Sync (manual dispatch — all)- if: github.event_name == 'workflow_dispatch' && inputs.issue_number == ''- env:- GITHUB_TOKEN: ${{ steps.token.outputs.token }}- DRY_RUN: ${{ inputs.dry_run }}- run: |- if [ "$DRY_RUN" = "true" ]; then- python script/triage_project_sync.py --all --dry-run- else- python script/triage_project_sync.py --all- fi-- - name: Write summary- if: always()- env:- EVENT_NAME: ${{ github.event_name }}- ISSUE_NUMBER: ${{ github.event.issue.number }}- run: |- {- echo "## Triage sync summary"- echo ""- echo "- Event: \`$EVENT_NAME\`"- if [ -n "$ISSUE_NUMBER" ]; then- echo "- Issue: #$ISSUE_NUMBER"- fi- echo "- Project: [#84 Zed weekly triage](https://github.com/orgs/zed-industries/projects/84)"- } >> "$GITHUB_STEP_SUMMARY"diff --git a/script/triage_project_sync.py b/script/triage_project_sync.pydeleted file mode 100644index 8c5c75988ee..00000000000--- a/script/triage_project_sync.py+++ /dev/null@@ -1,858 +0,0 @@-#!/usr/bin/env python3-"""-triage_project_sync.py-======================--Sync triage state from `zed-industries/zed` issues into the-"Zed weekly triage" project (#84).--Auto-derives `Status`, `Stale since`, `Aged?`, `Intake week` from issue labels-+ comment activity + assignees. Mutates the project to-reflect the derived state.--The labels and the issue thread are the source of truth. The project is a-*derived view* — manual edits to the synced fields will be overwritten on the-next sync.--Modes------- --issue N Sync a single issue. Used by GH Actions on issue events.- --all Sync every item currently in the project. Used by daily- cron as a safety net.- --dry-run Compute derivations and log them, but don't mutate the- project. Safe for local testing / first deploy.--Auth------Reads `GITHUB_TOKEN` from env. For production, this is an installation token-from the `ZED_COMMUNITY_BOT_APP_ID` GitHub App, scoped to-`owner: zed-industries`, with `Organization Projects: Read and write`.--For local `--dry-run` testing, a personal token with `repo, read:org,-read:project` is sufficient.--Idempotency / safety----------------------- Every run re-derives all fields from current issue state. Running twice- produces the same result as once.-- Failures on a single issue (in `--all` mode) are logged and the run- continues. One bad item doesn't poison the batch.-- `--dry-run` makes no GraphQL mutations and no REST writes.--Dependencies-------------- pip install requests-"""--from __future__ import annotations--import argparse-import json-import os-import sys-import time-from dataclasses import dataclass-from datetime import datetime, timedelta, timezone--import requests--# ----------------------------------------------------------------------------# Constants--REPO_OWNER = "zed-industries"-REPO_NAME = "zed"-REPO = f"{REPO_OWNER}/{REPO_NAME}"--PROJECT_NUMBER = 84-PROJECT_OWNER = REPO_OWNER--STAFF_TEAM_SLUG = "staff"--# Status names. MUST match the option names configured in project #84.-# (Casing matters — GH Projects single-select option matching is case-sensitive.)-STATUS_NEEDS_LABELS = "Needs labels"-STATUS_NEEDS_REPRO_ATTEMPT = "Needs repro attempt"-STATUS_NEEDS_ASK = "Needs ask"-STATUS_USER_REPLIED = "User replied (review)"-STATUS_AWAITING_USER = "Awaiting user"-STATUS_RESPONDED_NO_REPRO = "Responded, no repro"-STATUS_AWAITING_EXTERNAL_REPRO = "Awaiting external repro" # not auto-set; placeholder-STATUS_REPRODUCIBLE = "Reproducible"-STATUS_HANDOFF = "Handoff"-STATUS_HANDOFF_INCOMPLETE = "Handoff (incomplete)"-STATUS_CLAIMED_COMMUNITY = "Claimed by community"-STATUS_CLOSED = "Closed"-STATUS_UNKNOWN = "Unknown"--# Aging thresholds (days) per spec.-SUBSTANTIVE_COMMENT_MIN_LEN = 50-AGE_THRESHOLDS_DAYS = {- STATUS_NEEDS_LABELS: 7,- STATUS_NEEDS_REPRO_ATTEMPT: 7,- STATUS_AWAITING_USER: 14,- STATUS_USER_REPLIED: 3,- # Needs ask is handled explicitly in derive_aged (always flagged), so- # it doesn't need a threshold here.-}--TERMINAL_OR_RESTING_STATUSES = {- STATUS_REPRODUCIBLE,- STATUS_HANDOFF,- STATUS_CLOSED,- STATUS_RESPONDED_NO_REPRO,- STATUS_CLAIMED_COMMUNITY,-}--# Issue types that aren't triage work items — administrative collections,-# dashboards, and trackers. The sync detects these and skips field updates;-# they remain in the project (auto-add put them there) but with empty fields,-# invisible in any status-filtered view. Manually remove them in the UI if-# they're cluttering the all-items list.-SKIP_ISSUE_TYPES = {"Meta", "Tracking"}--REST_API = "https://api.github.com"-GRAPHQL_API = "https://api.github.com/graphql"--NOW = datetime.now(timezone.utc)---# ----------------------------------------------------------------------------# Logging---def log(msg: str, level: str = "INFO") -> None:- ts = datetime.now(timezone.utc).strftime("%H:%M:%S")- print(f"[{ts}] [{level}] {msg}", file=sys.stderr, flush=True)---# ----------------------------------------------------------------------------# Auth---def get_token() -> str:- token = os.environ.get("GITHUB_TOKEN", "").strip()- if not token:- sys.exit("ERROR: GITHUB_TOKEN env var is required")- return token---_TOKEN: str | None = None---def headers_rest() -> dict[str, str]:- return {- "Authorization": f"Bearer {_TOKEN}",- "Accept": "application/vnd.github+json",- "X-GitHub-Api-Version": "2022-11-28",- }---def headers_graphql() -> dict[str, str]:- return {"Authorization": f"Bearer {_TOKEN}", "Content-Type": "application/json"}---# ----------------------------------------------------------------------------# REST---def rest_get(path: str, params: dict | None = None, retries: int = 3) -> dict | list:- url = f"{REST_API}/{path.lstrip('/')}"- last_err: Exception | None = None- for attempt in range(retries):- try:- r = requests.get(url, headers=headers_rest(), params=params, timeout=30)- if r.status_code == 200:- return r.json()- if r.status_code in (429, 502, 503, 504):- wait = 2**attempt * 2- log(f"REST {r.status_code} on {path}; retry in {wait}s", "WARN")- time.sleep(wait)- continue- log(f"REST GET {path} failed: {r.status_code} {r.text[:200]}", "ERROR")- r.raise_for_status()- except requests.RequestException as e:- last_err = e- wait = 2**attempt * 2- log(f"REST GET {path} threw {e}; retry in {wait}s", "WARN")- time.sleep(wait)- raise RuntimeError(f"REST GET {path} failed after {retries} retries: {last_err}")---def rest_get_paginated(path: str, params: dict | None = None, max_pages: int = 20) -> list:- p = dict(params or {})- p["per_page"] = 100- out: list = []- for page in range(1, max_pages + 1):- p["page"] = page- items = rest_get(path, p)- if not items:- break- if not isinstance(items, list):- log(f"REST {path} page {page} returned non-list", "WARN")- break- out.extend(items)- if len(items) < 100:- break- return out---# ----------------------------------------------------------------------------# GraphQL---def graphql(query: str, variables: dict | None = None, retries: int = 3) -> dict:- payload = {"query": query, "variables": variables or {}}- last_err: Exception | None = None- for attempt in range(retries):- try:- r = requests.post(GRAPHQL_API, headers=headers_graphql(), json=payload, timeout=30)- if r.status_code == 200:- data = r.json()- if "errors" in data:- log(f"GraphQL errors: {json.dumps(data['errors'])[:400]}", "ERROR")- raise RuntimeError("GraphQL returned errors")- return data["data"]- if r.status_code in (429, 502, 503, 504):- wait = 2**attempt * 2- log(f"GraphQL {r.status_code}; retry in {wait}s", "WARN")- time.sleep(wait)- continue- log(f"GraphQL HTTP {r.status_code}: {r.text[:300]}", "ERROR")- r.raise_for_status()- except requests.RequestException as e:- last_err = e- wait = 2**attempt * 2- log(f"GraphQL threw {e}; retry in {wait}s", "WARN")- time.sleep(wait)- raise RuntimeError(f"GraphQL failed after {retries} retries: {last_err}")---# ----------------------------------------------------------------------------# Issue data fetch---@dataclass-class IssueData:- number: int- node_id: str- title: str- state: str # "open" / "closed"- closed_at: datetime | None- created_at: datetime- reporter: str- assignees: list[str]- labels: list[str]- issue_type: str | None # e.g. "Bug", "Crash", "Meta", "Tracking", or None- is_pull_request: bool- comments: list[dict]---def parse_dt(s: str | None) -> datetime | None:- if not s:- return None- return datetime.fromisoformat(s.replace("Z", "+00:00"))---def fetch_issue(number: int) -> IssueData:- issue = rest_get(f"repos/{REPO}/issues/{number}")- if not isinstance(issue, dict):- raise RuntimeError(f"unexpected response for issue {number}")- comments = rest_get_paginated(f"repos/{REPO}/issues/{number}/comments")- created_at = parse_dt(issue["created_at"])- if created_at is None:- raise RuntimeError(f"issue {number} has no created_at")- issue_type = None- if isinstance(issue.get("type"), dict):- issue_type = issue["type"].get("name")- return IssueData(- number=number,- node_id=issue["node_id"],- title=issue["title"],- state=issue["state"],- closed_at=parse_dt(issue.get("closed_at")),- created_at=created_at,- reporter=issue["user"]["login"],- assignees=[a["login"] for a in (issue.get("assignees") or [])],- labels=[l["name"] for l in issue["labels"]],- issue_type=issue_type,- is_pull_request="pull_request" in issue,- comments=comments,- )---# ----------------------------------------------------------------------------# Staff team---_STAFF: set[str] | None = None---def fetch_staff() -> set[str]:- global _STAFF- if _STAFF is not None:- return _STAFF- members = rest_get_paginated(f"orgs/{REPO_OWNER}/teams/{STAFF_TEAM_SLUG}/members")- _STAFF = {m["login"] for m in members}- log(f"loaded {len(_STAFF)} staff members")- return _STAFF---def is_bot(user: dict) -> bool:- return user.get("type") == "Bot" or user.get("login", "").endswith("[bot]")---def is_substantive_staff_comment(comment: dict, staff: set[str]) -> bool:- user = comment.get("user", {})- if user.get("login") not in staff or is_bot(user):- return False- body = comment.get("body") or ""- if len(body) >= SUBSTANTIVE_COMMENT_MIN_LEN:- return True- # Cheap attachment heuristic: looks for media tokens or attachment hosts.- if any(- m in body- for m in (- "user-attachments/assets",- ".png",- ".jpg",- ".jpeg",- ".gif",- ".mp4",- ".webm",- ".mov",- )- ):- return True- return False---def latest_reporter_activity(issue: IssueData) -> datetime:- times = [issue.created_at]- for c in issue.comments:- if c["user"]["login"] == issue.reporter:- t = parse_dt(c["created_at"])- if t:- times.append(t)- return max(times)---# ----------------------------------------------------------------------------# Derivation rules-# (Mirrors the spec's R0-R6 cascade. Keep in sync with-# spec.md → "Status derivation rules".)---def derive_status(issue: IssueData, staff: set[str]) -> tuple[str, str, str]:- """Returns (status, rule_id, why)."""- L = set(issue.labels)-- if issue.closed_at is not None:- return STATUS_CLOSED, "R1", "issue is closed"-- if "state:claimed by community" in L:- return STATUS_CLAIMED_COMMUNITY, "R0", "state:claimed by community label"-- if "state:reproducible" in L:- if issue.assignees:- return STATUS_REPRODUCIBLE, "R2a", f"reproducible, assignee={','.join(issue.assignees)}"- # R2b vs R2c: any substantive staff comment in the thread?- substantive = None- for c in issue.comments:- if is_substantive_staff_comment(c, staff):- substantive = c- if substantive:- return (- STATUS_HANDOFF,- "R2b",- f"reproducible, no assignee, staff context @ {substantive['created_at']} "- f"({len(substantive['body'])} chars by @{substantive['user']['login']})",- )- return (- STATUS_HANDOFF_INCOMPLETE,- "R2c",- "reproducible, no assignee, no substantive staff comment — close the loop",- )-- # R4 (state:needs info) and R5 (state:needs repro) intentionally come- # before R3 (state:needs triage). Per the team's actual practice,- # state:needs triage is often left on while triage is in progress; only- # when no other state label is more specific should we treat the issue- # as "needs initial labels."- if "state:needs info" in L:- # R4 splits into three sub-cases based on whether we've actually- # asked anything (substantive staff comment) and whether the reporter- # or a third-party has responded.- substantive_staff = None- for c in issue.comments:- if is_substantive_staff_comment(c, staff):- substantive_staff = c- if substantive_staff is None:- # state:needs info applied without an actual question to the user.- # Runbook violation — we owe the reporter a comment explaining- # what info we need.- return (- STATUS_NEEDS_ASK,- "R4c",- "state:needs info present but no substantive staff comment exists — we haven't asked anything",- )- last_comment = issue.comments[-1] if issue.comments else None- if last_comment is not None:- author = last_comment["user"]["login"]- non_staff = author not in staff and not is_bot(last_comment["user"])- if non_staff:- ct = parse_dt(last_comment["created_at"])- st = parse_dt(substantive_staff["created_at"])- if ct and st and ct > st:- relation = "reporter" if author == issue.reporter else "third-party"- return (- STATUS_USER_REPLIED,- "R4b",- f"{relation} (@{author}) replied {ct.isoformat()} after substantive staff @ {st.isoformat()}",- )- return (- STATUS_AWAITING_USER,- "R4a",- f"substantive staff comment @ {substantive_staff['created_at']}, no non-staff reply since",- )-- if "state:needs repro" in L:- cutoff = latest_reporter_activity(issue)- for c in reversed(issue.comments):- ct = parse_dt(c["created_at"])- if ct and ct > cutoff and is_substantive_staff_comment(c, staff):- return (- STATUS_RESPONDED_NO_REPRO,- "R5b",- f"staff comment {len(c['body'])} chars by @{c['user']['login']} @ {c['created_at']}",- )- return STATUS_NEEDS_REPRO_ATTEMPT, "R5a", "no substantive staff comment after reporter's last activity"-- # R3 (state:needs triage) is checked LAST among recognized state labels.- # If state:needs triage is the only state label, the issue genuinely needs- # initial labeling. If any other state label is also present, that state- # has already been matched above and won.- if "state:needs triage" in L:- return STATUS_NEEDS_LABELS, "R3", "state:needs triage label present (no other state:* matched)"-- return STATUS_UNKNOWN, "R6", f"open with no recognized state label (labels: {sorted(L) or '<none>'})"---def derive_stale_since(- issue: IssueData, status: str, staff: set[str]-) -> datetime | None:- """Returns the timestamp anchor used to measure aging, or None."""- if status in TERMINAL_OR_RESTING_STATUSES or status == STATUS_UNKNOWN:- return None- if status == STATUS_NEEDS_LABELS:- return issue.created_at- if status == STATUS_NEEDS_REPRO_ATTEMPT:- return latest_reporter_activity(issue)- if status == STATUS_NEEDS_ASK:- # Anchor on issue creation — measures how long the runbook violation- # has gone unaddressed. Aging threshold is 0 (always flagged).- return issue.created_at- if status == STATUS_AWAITING_USER:- # Anchor on the most recent SUBSTANTIVE staff comment (the actual- # "ask"), consistent with R4's substantive-comment requirement.- substantive_staff = None- for c in issue.comments:- if is_substantive_staff_comment(c, staff):- substantive_staff = c- return parse_dt(substantive_staff["created_at"]) if substantive_staff else issue.created_at- if status == STATUS_USER_REPLIED:- last_non_staff = None- for c in issue.comments:- u = c["user"]- if u["login"] not in staff and not is_bot(u):- last_non_staff = c- return parse_dt(last_non_staff["created_at"]) if last_non_staff else None- if status == STATUS_HANDOFF_INCOMPLETE:- # Spec: when state:reproducible was applied. Approximation for v0:- # issue.created_at as a weak proxy. Replacing with timeline event lookup- # is a "parked" item.- return issue.created_at- return None---def derive_aged(status: str, stale_since: datetime | None) -> tuple[str, str]:- """Returns ('Yes' | 'No', why)."""- if status == STATUS_HANDOFF_INCOMPLETE:- return "Yes", "always-flagged for loop closure"- if status == STATUS_NEEDS_ASK:- return "Yes", "always-flagged: state:needs info applied without a substantive staff comment"- if status in TERMINAL_OR_RESTING_STATUSES or status == STATUS_UNKNOWN:- return "No", "terminal/resting"- if not stale_since:- return "No", "no stale_since (status not aged-tracked)"- if status not in AGE_THRESHOLDS_DAYS:- return "No", f"status {status} not aged-tracked"- age = NOW - stale_since- threshold = AGE_THRESHOLDS_DAYS[status]- if age > timedelta(days=threshold):- return "Yes", f"{status} for {age.days}d (>{threshold}d)"- return "No", f"{status} for {age.days}d (≤{threshold}d)"---# ----------------------------------------------------------------------------# Project schema cache-# Discovered at runtime by name so the script doesn't break if field IDs-# change (e.g., project recreated). Project number is stable config.---_PROJECT_SCHEMA: dict | None = None---def fetch_project_schema() -> dict:- """Returns {'id', 'fields_by_name'} where fields_by_name maps name → field dict."""- global _PROJECT_SCHEMA- if _PROJECT_SCHEMA is not None:- return _PROJECT_SCHEMA- query = """- query($owner: String!, $number: Int!) {- organization(login: $owner) {- projectV2(number: $number) {- id- fields(first: 30) {- nodes {- __typename- ... on ProjectV2Field { id name dataType }- ... on ProjectV2SingleSelectField {- id name dataType options { id name }- }- ... on ProjectV2IterationField {- id name dataType- configuration {- duration startDay- iterations { id title startDate duration }- completedIterations { id title startDate duration }- }- }- }- }- }- }- }- """- data = graphql(query, {"owner": PROJECT_OWNER, "number": PROJECT_NUMBER})- proj = data["organization"]["projectV2"]- if not proj:- sys.exit(f"ERROR: project #{PROJECT_NUMBER} not found in {PROJECT_OWNER}")- fields_by_name = {f["name"]: f for f in proj["fields"]["nodes"]}- required = ["Status", "Intake week", "Stale since", "Aged?"]- missing = [n for n in required if n not in fields_by_name]- if missing:- sys.exit(f"ERROR: project missing required fields: {missing}")- _PROJECT_SCHEMA = {"id": proj["id"], "fields_by_name": fields_by_name}- log(f"loaded project schema: id={proj['id']}, fields={list(fields_by_name)}")- return _PROJECT_SCHEMA---def status_option_id(status_name: str) -> str | None:- schema = fetch_project_schema()- for opt in schema["fields_by_name"]["Status"]["options"]:- if opt["name"] == status_name:- return opt["id"]- return None---def aged_option_id(value: str) -> str | None:- schema = fetch_project_schema()- for opt in schema["fields_by_name"]["Aged?"]["options"]:- if opt["name"] == value:- return opt["id"]- return None---def iteration_id_for_date(d: datetime) -> str | None:- schema = fetch_project_schema()- field = schema["fields_by_name"]["Intake week"]- cfg = field["configuration"]- iterations = list(cfg.get("iterations") or []) + list(cfg.get("completedIterations") or [])- for it in iterations:- start = parse_dt(it["startDate"] + "T00:00:00+00:00")- if start is None:- continue- end = start + timedelta(days=int(it["duration"]))- if start <= d < end:- return it["id"]- return None---# ----------------------------------------------------------------------------# Project item lookup / mutation---def get_project_item_id(issue_node_id: str) -> str | None:- """Returns the ProjectV2Item.id for the issue in our project, or None."""- schema = fetch_project_schema()- project_id = schema["id"]- query = """- query($issueId: ID!) {- node(id: $issueId) {- ... on Issue {- projectItems(first: 100) {- pageInfo { hasNextPage }- nodes { id project { id } }- }- }- }- }- """- data = graphql(query, {"issueId": issue_node_id})- node = data["node"]- if not node:- return None- items_block = node["projectItems"]- for item in items_block["nodes"]:- if item["project"]["id"] == project_id:- return item["id"]- if items_block["pageInfo"]["hasNextPage"]:- # Issue is on >100 projects; very unlikely. Log + return None.- log(f"issue {issue_node_id} on >100 projects, can't find ours in first page", "WARN")- return None---def add_to_project(issue_node_id: str) -> str:- schema = fetch_project_schema()- mutation = """- mutation($projectId: ID!, $issueId: ID!) {- addProjectV2ItemById(input: { projectId: $projectId, contentId: $issueId }) {- item { id }- }- }- """- data = graphql(mutation, {"projectId": schema["id"], "issueId": issue_node_id})- return data["addProjectV2ItemById"]["item"]["id"]-----def update_single_select(item_id: str, field_id: str, option_id: str, dry_run: bool) -> None:- if dry_run:- log(f" [DRY] single-select field={field_id} option={option_id} on item={item_id}")- return- schema = fetch_project_schema()- mutation = """- mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $optionId: String!) {- updateProjectV2ItemFieldValue(input: {- projectId: $projectId, itemId: $itemId, fieldId: $fieldId,- value: { singleSelectOptionId: $optionId }- }) { projectV2Item { id } }- }- """- graphql(- mutation,- {- "projectId": schema["id"],- "itemId": item_id,- "fieldId": field_id,- "optionId": option_id,- },- )---def update_date(item_id: str, field_id: str, date_iso: str, dry_run: bool) -> None:- if dry_run:- log(f" [DRY] date field={field_id} value={date_iso} on item={item_id}")- return- schema = fetch_project_schema()- mutation = """- mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $date: Date!) {- updateProjectV2ItemFieldValue(input: {- projectId: $projectId, itemId: $itemId, fieldId: $fieldId,- value: { date: $date }- }) { projectV2Item { id } }- }- """- graphql(- mutation,- {"projectId": schema["id"], "itemId": item_id, "fieldId": field_id, "date": date_iso},- )---def update_iteration(item_id: str, field_id: str, iteration_id: str, dry_run: bool) -> None:- if dry_run:- log(f" [DRY] iteration field={field_id} value={iteration_id} on item={item_id}")- return- schema = fetch_project_schema()- mutation = """- mutation($projectId: ID!, $itemId: ID!, $fieldId: ID!, $iterId: String!) {- updateProjectV2ItemFieldValue(input: {- projectId: $projectId, itemId: $itemId, fieldId: $fieldId,- value: { iterationId: $iterId }- }) { projectV2Item { id } }- }- """- graphql(- mutation,- {- "projectId": schema["id"],- "itemId": item_id,- "fieldId": field_id,- "iterId": iteration_id,- },- )---# ----------------------------------------------------------------------------# Sync---def sync_issue(number: int, dry_run: bool = False) -> None:- """Sync a single issue. Adds to project if missing, then updates fields.-- Idempotent — running twice with the same issue state has no effect after- the first run.- """- log(f"sync #{number} (dry_run={dry_run})")- issue = fetch_issue(number)-- if issue.is_pull_request:- log(f" #{number} is a PR; skipping (project tracks issues)")- return-- # Skip administrative issue types (Meta, Tracking, etc.). These are- # collections / dashboards, not triage work. The script doesn't have- # permission to remove items from the project (intentional — narrows blast- # radius). Existing Meta/Tracking items in the project should be removed- # manually one-time; new ones get auto-added by the project's auto-add- # workflow but the sync below skips them, so they sit with no Status /- # Aged? / Stale since fields set and don't appear in any status-filtered- # view.- if issue.issue_type in SKIP_ISSUE_TYPES:- log(f" #{number} is type={issue.issue_type}; not a triage item, skipping fields")- return-- staff = fetch_staff()-- status, rule, why = derive_status(issue, staff)- stale_since = derive_stale_since(issue, status, staff)- aged, aged_why = derive_aged(status, stale_since)- intake_iter_id = iteration_id_for_date(issue.created_at)-- log(f" status={status} ({rule}: {why})")- log(f" stale_since={stale_since.isoformat() if stale_since else 'none'}")- log(f" aged={aged} ({aged_why})")- log(f" intake_iteration_id={intake_iter_id or 'none (created_at outside iteration range)'}")-- schema = fetch_project_schema()- item_id = get_project_item_id(issue.node_id)- if not item_id:- if dry_run:- log(" [DRY] would add to project (item not yet present)")- return- item_id = add_to_project(issue.node_id)- log(f" added to project as item={item_id}")-- # Status (always set)- sid = status_option_id(status)- if not sid:- log(f" ERROR: no Status option named '{status}' in project; skipping status update", "ERROR")- else:- update_single_select(- item_id, schema["fields_by_name"]["Status"]["id"], sid, dry_run- )-- # Aged? (always set)- aged_id = aged_option_id(aged)- if not aged_id:- log(f" ERROR: no Aged? option named '{aged}'; skipping", "ERROR")- else:- update_single_select(- item_id, schema["fields_by_name"]["Aged?"]["id"], aged_id, dry_run- )-- # Stale since (only set when meaningful)- if stale_since:- update_date(- item_id,- schema["fields_by_name"]["Stale since"]["id"],- stale_since.date().isoformat(),- dry_run,- )-- # Intake week (only set when an iteration covers the created_at)- if intake_iter_id:- update_iteration(- item_id,- schema["fields_by_name"]["Intake week"]["id"],- intake_iter_id,- dry_run,- )---def sync_all(dry_run: bool = False) -> None:- """Sync every item currently in the project. Cron mode."""- log("fetching all project items…")- cursor: str | None = None- total = 0- failed = 0- while True:- query = """- query($owner: String!, $number: Int!, $cursor: String) {- organization(login: $owner) {- projectV2(number: $number) {- items(first: 100, after: $cursor) {- pageInfo { hasNextPage endCursor }- nodes {- id- content {- __typename- ... on Issue { number }- ... on PullRequest { number }- }- }- }- }- }- }- """- data = graphql(- query, {"owner": PROJECT_OWNER, "number": PROJECT_NUMBER, "cursor": cursor}- )- items_block = data["organization"]["projectV2"]["items"]- for item in items_block["nodes"]:- content = item.get("content")- if not content:- continue- if content["__typename"] != "Issue":- continue- num = content["number"]- try:- sync_issue(num, dry_run=dry_run)- except Exception as e:- log(f"sync #{num} failed: {e}", "ERROR")- failed += 1- total += 1- if not items_block["pageInfo"]["hasNextPage"]:- break- cursor = items_block["pageInfo"]["endCursor"]- log(f"done: synced {total} items, {failed} failed")---# ----------------------------------------------------------------------------# Main---def main() -> int:- global _TOKEN-- ap = argparse.ArgumentParser(description=__doc__)- grp = ap.add_mutually_exclusive_group(required=True)- grp.add_argument("--issue", type=int, help="sync a single issue by number")- grp.add_argument("--all", action="store_true", help="sync every project item")- ap.add_argument("--dry-run", action="store_true", help="compute but don't mutate")- args = ap.parse_args()-- _TOKEN = get_token()-- if args.issue:- sync_issue(args.issue, dry_run=args.dry_run)- elif args.all:- sync_all(dry_run=args.dry_run)-- return 0---if __name__ == "__main__":- sys.exit(main())