rvlib-shipkit 2.2.0 → 2.3.0

package/src/agent-time/shape.ts

@@ -0,0 +1,271 @@
+// A tool call's SHAPE: the name its time is grouped under. A Bash command
+// becomes its program and subcommand (`git commit`, `bun test <file>`,
+// `sk ci --only lint`), so five hundred variants group into a few dozen rows.
+//
+// The constraint a reader breaks first: a shape never keeps a free value (a
+// path, a message, a hash), or every call becomes its own row again. The only
+// value kept is `sk ci --only <check>`, a small closed set that says WHICH
+// check is slow.
+
+/** bumped with any rule below: the index shapes every stored call again */
+export const SHAPE_VERSION = 4
+
+/** programs whose first word is never a subcommand */
+const NO_SUBCOMMAND = new Set([
+    'awk', 'cat', 'chmod', 'cp', 'curl', 'date', 'diff', 'du', 'echo', 'ffmpeg', 'ffprobe', 'file', 'find', 'grep', 'head',
+    'jq', 'kill', 'killall', 'less', 'ln', 'ls', 'lsof', 'mkdir', 'mv', 'open', 'pgrep', 'pkill', 'printf', 'ps', 'pwd', 'rg',
+    'rm', 'rmdir', 'sed', 'sleep', 'sort', 'sqlite3', 'stat', 'tail', 'tee', 'test', 'touch', 'tr', 'tree', 'uniq', 'uptime',
+    'wc', 'wget', 'which', 'xargs', 'perl', 'magick', 'convert', 'zip', 'unzip', 'tar', 'osascript', 'say', 'afplay', 'screencapture', 'sips', 'top',
+])
+
+/** programs whose shape keeps two subcommand words (`gh pr view`, `sk gp start`) */
+const TWO_LEVELS = new Set(['sk', 'shipkit', 'gh', 'docker', 'kubectl', 'gcloud', 'wrangler', 'chi', 'comfy-ts', 'cflow', 'brew'])
+
+/** bun's own subcommands; any other first word is a package script */
+const BUN_BUILTINS = new Set(['test', 'run', 'x', 'install', 'i', 'add', 'remove', 'rm', 'build', 'pm', 'link', 'unlink', 'init', 'create', 'upgrade', 'lint', 'fmt', 'outdated', 'update', 'publish', 'patch', 'why', 'audit', 'exec', 'repl', 'info'])
+
+/** a segment that only sets the scene for the next one */
+const SETUP = new Set(['cd', 'export', 'set', 'source', '.', 'pushd', 'popd', 'unset', 'ulimit', 'shopt', 'true', ':'])
+
+/** words that run the rest of the line as the real command */
+const WRAPPERS: Record<string, number> = { nice: 0, time: 0, timeout: 1, command: 0, exec: 0, env: 0, sudo: 0, caffeinate: 0, stdbuf: 0, nohup: 0 }
+
+/** flags that eat the next word, per program, before its subcommand */
+const ARG_FLAGS: Record<string, Set<string>> = { git: new Set(['-C', '-c']), nice: new Set(['-n']), bun: new Set(['--cwd', '--filter']) }
+
+/** shell words, quotes removed; enough of a shell to split a command line */
+export function shellWords(segment: string): string[] {
+    const words: string[] = []
+    let cur = ''
+    let quote: string | null = null
+    let any = false
+    for (let i = 0; i < segment.length; i++) {
+        const c = segment[i] as string
+        if (quote != null) {
+            if (c === quote) quote = null
+            else if (c === '\\' && quote === '"' && i + 1 < segment.length) cur += segment[++i]
+            else cur += c
+        } else if (c === '"' || c === "'") {
+            quote = c
+            any = true
+        } else if (c === '\\' && i + 1 < segment.length) cur += segment[++i]
+        else if (/\s/.test(c)) {
+            if (cur !== '' || any) words.push(cur)
+            cur = ''
+            any = false
+        } else cur += c
+    }
+    if (cur !== '' || any) words.push(cur)
+    return words
+}
+
+/** a heredoc's body is data, never a command: `cat > f <<'EOF'` keeps its
+ *  first line, the lines up to the marker go */
+export function stripHeredocs(command: string): string {
+    const out: string[] = []
+    let marker: string | null = null
+    for (const line of command.split('\n')) {
+        if (marker != null) {
+            if (line.trim() === marker) marker = null
+            continue
+        }
+        out.push(line)
+        const m = /<<-?\s*['"]?([A-Za-z_][A-Za-z0-9_]*)['"]?/.exec(line)
+        if (m?.[1] != null) marker = m[1]
+    }
+    return out.join('\n')
+}
+
+/** the statements of a command line (split on `&&`, `||`, `;` and newlines
+ *  outside quotes), each one only its first pipeline part: in `grep x | head`
+ *  the time is the producer's */
+export function statements(command: string): string[] {
+    const out: string[] = []
+    let cur = ''
+    let piped = false
+    let quote: string | null = null
+    const text = stripHeredocs(command).replace(/\\\n/g, ' ')
+    const flush = (): void => {
+        out.push(cur)
+        cur = ''
+        piped = false
+    }
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i] as string
+        if (quote != null) {
+            if (c === quote) quote = null
+            if (!piped) cur += c
+            continue
+        }
+        if (c === '"' || c === "'") {
+            quote = c
+            if (!piped) cur += c
+            continue
+        }
+        const two = text.slice(i, i + 2)
+        if (two === '&&' || two === '||') {
+            flush()
+            i++
+        } else if (c === ';' || c === '\n') flush()
+        else if (c === '|') piped = true
+        else if (!piped) cur += c
+    }
+    flush()
+    return out.map((x) => x.trim()).filter((x) => x !== '')
+}
+
+const isWord = (w: string): boolean => /^[a-z][a-z0-9:_-]*$/i.test(w) && !/\.[a-z0-9]+$/i.test(w)
+const isPathLike = (w: string): boolean => w.includes('/') || /\.[a-z0-9]{1,5}$/i.test(w) || w.startsWith('~')
+const isScript = (w: string): boolean => /\.(?:sh|bash|zsh|ts|tsx|js|mjs|cjs|py|rb|pl)$/i.test(w) || (w.includes('/') && !w.startsWith('-'))
+const base = (w: string): string => w.replace(/\/+$/, '').split('/').pop() ?? w
+
+/** a statement's words: redirections, a leading `X=$(` and env assignments gone */
+function wordsOf(statement: string): string[] {
+    // `cat > f`, `cat a > b`: a file write, whatever it writes
+    if (/^cat\b[^|]*?(?<![0-9&>])>{1,2}(?!&)/.test(statement)) return ['cat', '>']
+    const w = shellWords(statement.replace(/^[A-Za-z_][A-Za-z0-9_]*=\$\(/, '').replace(/^\(+|\)+$/g, '').replace(/\s\d?>>?&?\d?\s*\S*/g, ' ').replace(/\s<\S+/g, ' '))
+    while (w.length > 0 && /^[A-Za-z_][A-Za-z0-9_]*=/.test(w[0] as string)) w.shift()
+    return w
+}
+
+/** statements that cost nothing next to the one they come with: a shape skips
+ *  them when a heavier statement follows (`uptime; sk ci`, `mkdir -p x && bun y.ts`) */
+const LIGHT = new Set(['echo', 'printf', 'uptime', 'date', 'pwd', 'mkdir', 'touch', 'which', 'clear', 'rm', 'cat'])
+
+const isLight = (w: string[]): boolean => LIGHT.has(w[0] as string) && (w[0] !== 'cat' || w.length === 1 || w[1] === '>' || w.every((x, i) => i === 0 || x.startsWith('-')))
+
+/** a python heredoc that opens a file to write it: an edit through Bash */
+const PY_EDIT = /\bpython3?\s+-\s*<</
+const PY_WRITES = /open\([^)]*,\s*['"][wa]|\.write(?:_text)?\(/
+
+/** the shape of one Bash command line */
+export function commandShape(command: string): string {
+    const stmts = statements(command.trim()).map(wordsOf).filter((w) => w.length > 0)
+    if (stmts.length === 0) return '(empty)'
+    const shape = pick(stmts) ?? (base(stmts[0]?.[0] ?? '') || '(empty)')
+    if (shape.startsWith('python') && !shape.includes(' ') && PY_EDIT.test(command) && PY_WRITES.test(command)) return `${shape} (edit)`
+    return shape
+}
+
+/** the statement the time belongs to, shaped: loops by what they run */
+function pick(stmts: string[][]): string | null {
+    let light: string[] | null = null
+    for (let i = 0; i < stmts.length; i++) {
+        const w = stmts[i] as string[]
+        const head = w[0] as string
+        if (head === 'for' || head === 'while' || head === 'until' || head === 'select') return loopShape(head, w, stmts.slice(i + 1))
+        if (head === 'if') return '(if)'
+        if (/^[A-Za-z_][A-Za-z0-9_-]*\(\)/.test(head) || head === 'function') return '(function)'
+        if (SETUP.has(head) || head === 'do' || head === 'done' || head === 'then' || head === 'fi') continue
+        if (isLight(w)) {
+            light ??= w
+            continue
+        }
+        return shapeOfWords(w)
+    }
+    return light == null ? null : shapeOfWords(light)
+}
+
+/** `(for) bun <file>`: a for loop by its body, a while or until loop by its
+ *  condition (a `[ … ]` test says nothing, so by its body then) */
+function loopShape(head: string, w: string[], after: string[][]): string {
+    const label = head === 'select' ? 'for' : head
+    const doAt = after.findIndex((x) => x[0] === 'do')
+    const body = doAt === -1 ? [] : [after[doAt]?.slice(1) ?? [], ...after.slice(doAt + 1)].filter((x) => x.length > 0)
+    const end = body.findIndex((x) => x[0] === 'done')
+    const inner = pick(end === -1 ? body : body.slice(0, end))
+    if (label === 'for') return `(for) ${inner ?? '…'}`
+    const cond = w.slice(1).filter((x) => x !== '!').map((x, i) => (i === 0 ? x.replace(/^[A-Za-z_][A-Za-z0-9_]*=\$\(/, '') : x))
+    const condShape = cond.length === 0 || cond[0] === '[' || cond[0] === '[[' || cond[0] === 'test' || cond[0] === 'true' || cond[0] === ':' ? null : shapeOfWords(cond)
+    return `(${label}) ${condShape ?? inner ?? '…'}`
+}
+
+function shapeOfWords(input: string[]): string {
+    let words = input
+    // unwrap `nice -n 15 timeout 60 env X=1 <cmd>`
+    for (;;) {
+        const head = words[0]
+        if (head == null || !(head in WRAPPERS)) break
+        let i = 1
+        const eats = ARG_FLAGS[head]
+        while (i < words.length && (words[i] as string).startsWith('-')) i += eats?.has(words[i] as string) ? 2 : 1
+        i += WRAPPERS[head] as number
+        while (i < words.length && /^[A-Za-z_][A-Za-z0-9_]*=/.test(words[i] as string)) i++
+        if (i >= words.length) break
+        words = words.slice(i)
+    }
+
+    if (words.length === 0) return '(empty)'
+    if (isScript(words[0] as string)) return base(words[0] as string)
+    let program = base(words[0] as string)
+    let rest = words.slice(1)
+    if ((program === 'bunx' || program === 'npx' || program === 'pnpx') && rest.length > 0) {
+        const pkg = rest.findIndex((w) => !w.startsWith('-'))
+        if (pkg !== -1) {
+            program = `${program} ${base(rest[pkg] as string)}`
+            rest = rest.slice(pkg + 1)
+        }
+    }
+    if (program.startsWith('python')) {
+        if (rest[0] === '-c' || rest[0] === '-m') return `${program} ${rest[0]}${rest[0] === '-m' && rest[1] != null ? ` ${rest[1]}` : ''}`
+        return rest.some((w) => isPathLike(w)) ? `${program} <file>` : program
+    }
+    if ((program === 'sed' || program === 'perl') && rest.some((w) => /^-[a-zA-Z]*i/.test(w) || w === '--in-place')) return `${program} -i (edit)`
+    if (program === 'cat' && rest[0] === '>') return 'cat > (write)'
+    if (NO_SUBCOMMAND.has(program)) return program
+
+    const parts = [program]
+    const eats = ARG_FLAGS[program]
+    const depth = TWO_LEVELS.has(program) || program === 'bun' || program === 'npm' || program === 'pnpm' ? 2 : 1
+    let subs = 0
+    for (let i = 0; i < rest.length; i++) {
+        const w = rest[i] as string
+        if (w.startsWith('-')) {
+            if (eats?.has(w)) i++
+            if (subs > 0) break
+            continue
+        }
+        if (isWord(w) && subs < depth) {
+            parts.push(w)
+            subs++
+            // `bun test x`: one level, then the argument is what it runs.
+            // `bun run x y` and `bun x y` (a package script, often the
+            // project CLI) keep the script and its first word
+            if (program === 'bun' && subs === 1 && BUN_BUILTINS.has(w) && w !== 'run') break
+            if (program === 'bun' && subs === 2 && parts[1] === 'run' && i + 1 < rest.length && isWord(rest[i + 1] as string)) {
+                parts.push(rest[i + 1] as string)
+                break
+            }
+            if ((program === 'npm' || program === 'pnpm') && subs === 1 && w !== 'run') break
+            continue
+        }
+        if (isPathLike(w) && subs === 0) parts.push('<file>')
+        break
+    }
+    if ((program === 'sk' || program === 'shipkit') && parts[1] === 'ci') {
+        const only = onlyValues(rest)
+        if (only.length > 0) return `${program} ci --only ${only.join(',')}`
+    }
+    if (program === 'bun' && parts[1] === 'test' && parts.length === 2 && rest.some((w) => isPathLike(w))) parts.push('<file>')
+    return parts.join(' ')
+}
+
+/** the `--only` values of an `sk ci` line, sorted: `--only a --only b,c` */
+function onlyValues(words: string[]): string[] {
+    const out: string[] = []
+    for (let i = 0; i < words.length; i++) {
+        const w = words[i] as string
+        if (w === '--only' && words[i + 1] != null) out.push(...(words[++i] as string).split(','))
+        else if (w.startsWith('--only=')) out.push(...w.slice(7).split(','))
+    }
+    return [...new Set(out.filter((x) => x !== ''))].sort()
+}
+
+/** the shape of any tool call: Bash by its command, a sub-agent by its type,
+ *  a skill by its name, everything else by the tool name */
+export function toolShape(name: string, detail: string): string {
+    if (name === 'Bash') return commandShape(detail)
+    if (name === 'Agent' || name === 'Task') return `Agent ${detail.split(':')[0] || 'general-purpose'}`
+    if (name === 'Skill' && detail !== '') return `Skill ${detail}`
+    return name
+}

package/src/agent-time/signals.ts

@@ -0,0 +1,84 @@
+// What his typed prompts say about the work, by rule, no model: a status ping
+// (he is waiting and asks where things stand), a slowness complaint, a
+// correction. The rules are this visible table, so every count is explainable
+// by the row that matched.
+//
+// The constraint a reader breaks first: his prompts are also SPECS, and a spec
+// says "slow" about the game ("the camera pans too slow"). A slowness rule
+// names the agent's world (tests, the gate, a tool, "takes forever"), never
+// the bare word.
+
+export type Signal = 'status' | 'slow' | 'correction'
+
+export type Rule = { signal: Signal; id: string; re: RegExp }
+
+const AGENT_WORLD = String.raw`(?:tests?|ci|gate|tools?|builds?|agents?|commands?|machine|cpu|checks?|deploys?|hub|servers?|sessions?|lanes?|you|sk|shipkit|typecheck|tsc|lint|everything|things|projects?|progress|it all|shots?|renders?|indexing)`
+
+export const RULES: Rule[] = [
+    { signal: 'status', id: 'where-stand', re: /\bwhere (?:do|are) we (?:stand|at)\b/i },
+    { signal: 'status', id: 'progress', re: /\b(?:good progress|any progress|how(?:'s| is) it going|any news|status update|still (?:running|working|on it)|are you (?:done|finished|still))\b/i },
+    { signal: 'status', id: 'done-q', re: /^\s*(?:done|finished|status|progress|eta|so)\s*\?+\s*$/i },
+    { signal: 'status', id: 'fr-avance', re: /\b(?:ça avance|ca avance|où en (?:est|sommes)|ou en est)\b/i },
+
+    { signal: 'slow', id: 'too-slow', re: new RegExp(String.raw`\b${AGENT_WORLD}\b[^.?!\n]{0,40}\b(?:too|so|very|really|super|crazy|insanely|extremely|painfully)\s+slow|\b(?:too|so|very|really|super|crazy|insanely|extremely|painfully)\s+slow\b[^.?!\n]{0,30}\b${AGENT_WORLD}\b`, 'i') },
+    { signal: 'slow', id: 'takes-long', re: /\b(?:takes?|taking|took)\s+(?:so\s+|too\s+|way\s+too\s+|really\s+)?(?:long|forever|ages|minutes)\b/i },
+    { signal: 'slow', id: 'world-slow', re: new RegExp(String.raw`\b${AGENT_WORLD}\b[^.?!\n]{0,40}\b(?:slow|sluggish|hangs?|stuck)\b`, 'i') },
+    { signal: 'slow', id: 'slow-world', re: new RegExp(String.raw`\b(?:slow|sluggish)\b[^.?!\n]{0,20}\b${AGENT_WORLD}\b`, 'i') },
+    { signal: 'slow', id: 'make-faster', re: new RegExp(String.raw`\b(?:make|making|get)\s+${AGENT_WORLD}\s+(?:\w+\s+)?faster\b`, 'i') },
+    { signal: 'slow', id: 'still-waiting', re: /\b(?:(?:i'?m|i am|we'?re|we are) still waiting|waiting for ages|been waiting|wait(?:ing)? forever|my cpu|save my machine)\b/i },
+    { signal: 'slow', id: 'slow-equals', re: /\bslow\s*=\s*wrong\b/i },
+
+    { signal: 'correction', id: 'double-bang', re: /!!/ },
+    { signal: 'correction', id: 'already-said', re: /\b(?:i (?:already|just) (?:said|told|asked)|how many times|as i said|i said (?:it|that) before|again\s*\?!|stop doing)\b/i },
+    { signal: 'correction', id: 'swear', re: /\b(?:wtf|fuck\w*|ffs|ridiculous|seriously\s*\?|are you kidding)\b/i },
+    { signal: 'correction', id: 'not-what', re: /\b(?:that'?s not what i (?:asked|said|meant)|you (?:didn'?t|did not) (?:read|listen)|you misread|wrong again)\b/i },
+]
+
+/** short words in capitals that are names, never shouting */
+const CAPS_OK = new Set([
+    'API', 'URL', 'URLS', 'JSON', 'HTML', 'CSS', 'PR', 'OK', 'TODO', 'README', 'CLI', 'TUI', 'DSL', 'TLDR', 'ASAP', 'GPU', 'CPU', 'IDS',
+    'FAIL', 'WARN', 'GO', 'UI', 'UX', 'SVG', 'PNG', 'MP4', 'SQL', 'HTTP', 'HTTPS', 'SSH', 'NPM', 'TS', 'JS', 'MD', 'IMO', 'FYI', 'LLM',
+    'AGENTS', 'CLAUDE', 'STE', 'VAT', 'TVA', 'OVH', 'DNS', 'CDN', 'OG', 'RGB', 'FPS', 'HMR', 'MCP', 'SDK', 'AI', 'GIF', 'PDF', 'EN', 'FR',
+    'WIP', 'MVP', 'VS', 'ID', 'NPC', 'NPCS', 'HUD', 'HP', 'XP', 'UTC', 'CET', 'ENV', 'EOF', 'RAM', 'SSD', 'USB', 'AND', 'OR', 'NOT',
+])
+
+/** code and pastes say nothing about his mood: fenced blocks, inline code and
+ *  quoted pastes are dropped before any rule runs */
+export function prose(text: string): string {
+    return text
+        .replace(/<pasted_content\b[\s\S]*?(?:<\/pasted_content>|$)/g, ' ')
+        .replace(/```[\s\S]*?(?:```|$)/g, ' ')
+        .replace(/`[^`\n]*`/g, ' ')
+        .split('\n')
+        // quoted lines, tables, stack frames, shell lines, and an agent's report
+        // pasted back (its lines open on a skim marker)
+        .filter((l) => !/^\s*(?:>|\||\d+\s*[|:]|at |\$ |[✅💬🔴🔶🧹💡❓🤝🚧🔼🚀🔒💥💸])/u.test(l))
+        .join('\n')
+}
+
+/** two or more shouted words (three letters or more, not a known name) */
+export function shouts(text: string): number {
+    const words = text.match(/\b[A-Z][A-Z']{2,}\b/g) ?? []
+    return words.filter((w) => !CAPS_OK.has(w.replace(/'.*$/, '')) && !/^[A-Z]{2,}\d/.test(w)).length
+}
+
+export type SignalHit = { signal: Signal; rule: string }
+
+/** every signal one prompt carries, with the rule that matched each */
+/** joy shouts too: `!!` and capitals next to these words are delight, not a correction */
+const JOY = /\b(?:love|amazing|great|awesome|perfect|fantastic|wonderful|beautiful|wow|nice|yes|excellent|brilliant|bravo|incredible|gorgeous)\b/i
+
+export function signalsOf(text: string): SignalHit[] {
+    const body = prose(text).slice(0, 2000)
+    const hits: SignalHit[] = []
+    const seen = new Set<Signal>()
+    const joy = JOY.test(body)
+    for (const r of RULES) {
+        if (joy && r.id === 'double-bang') continue
+        if (seen.has(r.signal) || !r.re.test(body)) continue
+        seen.add(r.signal)
+        hits.push({ signal: r.signal, rule: r.id })
+    }
+    if (!seen.has('correction') && !joy && shouts(body) >= 2) hits.push({ signal: 'correction', rule: 'caps' })
+    return hits
+}