rvlib-shipkit 1.6.0 → 1.8.0

package/src/home/gui-app/ShipkitGui.swift

@@ -17,55 +17,110 @@ func stays(_ url: URL) -> Bool {
     url.host == "127.0.0.1" || url.host == "localhost" || url.host == startURL.host
 }
 
-/** a window's content: the web view, and the find bar above it when shown.
- *  WKWebView is an NSTextFinderClient, so the platform find bar searches the
- *  page; this view is the bar's container */
-final class Pane: NSView, NSTextFinderBarContainer {
+/** a window's content: the find bar above the web view when shown. WebKit's
+ *  public find api searches the page: NSTextFinder never shows its bar for a
+ *  WKWebView, which is no NSTextFinderClient at runtime */
+final class Pane: NSView, NSSearchFieldDelegate {
     let web: WKWebView
-    let finder = NSTextFinder()
+    let bar = NSStackView()
+    let field = NSSearchField()
+    let status = NSTextField(labelWithString: "")
+    static let barHeight: CGFloat = 34
 
     init(web: WKWebView) {
         self.web = web
         super.init(frame: .zero)
         addSubview(web)
-        finder.client = web
-        finder.findBarContainer = self
-        finder.isIncrementalSearchingEnabled = true
-        finder.incrementalSearchingShouldDimContentView = false
+        field.placeholderString = "find in page"
+        field.delegate = self
+        field.sendsSearchStringImmediately = true
+        status.textColor = .secondaryLabelColor
+        let prev = NSButton(title: "‹", target: self, action: #selector(findPrevious))
+        let next = NSButton(title: "›", target: self, action: #selector(findNext))
+        let done = NSButton(title: "Done", target: self, action: #selector(hideFind))
+        prev.toolTip = "previous match (⇧⌘G, ⇧↩)"
+        next.toolTip = "next match (⌘G, ↩)"
+        for b in [prev, next, done] { b.bezelStyle = .rounded; b.controlSize = .small }
+        field.controlSize = .small
+        field.widthAnchor.constraint(greaterThanOrEqualToConstant: 220).isActive = true
+        bar.orientation = .horizontal
+        bar.spacing = 6
+        bar.edgeInsets = NSEdgeInsets(top: 4, left: 8, bottom: 4, right: 8)
+        for v in [field, status, prev, next, done] as [NSView] { bar.addArrangedSubview(v) }
+        bar.setHuggingPriority(.defaultLow, for: .horizontal)
+        bar.isHidden = true
+        addSubview(bar)
     }
 
     required init?(coder: NSCoder) { fatalError("not from a nib") }
 
     override var isFlipped: Bool { true }
 
-    var findBarView: NSView? {
+    var isFindBarVisible = false {
         didSet {
-            oldValue?.removeFromSuperview()
-            if let bar = findBarView { addSubview(bar) }
+            bar.isHidden = !isFindBarVisible
             needsLayout = true
         }
     }
 
-    var isFindBarVisible = false {
-        didSet {
-            findBarView?.isHidden = !isFindBarVisible
-            needsLayout = true
+    override func layout() {
+        super.layout()
+        let top = isFindBarVisible ? Pane.barHeight : 0
+        bar.frame = NSRect(x: 0, y: 0, width: bounds.width, height: Pane.barHeight)
+        web.frame = NSRect(x: 0, y: top, width: bounds.width, height: max(0, bounds.height - top))
+    }
+
+    @objc func showFind() {
+        isFindBarVisible = true
+        window?.makeFirstResponder(field)
+        field.currentEditor()?.selectAll(nil)
+    }
+
+    @objc func hideFind() {
+        isFindBarVisible = false
+        window?.makeFirstResponder(web)
+    }
+
+    @objc func findNext() { search(backwards: false) }
+    @objc func findPrevious() { search(backwards: true) }
+
+    /** the next match of the field's text from the page's selection, wrapping;
+     *  `done` hears whether one was found */
+    func search(backwards: Bool, done: ((Bool) -> Void)? = nil) {
+        let q = field.stringValue
+        if q.isEmpty {
+            status.stringValue = ""
+            done?(false)
+            return
+        }
+        let c = WKFindConfiguration()
+        c.backwards = backwards
+        c.wraps = true
+        c.caseSensitive = false
+        web.find(q, configuration: c) { r in
+            self.status.stringValue = r.matchFound ? "" : "no match"
+            done?(r.matchFound)
         }
     }
 
-    func findBarViewDidChangeHeight() { needsLayout = true }
+    /** typing searches again from the top of the page */
+    func fromTop(done: ((Bool) -> Void)? = nil) {
+        web.evaluateJavaScript("getSelection().removeAllRanges()") { _, _ in self.search(backwards: false, done: done) }
+    }
 
-    func contentView() -> NSView? { web }
+    func controlTextDidChange(_ note: Notification) { fromTop() }
 
-    override func layout() {
-        super.layout()
-        var top: CGFloat = 0
-        if let bar = findBarView, isFindBarVisible {
-            let h = bar.frame.height
-            bar.frame = NSRect(x: 0, y: 0, width: bounds.width, height: h)
-            top = h
+    // in the field: return is the next match, shift return the previous, esc closes
+    func control(_ control: NSControl, textView: NSTextView, doCommandBy sel: Selector) -> Bool {
+        if sel == #selector(NSResponder.insertNewline(_:)) {
+            search(backwards: NSApp.currentEvent?.modifierFlags.contains(.shift) == true)
+            return true
         }
-        web.frame = NSRect(x: 0, y: top, width: bounds.width, height: max(0, bounds.height - top))
+        if sel == #selector(NSResponder.cancelOperation(_:)) {
+            hideFind()
+            return true
+        }
+        return false
     }
 }
 
@@ -74,12 +129,12 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     var opened = false
 
     func applicationDidFinishLaunching(_ note: Notification) {
+        if CommandLine.arguments.contains("--self-test-find") { return selfTestFind() }
         buildMenu()
         // esc closes the find bar of the key window, and reaches the page otherwise
         NSEvent.addLocalMonitorForEvents(matching: .keyDown) { e in
             if e.keyCode == 53, let pane = self.keyPane(), pane.isFindBarVisible {
-                pane.finder.performAction(.hideFindInterface)
-                pane.window?.makeFirstResponder(pane.web)
+                pane.hideFind()
                 return nil
             }
             return e
@@ -128,11 +183,10 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     @objc func zoomOut(_ sender: Any?) { zoom = zoom / 1.1 }
     @objc func zoomReset(_ sender: Any?) { zoom = 1 }
 
-    // the menu item's tag is the NSTextFinder.Action it performs
-    @objc func findAction(_ sender: NSMenuItem) {
-        guard let pane = keyPane(), let action = NSTextFinder.Action(rawValue: sender.tag) else { return }
-        pane.finder.performAction(action)
-    }
+    @objc func showFind(_ sender: Any?) { keyPane()?.showFind() }
+    @objc func hideFind(_ sender: Any?) { keyPane()?.hideFind() }
+    @objc func findNext(_ sender: Any?) { keyPane()?.findNext() }
+    @objc func findPrevious(_ sender: Any?) { keyPane()?.findPrevious() }
 
     // no public api opens the inspector: `_inspector` then `show` is the
     // WebKit call the context menu's Inspect Element makes. Where it is gone,
@@ -151,10 +205,9 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
     }
 
     func validateMenuItem(_ item: NSMenuItem) -> Bool {
-        if item.action == #selector(findAction(_:)) {
-            guard let pane = keyPane(), let action = NSTextFinder.Action(rawValue: item.tag) else { return false }
-            return pane.finder.validateAction(action)
-        }
+        if item.action == #selector(hideFind(_:)) { return keyPane()?.isFindBarVisible == true }
+        if item.action == #selector(findNext(_:)) || item.action == #selector(findPrevious(_:)) { return keyPane()?.field.stringValue.isEmpty == false }
+        if item.action == #selector(showFind(_:)) { return keyPane() != nil }
         if item.action == #selector(devTools(_:)) || item.action == #selector(reload(_:)) { return keyPane() != nil }
         return true
     }
@@ -184,12 +237,43 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         NSApp.activate(ignoringOtherApps: true)
     }
 
+    var onLoad: ((WKWebView) -> Void)?
+
+    // `--self-test-find`: an offscreen window on a page holding a word twice,
+    // the find bar opened, a word on the page searched, then one that is not;
+    // what happened printed, exit 0 only when the bar shows and finds
+    func selfTestFind() {
+        let web = WKWebView(frame: .zero, configuration: WKWebViewConfiguration())
+        web.navigationDelegate = self
+        let pane = Pane(web: web)
+        let win = NSWindow(contentRect: NSRect(x: -4000, y: -4000, width: 600, height: 400), styleMask: [.titled], backing: .buffered, defer: false)
+        win.contentView = pane
+        win.orderFrontRegardless()
+        windows.append(win)
+        onLoad = { _ in
+            pane.showFind()
+            pane.field.stringValue = "needle"
+            pane.fromTop { found in
+                pane.field.stringValue = "haystack"
+                pane.fromTop { absent in
+                    print("find-bar-visible=\(pane.isFindBarVisible)")
+                    print("found=\(found)")
+                    print("absent-found=\(absent)")
+                    print("status=\(pane.status.stringValue)")
+                    exit(pane.isFindBarVisible && found && !absent ? 0 : 1)
+                }
+            }
+        }
+        web.loadHTMLString("<p>one needle, two needle</p>", baseURL: nil)
+    }
+
     func windowWillClose(_ note: Notification) {
         windows.removeAll { $0 === note.object as? NSWindow }
     }
 
     // the page title names the window, so cmd-tab and the window menu tell pages apart
     func webView(_ web: WKWebView, didFinish nav: WKNavigation!) {
+        onLoad?(web)
         web.window?.title = (web.title?.isEmpty == false) ? web.title! : appName
     }
 
@@ -242,10 +326,10 @@ final class Delegate: NSObject, NSApplicationDelegate, WKNavigationDelegate, WKU
         edit.addItem(.separator())
         let findItem = edit.addItem(withTitle: "Find", action: nil, keyEquivalent: "")
         let find = NSMenu(title: "Find")
-        item(find, "Find…", #selector(findAction(_:)), "f", tag: NSTextFinder.Action.showFindInterface.rawValue)
-        item(find, "Find Next", #selector(findAction(_:)), "g", tag: NSTextFinder.Action.nextMatch.rawValue)
-        item(find, "Find Previous", #selector(findAction(_:)), "g", [.command, .shift], tag: NSTextFinder.Action.previousMatch.rawValue)
-        item(find, "Hide Find Bar", #selector(findAction(_:)), "", [], tag: NSTextFinder.Action.hideFindInterface.rawValue)
+        item(find, "Find…", #selector(showFind(_:)), "f")
+        item(find, "Find Next", #selector(findNext(_:)), "g")
+        item(find, "Find Previous", #selector(findPrevious(_:)), "g", [.command, .shift])
+        item(find, "Hide Find Bar", #selector(hideFind(_:)), "", [])
         edit.setSubmenu(find, for: findItem)
         editItem.submenu = edit
         let viewItem = NSMenuItem()

package/src/home/home-routes.ts

@@ -17,6 +17,8 @@ import { Hubs, type WorkerView } from './hubs.ts'
 import type { Planner, PlanRow } from '../plan/planner.ts'
 import type { Widgets, WidgetView } from './widgets.ts'
 import { ActivityCache, repoActivity, windowMinutes } from './activity.ts'
+import { devRepos, InsightsCache, type Scope } from './insights.ts'
+import { GLOBAL_CONTEXT_EVERY_MS, houseContext, writeIfChanged } from './global-context.ts'
 import { HouseRuns } from '../serve/house-runs.ts'
 
 /** how far back a repo's git page lists its commits */
@@ -111,6 +113,8 @@ export function homeRoutes(d: HomeDeps) {
     const modernizing = new Map<string, ModernizeView & { log: string }>()
     // read only while the activity page asks, never on the tick
     const activity = new ActivityCache({ declared: (name) => d.plan?.declared(name) ?? null, titles: (name) => d.plan?.titles(name) ?? null })
+    // read only while the insights page asks, one answer per scope
+    const insights = new InsightsCache()
     const modernizeLog = (repo: string): string => join(d.dir, 'modernize', `${repo}.log`)
     // the dock: every loaded repo's recent runs, read only while a page asks
     const house = new HouseRuns(() => repos)
@@ -123,6 +127,7 @@ export function homeRoutes(d: HomeDeps) {
     }
 
     let active = new Set<string>()
+    let contextAt = -Infinity
     if (d.plan != null) d.plan.active = (name) => active.has(name)
 
     async function tick(): Promise<void> {
@@ -130,6 +135,14 @@ export function homeRoutes(d: HomeDeps) {
         active = activeSet(rows, d.state.data.active, rows.find((r) => r.path === d.root)?.name ?? d.name)
         // the plan's clock: one look per tick, and it starts at most one batch
         d.plan?.tick()
+        // the house's generated context: rewritten only when a source moved,
+        // and never held on
+        if (Date.now() - contextAt >= GLOBAL_CONTEXT_EVERY_MS) {
+            contextAt = Date.now()
+            void houseContext(d.root)
+                .then((c) => { if (c != null && writeIfChanged(c.path, c.text)) console.log(`ok: wrote ${c.path}`) })
+                .catch((e) => console.error(`WARN the global context could not be written: ${(e as Error).message}`))
+        }
         // a widget render never holds the tick back
         void d.widgets?.tick(repos.map((r) => ({ name: r.name, path: r.path }))).catch((e) => console.error(`WARN the widgets broke: ${(e as Error).message}`))
         await d.hubs.tick(active)
@@ -176,6 +189,12 @@ export function homeRoutes(d: HomeDeps) {
             const q = new URL(req.url).searchParams
             return Response.json(await activity.get(repos, windowMinutes(q.get('m')), { fresh: q.get('fresh') === '1' }))
         }
+        if (path === '/api/home/insights.json') {
+            if (repos.length === 0) await refresh()
+            const q = new URL(req.url).searchParams
+            const scope: Scope = q.get('scope') === 'dev' ? 'dev' : 'house'
+            return Response.json(await insights.get(scope, () => (scope === 'dev' ? devRepos() : repos), { fresh: q.get('fresh') === '1' }))
+        }
         // one repo's git for its git page: a week of commits, and HEAD's last
         // one past that, whatever window the activity page shows
         if (path === '/api/home/git.json') {
@@ -209,6 +228,12 @@ export function homeRoutes(d: HomeDeps) {
             if (b.act === 'restart') return Response.json(await d.hubs.restart(r))
             return new Response(`act must be ensure, stop or restart`, { status: 400 })
         }
+        if (path === '/api/home/widgets/refresh') {
+            const b = await body(req)
+            const v = await d.widgets?.refresh(String(b.repo), String(b.id))
+            if (v == null) return new Response(`no widget ${String(b.id)} in ${String(b.repo)}`, { status: 404 })
+            return Response.json(v)
+        }
         if (path === '/api/home/planned/run') {
             const b = await body(req)
             if (d.plan == null || !d.plan.ask(String(b.repo), String(b.check))) return new Response(`no planned check ${String(b.check)} in ${String(b.repo)}`, { status: 404 })

package/src/home/insights-shape.ts

@@ -0,0 +1,124 @@
+// the insights page's boxes, computed from every package.json a scope of repos
+// tracks. Pure: no disk, so the page, `sk insights` and the tests share it.
+// Every box has one shape (a row per key, the repos using it, one value per
+// use), so a new box is one function in BOXES and the page draws it unchanged.
+
+/** one package.json, read: its repo, its dir inside the repo ('' at the root) */
+export type Manifest = {
+    repo: string
+    where: string
+    json: { dependencies?: Record<string, string>; devDependencies?: Record<string, string>; peerDependencies?: Record<string, string>; scripts?: Record<string, string> }
+}
+
+/** one package.json using the row's key, and what it says for it */
+export type InsightUse = { repo: string; where: string; value: string; dev?: boolean }
+
+export type InsightRow = {
+    key: string
+    /** distinct repos using it: the sort */
+    repos: number
+    /** its distinct values, most used first (the version ranges of a package) */
+    values: string[]
+    uses: InsightUse[]
+}
+
+export type InsightBox = {
+    id: string
+    title: string
+    tags: string[]
+    /** one line on what it lists and how it sorts */
+    hint: string
+    /** what a row's key is, for the filter's placeholder */
+    noun: string
+    /** the filter reads the values too (a script's command), not only the key */
+    searchValues?: boolean
+    rows: InsightRow[]
+}
+
+export const SCOPES = ['house', 'dev'] as const
+export type Scope = (typeof SCOPES)[number]
+
+export type InsightsAnswer = {
+    now: number
+    scope: Scope
+    /** repos read, and package.json files found in them */
+    repos: number
+    files: number
+    boxes: InsightBox[]
+    /** a manifest that would not parse, as `repo/where: why` */
+    errors: string[]
+    ms: number
+}
+
+const byCount = <T>(xs: T[]): T[] => {
+    const n = new Map<T, number>()
+    for (const x of xs) n.set(x, (n.get(x) ?? 0) + 1)
+    return [...n.keys()].sort((a, b) => n.get(b)! - n.get(a)!)
+}
+
+/** one row per key, the uses gathered, sorted by distinct repos then key */
+function rowsOf(uses: [string, InsightUse][]): InsightRow[] {
+    const by = new Map<string, InsightUse[]>()
+    for (const [k, u] of uses) {
+        if (!by.has(k)) by.set(k, [])
+        by.get(k)!.push(u)
+    }
+    return [...by]
+        .map(([key, us]) => ({ key, repos: new Set(us.map((u) => u.repo)).size, values: byCount(us.map((u) => u.value)), uses: us.sort((a, b) => a.repo.localeCompare(b.repo) || a.where.localeCompare(b.where)) }))
+        .sort((a, b) => b.repos - a.repos || a.key.localeCompare(b.key))
+}
+
+/** a range that names no published version: a workspace or local link */
+export const localRange = (v: string): boolean => /^(workspace:|file:|link:|portal:)/.test(v)
+
+function depUses(ms: Manifest[]): [string, InsightUse][] {
+    return ms.flatMap((m) => [
+        ...Object.entries(m.json.dependencies ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v }]),
+        ...Object.entries(m.json.devDependencies ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v, dev: true }]),
+    ])
+}
+
+export const BOXES: ((ms: Manifest[]) => InsightBox)[] = [
+    (ms) => ({
+        id: 'deps',
+        title: 'dependency usage',
+        tags: ['deps'],
+        hint: 'every package in a dependencies or devDependencies, by how many repos use it',
+        noun: 'package',
+        rows: rowsOf(depUses(ms)),
+    }),
+    (ms) => ({
+        id: 'drift',
+        title: 'version drift',
+        tags: ['deps', 'health'],
+        hint: 'packages asked at more than one version range across repos, by how many ranges',
+        noun: 'package',
+        rows: rowsOf(depUses(ms).filter(([, u]) => !localRange(u.value)))
+            .filter((r) => r.values.length > 1)
+            .sort((a, b) => b.values.length - a.values.length || b.repos - a.repos || a.key.localeCompare(b.key)),
+    }),
+    (ms) => ({
+        id: 'scripts',
+        title: 'script names',
+        tags: ['scripts'],
+        hint: 'every package.json script name, by how many repos declare it, each with its command',
+        noun: 'script',
+        searchValues: true,
+        rows: rowsOf(ms.flatMap((m) => Object.entries(m.json.scripts ?? {}).map(([k, v]): [string, InsightUse] => [k, { repo: m.repo, where: m.where, value: v }]))),
+    }),
+]
+
+/** a row matches a query on its key, or on a value when its box searches them */
+export const rowMatches = (b: InsightBox, r: InsightRow, q: string): boolean => {
+    const s = q.trim().toLowerCase()
+    return s === '' || r.key.toLowerCase().includes(s) || (b.searchValues === true && r.values.some((v) => v.toLowerCase().includes(s)))
+}
+
+/** every box over these manifests */
+export const boxesOf = (ms: Manifest[]): InsightBox[] => BOXES.map((b) => b(ms))
+
+/** every tag the boxes carry, in first seen order */
+export const tagsOf = (boxes: InsightBox[]): string[] => [...new Set(boxes.flatMap((b) => b.tags))]
+
+/** a use's place, as the page and the cli print it */
+export const placeWords = (u: InsightUse): string => (u.where === '' ? u.repo : `${u.repo}/${u.where}`)

package/src/home/insights.ts

@@ -0,0 +1,90 @@
+// the insights page's data: every package.json a scope of repos tracks, read
+// and turned into boxes (insights-shape.ts). Two scopes: the house repos, or
+// every folder of ~/dev with a package.json or a .git, so a package used in an
+// unwired repo can still be found and reused.
+//
+// the one constraint a reader breaks first: this runs only when the page or
+// `sk insights` asks (no tick), and an answer is kept per scope for
+// INSIGHTS_TTL_MS, so a page left open never walks ~/dev twice a minute.
+import { existsSync, readdirSync, readFileSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import { gitBin } from '../core/git-bin.ts'
+import { boxesOf, type InsightsAnswer, type Manifest, type Scope } from './insights-shape.ts'
+
+export * from './insights-shape.ts'
+
+export const INSIGHTS_TTL_MS = 5 * 60_000
+export const INSIGHTS_CONCURRENCY = 12
+
+export type InsightRepo = { name: string; path: string }
+
+/** every folder of ~/dev that holds a package.json or a .git, by name */
+export function devRepos(userHome: string = homedir()): InsightRepo[] {
+    const root = join(userHome, 'dev')
+    let names: string[] = []
+    try {
+        names = readdirSync(root, { withFileTypes: true }).filter((e) => e.isDirectory() && !e.name.startsWith('.')).map((e) => e.name)
+    } catch {
+        return []
+    }
+    return names
+        .map((name) => ({ name, path: join(root, name) }))
+        .filter((r) => existsSync(join(r.path, 'package.json')) || existsSync(join(r.path, '.git')))
+        .sort((a, b) => a.name.localeCompare(b.name))
+}
+
+/** the package.json paths a repo tracks; the root one alone outside git */
+async function manifestPaths(dir: string): Promise<string[]> {
+    if (!existsSync(join(dir, '.git'))) return existsSync(join(dir, 'package.json')) ? ['package.json'] : []
+    const p = Bun.spawn([gitBin(), 'ls-files', '-z', '--', 'package.json', '**/package.json'], { cwd: dir, stdout: 'pipe', stderr: 'ignore', env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' } })
+    const [out, code] = await Promise.all([new Response(p.stdout).text(), p.exited])
+    if (code !== 0) return existsSync(join(dir, 'package.json')) ? ['package.json'] : []
+    return out.split('\0').filter(Boolean)
+}
+
+/** one repo's manifests, read; a file that does not parse is an error line */
+export async function repoManifests(r: InsightRepo): Promise<{ manifests: Manifest[]; errors: string[] }> {
+    const manifests: Manifest[] = []
+    const errors: string[] = []
+    for (const rel of await manifestPaths(r.path)) {
+        const where = rel === 'package.json' ? '' : rel.slice(0, -'/package.json'.length)
+        try {
+            manifests.push({ repo: r.name, where, json: JSON.parse(readFileSync(join(r.path, rel), 'utf8')) })
+        } catch (e) {
+            // a deleted but still tracked file is no error, only nothing to read
+            if ((e as NodeJS.ErrnoException).code !== 'ENOENT') errors.push(`${r.name}/${rel}: ${(e as Error).message}`)
+        }
+    }
+    return { manifests, errors }
+}
+
+/** THE computation: the daemon's route and `sk insights` both call it */
+export async function insightsOf(repos: InsightRepo[], scope: Scope, now = Date.now()): Promise<InsightsAnswer> {
+    const t0 = performance.now()
+    const all: { manifests: Manifest[]; errors: string[] }[] = []
+    for (let i = 0; i < repos.length; i += INSIGHTS_CONCURRENCY) all.push(...(await Promise.all(repos.slice(i, i + INSIGHTS_CONCURRENCY).map(repoManifests))))
+    const manifests = all.flatMap((a) => a.manifests)
+    return { now, scope, repos: repos.length, files: manifests.length, boxes: boxesOf(manifests), errors: all.flatMap((a) => a.errors), ms: Math.round(performance.now() - t0) }
+}
+
+/** one answer per scope, shared for INSIGHTS_TTL_MS; `fresh` always reads */
+export class InsightsCache {
+    private kept = new Map<Scope, InsightsAnswer>()
+    private running = new Map<Scope, Promise<InsightsAnswer>>()
+
+    constructor(private o: { ttlMs?: number; now?: () => number } = {}) {}
+
+    get(scope: Scope, repos: () => InsightRepo[], o: { fresh?: boolean } = {}): Promise<InsightsAnswer> {
+        const now = (this.o.now ?? Date.now)()
+        const k = this.kept.get(scope)
+        if (k != null && o.fresh !== true && now - k.now < (this.o.ttlMs ?? INSIGHTS_TTL_MS)) return Promise.resolve(k)
+        const going = this.running.get(scope)
+        if (going != null) return going
+        const p = insightsOf(repos(), scope, now)
+            .then((a) => { this.kept.set(scope, a); return a })
+            .finally(() => this.running.delete(scope))
+        this.running.set(scope, p)
+        return p
+    }
+}

package/src/home/serve-web.ts

@@ -14,7 +14,7 @@ import { hubBase } from './home-paths.ts'
 /** the page routes: ONE app for the overview, the plan, and the hub page of
  *  each known repo, which moves between them in place (home-st.ts) */
 export function pageRoutes<T>(names: string[], page: T): Record<string, T> {
-    const out: Record<string, T> = { '/': page, '/planned': page, '/activity': page, '/archived': page }
+    const out: Record<string, T> = { '/': page, '/planned': page, '/activity': page, '/archived': page, '/insights': page }
     for (const n of names) out[`${hubBase(n)}/`] = page
     return out
 }
@@ -51,8 +51,8 @@ export const REPO_ANSWER_MS = 30_000
 export const LIST_EVERY_MS = 30_000
 export const LIST_RETRY_MS = 1_000
 
-/** the home answers that can wait on git: the activity page's first read of a window, and a repo's git page */
-export const readsGit = (path: string): boolean => path === '/api/home/activity.json' || path === '/api/home/git.json'
+/** the home answers that can wait on git: the activity page's first read of a window, a repo's git page, and the insights page's read of every manifest */
+export const readsGit = (path: string): boolean => path === '/api/home/activity.json' || path === '/api/home/git.json' || path === '/api/home/insights.json'
 
 /** a run or a check run streams for minutes, and a silent one is never cut */
 export const streams = (path: string): boolean => /\/api\/(run|check\/run)$/.test(path)

package/src/home/widgets.ts

@@ -104,12 +104,12 @@ export class Widgets {
     }
 
     /** one render, bounded, its result or its error kept */
-    async render(s: Slot): Promise<void> {
+    async render(s: Slot, force = false): Promise<void> {
         s.busy = true
         let timer: ReturnType<typeof setTimeout> | undefined
         try {
             const html = await Promise.race([
-                Promise.resolve().then(() => s.w.def.render()),
+                Promise.resolve().then(() => s.w.def.render({ force })),
                 new Promise<never>((_, no) => { timer = setTimeout(() => no(new Error(`render took more than ${WIDGET_RENDER_MS / 1000}s`)), WIDGET_RENDER_MS) }),
             ])
             if (typeof html !== 'string') throw new Error(`render returned ${typeof html}, not an html string`)
@@ -123,6 +123,16 @@ export class Widgets {
         }
     }
 
+    /** a reader's refresh: one widget rendered now with force, its view after
+     *  it; null when no widget has that repo and id */
+    async refresh(repo: string, id: string): Promise<WidgetView | null> {
+        const s = this.slots.get(`${repo}/${id}`)
+        if (s == null) return null
+        this.readAt = this.now()
+        await this.render(s, true)
+        return s.view
+    }
+
     /** the last html of each; a read that keeps the clocks running */
     views(): WidgetView[] {
         this.readAt = this.now()

package/src/serve/hub-app/home-st.ts

@@ -18,6 +18,7 @@ import { DockSt } from './dock-st.ts'
 import { PaletteSt } from './palette-st.ts'
 import { PlannedSt } from './planned-st.ts'
 import { ActivitySt } from './activity-st.ts'
+import { InsightsSt } from './insights-st.ts'
 import { ProjectsSvc } from './projects-svc.ts'
 import { parseFilter, RepoSt } from './repo-st.ts'
 import { openSection, repoSections, sectionOfRepo } from './repo-sections.ts'
@@ -25,11 +26,11 @@ import { openSection, repoSections, sectionOfRepo } from './repo-sections.ts'
 /** the longest one repo's read ahead holds the next one back */
 export const PREFETCH_WAIT_MS = 10_000
 
-/** what the page shows: the machine overview, the plan, the activity, or one repo */
-export type Page = 'overview' | 'planned' | 'activity' | 'archived' | 'repo'
+/** what the page shows: the machine overview, the plan, the activity, the insights, the archived repos, or one repo */
+export type Page = 'overview' | 'planned' | 'activity' | 'insights' | 'archived' | 'repo'
 
 /** the address of each page of the home that is no repo's */
-export const PLACE_PATH = { overview: '/', planned: '/planned', activity: '/activity', archived: '/archived' } as const
+export const PLACE_PATH = { overview: '/', planned: '/planned', activity: '/activity', insights: '/insights', archived: '/archived' } as const
 
 /** where a repo's hub answers on the home */
 export const repoBase = (name: string): string => `/r/${encodeURIComponent(name)}`
@@ -46,6 +47,7 @@ export function routeOf(pathname: string): { page: Page; repo: string | null } {
     if (m != null) return { page: 'repo', repo: decodeURIComponent(m[1]!) }
     if (/^\/planned\/?$/.test(pathname)) return { page: 'planned', repo: null }
     if (/^\/activity\/?$/.test(pathname)) return { page: 'activity', repo: null }
+    if (/^\/insights\/?$/.test(pathname)) return { page: 'insights', repo: null }
     if (/^\/archived\/?$/.test(pathname)) return { page: 'archived', repo: null }
     return { page: 'overview', repo: null }
 }
@@ -69,6 +71,7 @@ export class HomeSt {
     planned: PlannedSt
     /** what every repo committed and holds, polled while it is the page */
     activity: ActivitySt
+    insights: InsightsSt
     /** the one picker, cmd+j */
     palette: PaletteSt
     /** the widths of the project list and a repo's sidebar */
@@ -91,12 +94,13 @@ export class HomeSt {
         this.projects = new ProjectsSvc()
         this.planned = new PlannedSt(this)
         this.activity = new ActivitySt(this)
+        this.insights = new InsightsSt(this)
         this.palette = new PaletteSt(this)
         this.layout = new LayoutSt()
         this.dock = new DockSt(this)
         this.machine = o.home ? new MachineSt(this, o) : null
         this.page = o.home ? 'overview' : 'repo'
-        makeAutoObservable<this, 'disposers' | 'onUrl' | 'prefetching'>(this, { machine: false, projects: false, planned: false, activity: false, palette: false, layout: false, dock: false, repos: observableShallow, disposers: false, onUrl: false, prefetching: false })
+        makeAutoObservable<this, 'disposers' | 'onUrl' | 'prefetching'>(this, { machine: false, projects: false, planned: false, activity: false, insights: false, palette: false, layout: false, dock: false, repos: observableShallow, disposers: false, onUrl: false, prefetching: false })
         const m = this.machine
         if (m != null) {
             this.projects.onSelect = (name) => this.select(name)
@@ -129,6 +133,7 @@ export class HomeSt {
         if (this.page === 'overview') return 'home'
         if (this.page === 'planned') return 'planned'
         if (this.page === 'activity') return 'activity'
+        if (this.page === 'insights') return 'insights'
         if (this.page === 'archived') return 'archived'
         const r = this.shown
         return r == null || r.name === '' ? 'hub' : `${r.name} · hub`
@@ -222,6 +227,7 @@ export class HomeSt {
      *  everything; the one shown resumes once its hub answers */
     private show(page: Page, repo: string | null, how: 'push' | 'replace' | 'none'): void {
         const prev = this.shown
+        const prevPage = this.page
         const next = page === 'repo' && repo != null ? this.repo(repo) : null
         // the page already shown is never a second history entry
         if (how === 'push' && page === this.page && next === prev && page !== 'planned') how = 'none'
@@ -234,12 +240,13 @@ export class HomeSt {
         this.projects.away = next == null
         this.projects.place = page === 'repo' || page === 'archived' ? null : page
         if (how !== 'none') {
-            const to = next != null ? `${repoPage(next.key)}${next.search}${next.hash}` : page === 'planned' ? this.planned.address : page === 'activity' || page === 'archived' ? PLACE_PATH[page] : '/'
+            const to = next != null ? `${repoPage(next.key)}${next.search}${next.hash}` : page === 'planned' ? this.planned.address : page === 'activity' || page === 'insights' || page === 'archived' ? PLACE_PATH[page] : '/'
             if (how === 'push') history.pushState(null, '', to)
             else history.replaceState(null, '', to)
         }
         if (page === 'planned') this.planned.start()
         else this.planned.stop()
+        if (page === 'insights' && prevPage !== 'insights') this.insights.start()
         if (page === 'activity') this.activity.start()
         else this.activity.stop()
         if (next != null && next !== prev && this.machine?.data != null) void this.machine.hub(next.key, 'ensure')