rvlib-shipkit 0.10.0 → 0.13.0

package/src/serve/serve-hub.ts

@@ -1,18 +1,16 @@
-// shipkit serve — ONE hub server per repo, ONE port (his call 2026-07-22:
-// "a single shipkit task in vscode with multiple urls I can click"). The
-// landing page's links are the whole toolbox: /graph/wiki · /graph/agent ·
-// /assets/ (the studio, mounted IN-PROCESS) · /status (STATUS.md + run
-// check). Route logic only — resolving WHAT to mount from repo.config is
-// run-serve.ts's job.
+// shipkit serve — the repo's ONE Bun.serve, serving the ONE page (his
+// rules 2026-07-23: one server per repo, one surface, mobx+react). `/` is
+// the hub app (Bun HTML import — media studio + asks + creds + posts +
+// health + graphs as sections); the studio route table mounts as the media
+// API under /media/*; graph canvases stay as drill-down pages. Route logic
+// only — resolving WHAT to mount from repo.config is run-serve.ts's job.
 import { existsSync } from 'fs'
 import { join } from 'path'
 import { graphHtml } from 'rvlib-shipkit/src/wiki/graph-page.ts'
 import type { MdGraph } from 'rvlib-shipkit/src/wiki/md-graph.ts'
 import type { StudioRoutes } from '../assets/server/studio-server.ts'
-import { withRail, type AttentionSection } from './hub-pages.ts'
-// the hub UI is a Bun-native React app (HTML import, no vite, no build) —
-// build/webapp doctrine; legacy pages (graphs, studio SPA) keep the
-// server-injected rail until they migrate
+import { appendAskRemark, appendAssetNote, appendPostFeedback, askDone, askProof, markPosted, pickPostVariant } from '../collections/actions.ts'
+import type { Collection, Instance, NeedItem } from '../collections/collection-types.ts'
 import hubIndex from './hub-app/index.html'
 
 export type HubGraph = { title: string; load: () => MdGraph }
@@ -25,74 +23,126 @@ export type HubDeps = {
     wikiGraph: HubGraph
     /** null = no agent/ dir */
     agentGraph: HubGraph | null
-    /** null = no .rv-assets/kit.ts (or it failed to load — caller prints the WARN) */
+    /** the media API (mounted under /media/*); null only if the route
+     *  table failed to build — the page shows the WARN, never a second page */
     studio: StudioRoutes | null
-    /** argv shelling the check run streamed by /status/run (test seam) */
+    /** argv shelling the check run streamed by /api/check/run (test seam) */
     checkCmd: string[]
-    /** the / dashboard's data — everything red, gathered per request
-     *  (checks · asks · assets · contracts · posts; run-serve builds it) */
-    attention: () => Promise<AttentionSection[]>
+    /** every human-action item, red/yellow, gathered per request from the
+     *  collection providers (run-serve builds it) */
+    needs: () => Promise<NeedItem[]>
+    /** BROWSE-ALL: the collections with every instance incl. healthy —
+     *  the page shows everything that exists (his trust rule) */
+    collections: () => Collection[]
+    /** asks dir (repo-root-relative) for the act-in-place ask verbs */
+    asksDir: string
+    /** RED-only ping tick, called on an interval while serving (null = off) */
+    pingTick?: ((needs: NeedItem[]) => void) | null
 }
 export type Hub = { server: ReturnType<typeof Bun.serve>; tools: HubTool[]; stop: () => void }
 
