rvlib-shipkit 1.8.0 → 2.0.0

package/src/serve/hub-app/prose-hits-st.ts

@@ -1,125 +0,0 @@
-// The SK014 page's own state: the hits the server grouped, the filters over
-// them, and the word list form. Component scoped (it lives while the page is
-// open), and every write goes through the ONE config writer the run when
-// switch uses (checks-svc.ts writeGate), so a word list edit is refused for
-// the same reasons a switch is.
-import { makeAutoObservable, observableRef, runInAction } from 'mobx'
-import type { ProseGroup, ProseView } from '../../prose/prose-view.ts'
-import type { RepoSt } from './repo-st.ts'
-import { ownTrouble, reach } from './reach.ts'
-
-export type TierFilter = 'all' | 'blocking' | 'soft'
-export type ListKind = 'allow' | 'ban'
-
-/** how many groups the page draws before a "show every word" button */
-export const GROUP_CAP = 40
-/** how many hits one open group draws before its own "show all" */
-export const HIT_CAP = 60
-
-export class ProseHitsSt {
-    view: ProseView | null = null
-    error = ''
-    loading = false
-    word = ''
-    file = ''
-    tier: TierFilter = 'all'
-    allGroups = false
-    /** group keys the reader opened */
-    open = new Set<string>()
-    /** group keys whose every hit is drawn */
-    full = new Set<string>()
-    form: { kind: ListKind; word: string; to: string; reason: string } = { kind: 'allow', word: '', to: '', reason: '' }
-
-    constructor(private st: RepoSt) {
-        // .ref: the view is swapped whole on every load, never edited in place
-        makeAutoObservable<this, 'st'>(this, { st: false, view: observableRef })
-    }
-
-    async load(): Promise<void> {
-        runInAction(() => { this.loading = true })
-        try {
-            const r = await reach(this.st.url('/api/prose.json'))
-            if (!r.ok) throw new Error(await r.text())
-            const v = (await r.json()) as ProseView
-            runInAction(() => { this.view = v; this.error = '' })
-        } catch (e) {
-            runInAction(() => { this.error = ownTrouble(e, this.st.home.machine, (m) => `the hits could not be read: ${m}`) })
-        }
-        runInAction(() => { this.loading = false })
-    }
-
-    setWord(v: string): void { this.word = v }
-    setFile(v: string): void { this.file = v }
-    setTier(v: TierFilter): void { this.tier = v }
-    showAllGroups(): void { this.allGroups = true }
-    toggle(key: string): void {
-        if (this.open.has(key)) this.open.delete(key)
-        else this.open.add(key)
-    }
-    showAllHits(key: string): void { this.full.add(key) }
-    setForm<K extends keyof ProseHitsSt['form']>(k: K, v: ProseHitsSt['form'][K]): void {
-        this.form = { ...this.form, [k]: v }
-    }
-
-    /** the groups under the filters, each recounted over the hits it keeps,
-     *  so a file filter reorders the words by their noise IN that file */
-    get groups(): ProseGroup[] {
-        const v = this.view
-        if (v == null) return []
-        const w = this.word.trim().toLowerCase()
-        const f = this.file.trim().toLowerCase()
-        const out: ProseGroup[] = []
-        for (const g of v.groups) {
-            if (this.tier === 'blocking' && g.tier === 'soft') continue
-            if (this.tier === 'soft' && g.tier !== 'soft') continue
-            if (w !== '' && !(g.word ?? g.cls).includes(w) && !g.cls.includes(w)) continue
-            const hits = f === '' ? g.hits : g.hits.filter((h) => h.file.toLowerCase().includes(f))
-            if (hits.length === 0) continue
-            out.push(hits === g.hits ? g : { ...g, hits, count: hits.length })
-        }
-        return out.sort((a, b) => b.count - a.count || a.key.localeCompare(b.key))
-    }
-
-    get shownCount(): number {
-        return this.groups.reduce((n, g) => n + g.count, 0)
-    }
-
-    /** every file that carries a hit, for the file filter's suggestions */
-    get files(): string[] {
-        const s = new Set<string>()
-        for (const g of this.view?.groups ?? []) for (const h of g.hits) s.add(h.file)
-        return [...s].sort()
-    }
-
-    get busy(): boolean { return this.st.checks.gateBusy }
-
-    /** after any write: the config moved, so the hits are re-read and the
-     *  rule reruns, and its row recolours on the tree like any other run */
-    private async after(ok: boolean): Promise<void> {
-        if (!ok) return
-        await this.load()
-        void this.st.checks.run(['SK014'])
-    }
-
-    async allow(word: string, reason = ''): Promise<void> {
-        const ok = await this.st.checks.writeGate({ words: { allow: [{ word, reason }] } }, `'${word}' is allowed in this repo — repo.config.ts is edited and waiting for your commit`)
-        await this.after(ok)
-    }
-
-    async submit(): Promise<void> {
-        const f = this.form
-        if (f.word.trim() === '') return
-        const entry = f.kind === 'allow' ? { allow: [{ word: f.word, reason: f.reason }] } : { ban: [{ word: f.word, to: f.to, reason: f.reason }] }
-        const said = f.kind === 'allow'
-            ? `'${f.word.trim()}' is allowed in this repo — repo.config.ts is edited and waiting for your commit`
-            : `'${f.word.trim()}' is refused in this repo — repo.config.ts is edited and waiting for your commit`
-        const ok = await this.st.checks.writeGate({ words: entry }, said)
-        if (ok) runInAction(() => { this.form = { kind: this.form.kind, word: '', to: '', reason: '' } })
-        await this.after(ok)
-    }
-
-    async remove(word: string): Promise<void> {
-        const ok = await this.st.checks.writeGate({ words: { remove: [word] } }, `'${word}' is back to the house dictionary — repo.config.ts is edited and waiting for your commit`)
-        await this.after(ok)
-    }
-}

