rvlib-shipkit 0.38.0 → 1.0.0

package/src/rules/run-fix.ts

@@ -1,72 +0,0 @@
-// `shipkit check --fix [SK### …]` — apply rule autofixes, then re-lint and
-// show the real end state. Never runs under ci (the gate stays pure), never
-// caches (a fixer must see reality). No ids = every fixable rule; a
-// requested id that is unknown or unfixable fails loud instead of silently
-// narrowing.
-import { CheckCtx } from '../core/check-ctx.ts'
-import { formatLine } from '../core/wire.ts'
-import { loadRepoConfig } from '../repo-config.ts'
-import { RULES } from './rule-registry.ts'
-import { runRuleLint, type RuleEnv } from './rule.ts'
-
-export type FixOpts = {
-    ids?: string[]
-    /** drop the closing advisory: inside the ci fix pass it is noise, and it is
-     *  not wire-shaped, which the frozen output contract forbids */
-    quiet?: boolean
-    print?: (line: string) => void
-}
-
-export async function runFix(root: string, o: FixOpts = {}): Promise<number> {
-    const print = o.print ?? ((l: string) => console.log(l))
-    const config = await loadRepoConfig(root)
-    const env: RuleEnv = { root, config }
-    const color = process.stdout.isTTY && process.env.NO_COLOR == null
-    // the repo's own rules fix exactly like the built-ins, one code path
-    const all = [...RULES, ...(config.rules ?? [])]
-
-    let targets = all.filter((r) => r.fix != null)
-    if (o.ids != null && o.ids.length > 0) {
-        for (const id of o.ids) {
-            const r = all.find((x) => x.id === id)
-            if (r == null) { print(`FAIL: unknown rule '${id}' — see: shipkit rules`); return 1 }
-            if (r.fix == null) { print(`FAIL: [${id}] has no autofix — fix by hand: ${config.docsBase ?? ''}${r.owner}`); return 1 }
-        }
-        const wanted = new Set(o.ids)
-        targets = targets.filter((r) => wanted.has(r.id))
-    }
-
-    let exit = 0
-    for (const rule of targets) {
-        const before = new CheckCtx(new Map())
-        await runRuleLint(rule, before, env)
-        // an exempted rule never autofixes: the repo broke that invariant on purpose
-        const exempt = config.ruleExempt?.[rule.id]
-        if (exempt != null) {
-            if (o.quiet !== true) print(`skip: [${rule.id}] ${rule.id} exempt: ${exempt}`)
-            continue
-        }
-        if (!before.failed && !before.warned) {
-            // inside the ci fix pass, a line per already-clean rule is a wall of
-            // nothing above the run that reports those same rules for real
-            if (o.quiet !== true) print(`ok: [${rule.id}] already clean — nothing to fix`)
-            continue
-        }
-        const f = await rule.fix!(env)
-        // an unchanged fix is the DESIGNED outcome for judgment findings, so
-        // it is an ok, not a warning. It carries a frozen wire prefix like
-        // every other line the fix pass emits: `shipkit ci` promises its whole
-        // output is parseable, and a bare line breaks that for every reader.
-        print(f.changed ? `ok: [${rule.id}] fixed: ${f.summary}` : `ok: [${rule.id}] fix changed nothing — ${f.summary}`)
-        const after = new CheckCtx(new Map())
-        await runRuleLint(rule, after, env)
-        // the fix already ran: advertising it again on surviving findings
-        // would send an agent in a loop
-        for (const l of after.lines) print(formatLine({ ...l, text: l.text.replace(/ · autofix: shipkit check --fix [A-Z]{2,4}\d{3}$/, '') }, color))
-        if (after.failed) exit = 1
-    }
-    const unfixable = all.filter((r) => r.fix == null).length
-    if (unfixable > 0 && o.quiet !== true && (o.ids == null || o.ids.length === 0))
-        print(`${unfixable} rule(s) have no autofix — they report in the run below`)
-    return exit
-}

package/src/tui/tasks-panel.ts

@@ -1,60 +0,0 @@
-// built-in panel: the ci gate's TASKS (floor + contracts + repo tasks)
-// through runCi — results stream in via the onTaskFinish tap. The checks are
-// skipped here on purpose: the Checks panel runs the same suite and renders
-// it, and running it twice per refresh costs twice and proves the same thing.
-// no panel writes STATUS.md: a dashboard refresh runs the tasks alone, so
-// stamping a verdict from it would overwrite what a real gate proved with a
-// narrower claim, just by looking at the repo.
-import type { RepoConfig } from '../repo-config.ts'
-import { allTasks } from '../repo-config.ts'
-import { runCi } from '../core/run-ci.ts'
-import { formatLine } from '../core/wire.ts'
-import type { TaskResult } from '../core/task-runner.ts'
-import type { TuiPanelDef, TuiRow } from './tui-panel.ts'
-
-const taskRow = (r: TaskResult): TuiRow => ({
-    key: r.id,
-    label: r.id,
-    status: r.status === 'pass' ? (r.lines.some((l) => l.kind === 'warn') ? 'warn' : 'pass') : r.status === 'fail' ? 'fail' : 'skip',
-    hint: `${(r.durationMs / 1000).toFixed(1)}s`,
-    detail: [
-        ...r.lines.map((l) => formatLine(l, false)),
-        ...(r.status === 'fail' && r.lastLine !== '' ? [`FAIL: ${r.lastLine}`] : []),
-        ...(r.note !== '' ? [`skip: ${r.note}`] : []),
-        ...(r.logPath != null ? [`full log: ${r.logPath}`] : []),
-    ],
-})
-
-export function tasksPanel(root: string, config: RepoConfig): TuiPanelDef {
-    let rows: TuiRow[] = []
-    return {
-        id: 'tasks',
-        title: 'Tasks',
-        rows: () => rows,
-        refresh: async (update) => {
-            const { tasks, disabled, unfilled } = allTasks(config, root)
-            rows = [
-                ...tasks.map((t): TuiRow => ({ key: t.id, label: t.id, status: 'pending', detail: [] })),
-                ...disabled.map((id): TuiRow => ({ key: id, label: id, status: 'skip', detail: ['skip: disabled by repo.config defaults'] })),
-                ...unfilled.map((u): TuiRow => ({ key: u.id, label: u.id, status: 'skip', detail: [`skip: ${u.reason}`] })),
-            ]
-            const byKey = new Map(rows.map((r, i) => [r.key, i]))
-            update()
-            await runCi(root, {
-                config,
-                skipChecks: true,
-                status: false,
-                print: () => {}, // rows carry everything the wire lines would
-                onTaskFinish: (r) => {
-                    const i = byKey.get(r.id)
-                    if (i == null) return
-                    rows[i] = taskRow(r)
-                    update()
-                },
-            })
-            // bail/interrupt leftovers never got a finish tap — visible, never a fake pass
-            rows = rows.map((r) => (r.status === 'pending' ? { ...r, status: 'skip', detail: ['skip: never ran (bailed or interrupted)'] } : r))
-            update()
-        },
-    }
-}