-// the toolbox as data — the landing page, /hub.json, and the stdout ok:
-// lines all render THIS list, so they can never disagree
-export function hubTools(d: Pick<HubDeps, 'wikiGraph' | 'agentGraph' | 'studio'>): HubTool[] {
-    const tools: HubTool[] = [{ path: '/graph/wiki', label: 'wiki graph', desc: d.wikiGraph.title }]
+// the toolbox as data — stdout ok: lines and /hub.json render THIS list,
+// so they can never disagree
+export function hubTools(d: Pick<HubDeps, 'wikiGraph' | 'agentGraph'>): HubTool[] {
+    const tools: HubTool[] = [{ path: '/', label: 'hub', desc: 'THE page — media · asks · creds · posts · health · graphs' }]
+    tools.push({ path: '/graph/wiki', label: 'wiki graph', desc: d.wikiGraph.title })
     if (d.agentGraph != null) tools.push({ path: '/graph/agent', label: 'agent graph', desc: d.agentGraph.title })
-    if (d.studio != null) tools.push({ path: '/assets/', label: 'assets studio', desc: 'roll, curate, pick, ship' })
-    tools.push({ path: '/status', label: 'status', desc: 'STATUS.md + run check' })
     return tools
 }
 
+// drill-down pages (graph canvases) get one fixed home link back to THE page
+const HOME_LINK = `<style>.skhome{position:fixed;left:10px;top:10px;z-index:9999;font-size:17px;text-decoration:none;
+ background:#17140f;border:1px solid #332b22;border-radius:9px;padding:5px 9px}</style><a class=skhome href="/" title="hub — THE page">⌂</a>`
+const withHome = (html: string): string => html.replace(/<body([^>]*)>/, `<body$1>${HOME_LINK}`)
+
 export function serveHub(d: HubDeps): Hub {
     const tools = hubTools(d)
-    // every HTML page carries the rail — one keystroke between surfaces;
-    // the red dot self-fetches client-side (no collector on passive navs)
-    const shell = (s: string, active: string): Response =>
-        new Response(withRail(s, { tools, active }), { headers: { 'content-type': 'text/html; charset=utf-8' } })
     const server: ReturnType<typeof Bun.serve> = Bun.serve({
         hostname: '127.0.0.1',
         port: d.port,
-        // / (attention dashboard) and /status are the React app — one HTML
-        // bundle, view picked by pathname client-side
-        routes: { '/': hubIndex, '/status': hubIndex },
+        // `/` IS the page — the react app; there is no other surface
+        routes: { '/': hubIndex },
         async fetch(req): Promise<Response> {
             const path = new URL(req.url).pathname
             // identity probe: lets a second launch tell "same repo, another
             // window" from "a DIFFERENT repo hashed onto my port"
             if (path === '/hub.json') return Response.json({ hub: 'shipkit', name: d.name, tools })
-            if (path === '/api/attention.json') {
-                const sections = await d.attention().catch((e: Error) => [{ title: 'attention collector broke', tone: 'red' as const, lines: [{ text: e.message }] }])
-                return Response.json({ sections })
+            if (path === '/api/needs.json') {
+                const needs = await d.needs().catch((e: Error) => [{ collection: 'hub', id: 'hub:broken', text: `needs projection broke: ${e.message}`, severity: 'red' as const }])
+                return Response.json({ needs })
+            }
+            if (path === '/api/collections.json') {
+                // browse-all: every instance of every collection, healthy
+                // included — failure-isolated per collection
+                const out: { id: string; title: string; media: string; instances: Instance[] }[] = []
+                for (const col of d.collections()) {
+                    try {
+                        out.push({ id: col.id, title: col.title, media: col.media, instances: await col.list() })
+                    } catch (e) {
+                        out.push({ id: col.id, title: col.title, media: col.media, instances: [{ id: `${col.id}:broken`, text: `collector broke: ${(e as Error).message}`, severity: 'red' }] })
+                    }
+                }
+                return Response.json({ collections: out })
+            }
+            if (path.startsWith('/api/act/') && req.method === 'POST') {
+                // act-in-place verbs — every mutation hits a git-tracked truth
+                // file; errors surface as 400 text the card shows verbatim
+                try {
+                    const b = (await req.json()) as Record<string, string>
+                    if (path === '/api/act/ask-done') askDone(d.root, d.asksDir, b.file ?? '')
+                    else if (path === '/api/act/ask-proof') askProof(d.root, d.asksDir, b.file ?? '', b.url ?? '')
+                    else if (path === '/api/act/post-pick') pickPostVariant(d.root, b.channel ?? '', b.file ?? '')
+                    else if (path === '/api/act/post-posted') {
+                        const rating = b.rating != null ? Number(b.rating) : undefined
+                        if (rating != null && (!Number.isFinite(rating) || rating < 1 || rating > 5)) return new Response('rating must be 1-5', { status: 400 })
+                        markPosted(d.root, b.channel ?? '', b.file ?? '', b.url ?? '', rating)
+                    }
+                    else if (path === '/api/act/post-feedback') appendPostFeedback(d.root, b.channel ?? '', b.file ?? '', b.text ?? '')
+                    else if (path === '/api/act/remark') {
+                        // ONE remark verb, routed by collection — his words
+                        // land in the item's own truth file
+                        const text = (b.text ?? '').trim()
+                        if (text === '') return new Response('empty remark', { status: 400 })
+                        if (b.kind === 'ask') appendAskRemark(d.root, d.asksDir, b.file ?? '', text)
+                        else if (b.kind === 'media') appendAssetNote(d.root, b.id ?? '', text)
+                        else if (b.kind === 'post') appendPostFeedback(d.root, b.channel ?? '', b.file ?? '', text)
+                        else return new Response('unknown remark kind', { status: 400 })
+                    }
+                    else return new Response('unknown act', { status: 404 })
+                    return Response.json({ ok: true })
+                } catch (e) {
+                    return new Response((e as Error).message, { status: 400 })
+                }
             }
             if (path === '/api/status.json') {
                 const p = join(d.root, 'STATUS.md')
                 return Response.json({ statusMd: existsSync(p) ? await Bun.file(p).text() : null })
             }
-            if (path === '/graph/wiki') return shell(graphHtml(d.wikiGraph.load(), { title: d.wikiGraph.title }), path)
-            if (path === '/graph/wiki/graph.json') return Response.json(d.wikiGraph.load())
-            if (d.agentGraph != null && path === '/graph/agent') return shell(graphHtml(d.agentGraph.load(), { title: d.agentGraph.title }), path)
-            if (d.agentGraph != null && path === '/graph/agent/graph.json') return Response.json(d.agentGraph.load())
-            if (path === '/status/run' && req.method === 'POST') {
+            if (path === '/api/check/run' && req.method === 'POST') {
                 // stream wire lines as the check emits them; sh merges stderr
                 // so FAIL lines reach the page, not just the terminal
                 const proc = Bun.spawn(['sh', '-c', 'exec "$0" "$@" 2>&1', ...d.checkCmd], { cwd: d.root, stdout: 'pipe', stderr: 'ignore' })
                 return new Response(proc.stdout, { headers: { 'content-type': 'text/plain; charset=utf-8', 'cache-control': 'no-store' } })
             }
-            if (d.studio != null) {
-                // the studio page fetches RELATIVE urls — it must live under
-                // the slash-terminated prefix for them to resolve
-                if (path === '/assets') return new Response(null, { status: 307, headers: { location: '/assets/' } })
-                if (path === '/assets/' && req.method === 'GET') {
-                    // the SPA document gets the rail too; API routes untouched
-                    const res = await d.studio.handle(req, '/')
-                    return shell(await res.text(), '/assets/')
-                }
-                if (path.startsWith('/assets/')) return d.studio.handle(req, path.slice('/assets'.length))
-            }
-            return new Response('not found', { status: 404 })
+            const page = (s: string): Response => new Response(withHome(s), { headers: { 'content-type': 'text/html; charset=utf-8' } })
+            if (path === '/graph/wiki') return page(graphHtml(d.wikiGraph.load(), { title: d.wikiGraph.title }))
+            if (path === '/graph/wiki/graph.json') return Response.json(d.wikiGraph.load())
+            if (d.agentGraph != null && path === '/graph/agent') return page(graphHtml(d.agentGraph.load(), { title: d.agentGraph.title }))
+            if (d.agentGraph != null && path === '/graph/agent/graph.json') return Response.json(d.agentGraph.load())
+            // the media API namespace — the studio route table, ONE prefix strip
+            if (d.studio != null && path.startsWith('/media/')) return d.studio.handle(req, path.slice('/media'.length))
+            // stale bookmarks (/assets/, /status, …) land here — name the way home
+            return new Response('not found — the hub page is at /', { status: 404 })
         },
     })
-    return { server, tools, stop: () => server.stop(true) }
+    // RED-only pings ride the serving process: one tick now (state file
+    // guarantees a restart never re-fires), then every minute
+    let pingTimer: ReturnType<typeof setInterval> | null = null
+    if (d.pingTick != null) {
+        // tick failures are LOUD (console = the serve terminal), never swallowed
+        const tick = (): void => void d.needs().then((n) => d.pingTick?.(n)).catch((e: Error) => console.error(`WARN ping tick broke: ${e.message}`))
+        tick()
+        pingTimer = setInterval(tick, 60_000)
+    }
+    return { server, tools, stop: () => { if (pingTimer != null) clearInterval(pingTimer); server.stop(true) } }
 }

package/src/shipkit.ts

@@ -1,13 +1,16 @@
 // rvlib-shipkit — barrel. One import per repo: defineRepo in repo.config.ts;
 // everything else is the machinery behind the shipkit CLI.
-export { defineRepo, loadRepoConfig, resolveFloor, allTasks, contractsTask, contractsConfigFrom, activeContracts } from './repo-config.ts'
+export { defineRepo, loadRepoConfig, resolveFloor, allTasks, contractsTask } from './repo-config.ts'
 export type { RepoConfig, ServeConfig, FloorResolution, FloorSource } from './repo-config.ts'
+export { contractsConfigFrom, activeContracts, applyContractsResult } from './contracts/apply-contracts.ts'
 // the hub (`shipkit serve`): one server, one port, every tool a click away
 export { serveHub, hubTools } from './serve/serve-hub.ts'
 export type { Hub, HubDeps, HubGraph, HubTool } from './serve/serve-hub.ts'
 export { runServe, resolveHubDeps, defaultHubPort } from './serve/run-serve.ts'
-export { withRail, attentionRedCount } from './serve/hub-pages.ts'
-export type { AttentionSection, AttentionLine } from './serve/hub-pages.ts'
+export { projectNeeds, redCount } from './collections/collection-types.ts'
+export type { Collection, Instance, NeedItem, NeedSeverity, CurationVerb } from './collections/collection-types.ts'
+export { buildCollections } from './collections/providers.ts'
+export { socialPostsCollection, listPosts } from './collections/posts.ts'
 export { discoverChecks } from './core/discover-checks.ts'
 export type { DiscoveredCheck } from './core/discover-checks.ts'
 export { runTasks, selectTasks } from './core/task-runner.ts'
@@ -24,6 +27,11 @@ export { writeStatus } from './core/write-status.ts'
 export type { StatusInput, StatusOutcome } from './core/write-status.ts'
 export { formatLine, parseDuration, fmtAge, parseWireOutput } from './core/wire.ts'
 export type { Line } from './core/wire.ts'
+// the SK rule registry — stable-id invariants `shipkit check` enforces;
+// consumers (e.g. a wiki lint verifying mentioned ids exist) read RULES
+export { RULES, ruleById } from './rules/rule-registry.ts'
+export { tagRuleLines } from './rules/rule.ts'
+export type { Rule, RuleEnv, FixResult } from './rules/rule.ts'
 export { evaluateContracts, pngDims } from './contracts/contracts-engine.ts'
 export type { ContractsConfig, ContractsResult, ContractOutcome } from './contracts/contracts-engine.ts'
 export { defineContract, validateManifest, file, png, glob, md, dir, custom, script, fileContains, dirExists } from './contracts/contract-types.ts'
@@ -38,9 +46,8 @@ export { defineKit, defineKind, comfy, canvas, manual, gemini, mediaOf, MEDIA_EX
 export type { KitConfig, ResolvedKit, Kind, KindMeta, Media, AssetSpec, GeneratorSpec, ComfyGen, CanvasGen, ManualGen, GeminiGen, PanelSpec, GeometryPanelSpec, GridPanelSpec, CustomPanelSpec, FoundAsset, ShipContext, ShipFn } from './assets/kit-config.ts'
 export { identityKinds, renderIdentity, renderIdentityFromMark, NO_PICK_FIX, FAVICON_SIZE, OG_W, OG_H, LOGO_SIZE } from './assets/kits/identity-kit.ts'
 export type { Brand } from './assets/kits/identity-kit.ts'
-export { serveStudio, studioRoutes } from './assets/server/studio-server.ts'
-export type { Studio, StudioDeps, StudioRoutes } from './assets/server/studio-server.ts'
-export { page as studioPage } from './assets/server/studio-page.ts'
+export { studioRoutes } from './assets/server/studio-server.ts'
+export type { StudioDeps, StudioRoutes } from './assets/server/studio-server.ts'
 export { StudioQueue } from './assets/server/studio-queue.ts'
 export type { Job, QueueState } from './assets/server/studio-queue.ts'
 export { cleanRect, liveRect, defaultLegs, migrateCircle } from './assets/panels/geometry-rects.ts'