Craft Repo Status App

Find out the status of the craft apps: a tray dashboard ("Craft Status") that polls the storytold *craft repositories on GitHub every 5 minutes, keeps a cache, and tells you what to fix first. Everything runs locally: no server.

• Rust workspace
  • craft-core: the model, release/download accounting, the urgency heuristic, config, cache and window state. No network or UI dependencies, and it is unit-tested.
  • craft-github: the GitHub GraphQL/REST fetcher, plus a craft-fetch CLI that prints a table, for debugging.
  • craft-status-app: the Tauri 2 shell (poll thread, tray, global shortcut, window).
• TypeScript, HTML and CSS in ui/, with no framework or bundler. tsc compiles ui/src/ to ui/build/, which index.html loads; the app's build.rs runs it, so building the app needs Node.js 24+ and npm ci. ui/src/model.ts is pure; it and the UI itself (in happy-dom) are tested with node --test. No JavaScript is committed: see CLAUDE.md.

Every column sorts. Click a header; click it again to reverse the order. Repos with no data always sort last. Or drag rows into your own order (say, by priority): dropping one clears the sort, and the order is remembered until you sort by a column again.

• Activity covers the window picked in that group's header: the last 10 min, 30 min, hour, 4 h (the default), 12 h, day or week, since the last release, or all time. Every poll fetches all nine, so switching is instant; the choice is remembered. People are distinct commit authors in the window; all time, it is GitHub's contributor count. The numbers are as of the last poll, so short windows lag by up to poll_minutes.
• Since last release starts at each repo's own latest build, so the span differs per row (hover a number for the release and its date). Its commits are the Unreleased count; PRs, merges, issues and people count from the release's publish date. Repos with no release show —.
• Builds are GitHub releases. Drafts are ignored. Prereleases count, and they carry a PRE tag.
• Unreleased counts the commits that have landed on main since the latest build, by comparing its tag with main. When the tag's commit isn't on main (say, a release branch with a version bump), it counts the commits since the two split. When they share no history, it counts the main commits newer than the tag's commit. Both estimates show a ~. Click the number to open the comparison on GitHub.
• Downloads add up every OS and package type: dmg, msi, AppImage, deb, rpm, flatpak, zips and tarballs. Checksum lists, signatures, .zsync delta files and updater manifests are left out, because machines fetch them, not people.
• Fix first (⌘2) ranks open issues across every repo. Each issue shows the reasons behind its score. Click a row in the Repos table to filter the list to that repo. Click an issue to open it on GitHub.
• Freshness: the header shows when the oldest data on screen was fetched, and a pill that reads FRESH, REFRESHING or STALE. Data is stale when any repo has gone stale_minutes (default 15) without a successful fetch. A stale row is dimmed and gets an amber dot; a failed row gets a red dot, and its error appears in the banner. The tray tooltip also says whether the data is stale.

The score is deterministic and simple to read (crates/craft-core/src/urgency.rs):

Issues labelled wontfix, duplicate or invalid are dropped. For each repo, the 100 newest open issues and the 30 most-commented open issues are scored.

• The app polls every poll_minutes (default 5), one repo at a time, pausing after each GraphQL request as long as it took: GitHub allows only 60 s of GraphQL server time per minute, and back-to-back queries exceed it. Each repo costs about six GraphQL requests and one REST request: roughly 100 of the 5,000 GraphQL points GitHub allows per hour per cycle. It never uses search, which GitHub limits far more tightly (to about 30 a minute); PR and issue counts per window come from walking the recent PRs and issues.
• Each repo's icon is assets/app-icon/hicolor/64x64/apps/*.png on its default branch. It is downloaded once and again only when the file changes; it's kept in the cache. Repos without one (libraries) get a lettered tile.
• If fewer than 150 points remain, polling slows to every 30 minutes. If GitHub rate-limits the app, it stops that poll at once and waits three intervals. If every repo fails (offline, or just woke from sleep), it retries after one minute.
• Timing follows the wall clock, so a laptop that wakes from sleep polls within about 15 s.
• ⌘R or the ⟳ button refreshes immediately.
• Two caches in ~/Library/Caches/craft-status/ survive restarts:
  • raw/<owner>@<repo>.json: each repo's commit authors, PRs and issues from the last week (or since the latest build). Each poll fetches only what's new since the previous one, and refetches from scratch every six hours to drop deleted issues and pick up late-dated commits.
  • snapshot.json: what the window shows, saved after each repo. On launch the window shows it at once, marked STALE if it's old. If it is less than one interval old, the app skips the poll it would otherwise run at launch.
• The GitHub token comes from github_token in the config. If that is empty, it comes from $GITHUB_TOKEN or $GH_TOKEN, and if those are unset, from gh auth token.

The app behaves like the Todo app:

• It lives in the menu bar, with no Dock icon.
• Left-click the tray icon to show or hide the window. Right-click it to get Refresh Now, Always on Top, Edit Config… and Quit.
• ⌘⇧G shows or hides the window from anywhere.
• The window is chrome-less and semi-transparent, and it appears on every Space. It remembers its position and size in ~/.craft_status_state.toml.
• Esc hides the window.

The app creates this file from craft_status_config.template.toml the first time it launches. It re-reads the file before each poll, so edits to the repo list or the intervals take effect without a restart.

Prerequisites:

• Rust stable
• Node.js 24+, then npm ci (the UI's TypeScript compiler and test DOM)
• cargo install tauri-cli --version "^2"
• Xcode CLT on macOS
• gh auth login, or a token in the config

make install    # release .app → /Applications/Craft Status.app, start at login, launch
make uninstall  # quit, remove the app and the login item (keeps config + cache)
make run        # debug binary
make test       # Rust + UI tests
make check      # clippy + rustfmt + tsc type-check
make snapshot   # fetch once, print a table, write ui/dev-snapshot.json
make preview    # serve ui/ in a browser against that snapshot (no Tauri needed)

To start the app at login, make install adds ~/Library/LaunchAgents/ai.storyteller.craft-status.plist.