package/src/serve/hub-app/prose-hits-view.tsx

@@ -1,176 +0,0 @@
-// THE SK014 PAGE's own sections: what the prose check found, grouped by word
-// with the noisiest on top, each hit a file:line link into the editor and the
-// sentence around it with the word marked; then the repo's own word lists,
-// editable in place. The house dictionary stays the default, a list entry
-// overrides it for this repo only.
-import { observer } from 'mobx-react-lite'
-import { useEffect, useMemo } from 'react'
-import type { ProseGroup, ProseViewHit } from '../../prose/prose-view.ts'
-import type { ProseWords } from '../../prose/ste.ts'
-import { editorHref } from './check-words.ts'
-import { Help } from './help.tsx'
-import type { RepoSt } from './repo-st.ts'
-import { GROUP_CAP, HIT_CAP, ProseHitsSt, type ListKind, type TierFilter } from './prose-hits-st.ts'
-
-/** blocking tiers read red, the soft tier reads as a warning */
-const TIER_WORD: Record<string, { word: string; tone: string }> = {
-    fix: { word: 'blocks, --fix rewrites it', tone: 'red' },
-    hard: { word: 'blocks', tone: 'red' },
-    soft: { word: 'soft', tone: 'warn' },
-}
-
-const TIERS: { v: TierFilter; label: string }[] = [
-    { v: 'all', label: 'every hit' },
-    { v: 'blocking', label: 'what blocks' },
-    { v: 'soft', label: 'soft only' },
-]
-
-/** the sentence around a hit, the hit itself marked */
-const Excerpt = ({ h }: { h: ProseViewHit }) => (
-    <span className="pexc">
-        {h.excerpt.slice(0, h.mark[0])}
-        <mark>{h.excerpt.slice(h.mark[0], h.mark[1])}</mark>
-        {h.excerpt.slice(h.mark[1])}
-    </span>
-)
-
-const HitLine = ({ root, h, shape }: { root: string; h: ProseViewHit; shape: boolean }) => {
-    const href = editorHref(root, h.file)
-    const at = `${h.file}:${h.line}`
-    return (
-        <div className="phit">
-            {href == null ? <code className="cpath">{at}</code> : <a href={`${href}:${h.line}`} title="open it in the editor"><code className="cpath">{at}</code></a>}
-            <Excerpt h={h} />
-            {/* a shape's reason names its own numbers (31 words, 8 sentences) */}
-            {shape ? <span className="dim pwhy">{h.why}</span> : null}
-        </div>
-    )
-}
-
-const Group = observer(({ app, s, g }: { app: RepoSt; s: ProseHitsSt; g: ProseGroup }) => {
-    const open = s.open.has(g.key)
-    const t = TIER_WORD[g.tier] ?? { word: g.tier, tone: '' }
-    const shown = s.full.has(g.key) ? g.hits : g.hits.slice(0, HIT_CAP)
-    return (
-        <div className="pgroup">
-            <div className="phead">
-                <button className="ptoggle" onClick={() => s.toggle(g.key)} title={open ? 'hide the hits' : 'show the hits'}>{open ? '▾' : '▸'}</button>
-                <span className="pcount dnum">{g.count}</span>
-                <b className="pword">{g.word ?? g.cls}</b>
-                <span className="stchip">{g.cls}</span>
-                <span className={`tl ${t.tone}`}>{t.word}</span>
-                <span className="dim pwhy">{g.word == null ? null : g.hits[0]?.why}</span>
-                <span className="sp" />
-                {g.word == null
-                    ? null
-                    : <button disabled={s.busy} title="accept this word in this repo: every hit on it goes away" onClick={() => void s.allow(g.word!)}>allow it here</button>}
-            </div>
-            {open
-                ? <div className="phits">
-                    {shown.map((h, n) => <HitLine key={`${h.file}:${h.line}:${n}`} root={app.root} h={h} shape={g.word == null} />)}
-                    {shown.length < g.hits.length
-                        ? <button className="pmore" onClick={() => s.showAllHits(g.key)}>show the other {g.hits.length - shown.length}</button>
-                        : null}
-                </div>
-                : null}
-        </div>
-    )
-})
-
-const Hits = observer(({ app, s }: { app: RepoSt; s: ProseHitsSt }) => {
-    const v = s.view
-    if (v == null) return <div className="dim">{s.error !== '' ? s.error : 'reading the hits…'}</div>
-    if (!v.scoped) return <div className="dim">this repo declares no prose scope, so the check reads no file: add `prose: {'{'} include: [...] {'}'}` to repo.config.ts</div>
-    const groups = s.groups
-    const drawn = s.allGroups ? groups : groups.slice(0, GROUP_CAP)
-    const blocking = v.byTier.fix + v.byTier.hard
-    return (
-        <>
-            <div className="wline">
-                {v.total} hit(s) in {v.files} file(s): <span className={blocking > 0 ? 'tl red' : 'dim'}>{blocking} block</span>, <span className="tl warn">{v.byTier.soft} soft</span>
-                {s.loading ? <span className="dim"> (reading again…)</span> : null}
-            </div>
-            <div className="pfilters">
-                <input placeholder="filter by word or rule" value={s.word} onChange={(e) => s.setWord(e.target.value)} />
-                <input placeholder="filter by file" list="prose-files" value={s.file} onChange={(e) => s.setFile(e.target.value)} />
-                <datalist id="prose-files">{s.files.map((f) => <option key={f} value={f} />)}</datalist>
-                <select className="wsel" value={s.tier} onChange={(e) => s.setTier(e.target.value as TierFilter)}>
-                    {TIERS.map((t) => <option key={t.v} value={t.v}>{t.label}</option>)}
-                </select>
-                {s.word !== '' || s.file !== '' || s.tier !== 'all' ? <span className="dim">{s.shownCount} shown</span> : null}
-            </div>
-            {groups.length === 0 ? <div className="dim">no hit matches the filters</div> : null}
-            {drawn.map((g) => <Group key={g.key} app={app} s={s} g={g} />)}
-            {drawn.length < groups.length
-                ? <button className="pmore" onClick={() => s.showAllGroups()}>show the other {groups.length - drawn.length} words and rules</button>
-                : null}
-        </>
-    )
-})
-
-const ListRows = ({ s, words }: { s: ProseHitsSt; words: ProseWords }) => {
-    const rows = [
-        ...(words.allow ?? []).map((a) => ({ kind: 'allow' as ListKind, word: a.word, to: undefined as string | undefined, reason: a.reason })),
-        ...(words.ban ?? []).map((b) => ({ kind: 'ban' as ListKind, word: b.word, to: b.to, reason: b.reason })),
-    ]
-    if (rows.length === 0) return <div className="dim">no entry: the house dictionary decides every word here</div>
-    return (
-        <div className="plist">
-            {rows.map((r) => (
-                <div key={`${r.kind}:${r.word}`} className="prow">
-                    <span className={`stchip ${r.kind === 'allow' ? 'ok' : 'miss'}`}>{r.kind}</span>
-                    <b>{r.word}</b>
-                    {r.to == null || r.to === '' ? null : <span>→ {r.to}</span>}
-                    {r.reason == null || r.reason === '' ? null : <span className="dim">{r.reason}</span>}
-                    <span className="sp" />
-                    <button disabled={s.busy} onClick={() => void s.remove(r.word)}>drop it</button>
-                </div>
-            ))}
-        </div>
-    )
-}
-
-const Lists = observer(({ app, s }: { app: RepoSt; s: ProseHitsSt }) => {
-    const f = s.form
-    const g = app.checks.gate
-    return (
-        <>
-            <ListRows s={s} words={s.view?.words ?? {}} />
-            <div className="pform">
-                <select className="wsel" value={f.kind} onChange={(e) => s.setForm('kind', e.target.value as ListKind)}>
-                    <option value="allow">allow</option>
-                    <option value="ban">ban</option>
-                </select>
-                <input placeholder={f.kind === 'allow' ? 'word or phrase this repo accepts' : 'word or phrase this repo refuses'} value={f.word} onChange={(e) => s.setForm('word', e.target.value)} />
-                {f.kind === 'ban' ? <input placeholder="write this instead" value={f.to} onChange={(e) => s.setForm('to', e.target.value)} /> : null}
-                <input placeholder="why (optional, it rides in the config)" value={f.reason} onChange={(e) => s.setForm('reason', e.target.value)} />
-                <button disabled={s.busy || f.word.trim() === ''} onClick={() => void s.submit()}>{f.kind === 'allow' ? 'allow it' : 'ban it'}</button>
-            </div>
-            {g?.wordsState === 'stale' ? <div className="warnline">the words block in {g.path} was hand edited: reconcile it, then the lists work again</div> : null}
-            {g != null && g.dirty ? <div className="note">{g.path} is edited and not committed, review it in your git client</div> : null}
-            {app.checks.gateNote === '' ? null : <div className="note">{app.checks.gateNote}</div>}
-        </>
-    )
-})
-
-/** the two sections over one state, the part a test renders headless */
-export const ProseSections = observer(({ app, s }: { app: RepoSt; s: ProseHitsSt }) => (
-    <>
-        <section className="csec">
-            <div className="cstitle">hits<Help text="every hit of the last read, grouped by the word or the rule that fired, the noisiest first. A file:line opens the editor on that line" /></div>
-            <Hits app={app} s={s} />
-        </section>
-        <section className="csec">
-            <div className="cstitle">this repo's words<Help text="allow drops every hit on a word or phrase, ban refuses an extra one and names what to write instead. The house dictionary stays the default. An edit writes repo.config.ts, reruns the check and leaves the file for you to commit" /></div>
-            <Lists app={app} s={s} />
-        </section>
-    </>
-))
-
-/** mounted by the check page for SK014 only: the state lives while the page
- *  is open, and reads the hits once on the way in */
-export const ProseHits = observer(({ app }: { app: RepoSt }) => {
-    const s = useMemo(() => new ProseHitsSt(app), [app])
-    useEffect(() => { void s.load() }, [s])
-    return <ProseSections app={app} s={s} />
-})

package/src/serve/hub-app/prose-hits.css

@@ -1,21 +0,0 @@
-/* the SK014 page: word groups, their hits, the repo's word lists (prose-hits-view.tsx) */
-.pfilters{display:flex;flex-wrap:wrap;gap:var(--s2);align-items:center;margin-bottom:var(--s2)}
-.pfilters input,.pform input{background:var(--bg);border:1px solid var(--line);border-radius:4px;color:var(--ink);
- padding:var(--s1) var(--s2);font:inherit;font-size:12.5px}
-.pfilters input:focus,.pform input:focus{border-color:var(--accent);outline:none}
-.pgroup{border-top:1px solid var(--line)}
-.phead{display:flex;gap:var(--s2);align-items:baseline;padding:var(--s1) 0;min-width:0}
-.phead .sp,.prow .sp{flex:1}
-.phead .pwhy{overflow:hidden;text-overflow:ellipsis;white-space:nowrap;min-width:0}
-.ptoggle{background:none;border:0;color:var(--dim);cursor:pointer;padding:0;font:inherit}
-.pcount{min-width:3.5em;text-align:right}
-.pword{font-weight:500}
-.phits{padding:0 0 var(--s2) var(--s4)}
-.phit{display:flex;flex-wrap:wrap;gap:var(--s2);align-items:baseline;padding:var(--s0) 0;font-size:12.5px}
-.phit a{text-decoration:none}
-.pexc{color:var(--dim);word-break:break-word}
-.pexc mark{background:var(--hi2);color:var(--ink);border-bottom:1px solid var(--red);padding:0 var(--s0)}
-.pmore{margin:var(--s1) 0}
-.plist{display:flex;flex-direction:column;gap:var(--s1);margin-bottom:var(--s2)}
-.prow{display:flex;gap:var(--s2);align-items:baseline}
-.pform{display:flex;flex-wrap:wrap;gap:var(--s2);align-items:center}