@flavor-code/superharness 1.0.0 → 1.0.3

package/HARNESS.md

@@ -19,6 +19,7 @@ the Skill tool before doing anything else.**
 |-------|-------------|
 | `superharness:go` | The user gives a task goal to complete end-to-end (also triggered by `/superharness:go <goal>`) |
 | `superharness:brainstorm` | ONLY when the user explicitly runs `/superharness:brainstorm <topic>` — never self-invoke. Requirements/design dialogue with a live browser mind map |
+| `superharness:onboarding` | When onboarding a newcomer or asked to explain/analyze the workspace's business logic — deep codebase analysis into ONBOARDING.md + interactive module mind map; also via `/onboarding` |
 | `superharness:light` | Small, focused tasks that need discipline without the full go machinery — quick fixes, small features, config/docs tweaks, prototypes. Lighter go: TDD with explicit exemptions, real-output verification, root-cause debugging; no worktree, no plan file, no ralph tracking |
 | `superharness:writing-plans` | A multi-step task needs an implementation plan, before touching code |
 | `superharness:using-git-worktrees` | Starting feature work that needs an isolated workspace, before implementation (go Phase 0.5) |

package/flavor-plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "superharness",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "apiVersion": "1",
   "main": "./index.js",
   "permissions": [],

package/index.js

@@ -1,13 +1,15 @@
 // superharness flavor-code plugin
 // Registers the superharness skill root so that go, brainstorm, tdd, etc.
-// are discovered under the /superharness namespace, and registers three
-// lifecycle hooks mirroring the Claude Code hooks:
+// are discovered by flavor-code, and registers eight lifecycle hooks:
 //   SessionStart     inject HARNESS.md (+ STACK.md when present) as additionalContext
 //   UserPromptSubmit auto-bootstrap ralph tracking on `/superharness:go <goal>`
 //   Stop             append a 'round' heartbeat to trace.jsonl while a go task runs
+//   SessionEnd       checkpoint without clearing the active resumable task
+//   Before/AfterPlan record plan boundaries
+//   SubagentStart/Stop record child lifecycle and real completion status
 // All hooks are best-effort and always return { decision: "allow" }.
 
-import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -37,9 +39,13 @@ function isoNow() {
 
 function atomicWrite(path, text) {
   mkdirSync(dirname(path), { recursive: true });
-  const tmp = `${path}.tmp`;
-  writeFileSync(tmp, text, "utf8");
-  renameSync(tmp, path);
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    writeFileSync(tmp, text, "utf8");
+    renameSync(tmp, path);
+  } finally {
+    try { rmSync(tmp, { force: true }); } catch { /* ignore */ }
+  }
 }
 
 function readJson(path) {
@@ -67,8 +73,7 @@ function appendTrace(root, phase, traceEvent, detail) {
   const line = JSON.stringify({ ts: isoNow(), phase, event: traceEvent, detail: detail ?? "" });
   const path = join(ralphDir(root), "trace.jsonl");
   mkdirSync(dirname(path), { recursive: true });
-  const existing = readText(path) ?? "";
-  writeFileSync(path, `${existing}${line}\n`, "utf8");
+  appendFileSync(path, `${line}\n`, "utf8");
 }
 
 // Parse a go invocation at the start of the prompt. flavor-code invokes skills
@@ -115,6 +120,13 @@ function onSessionStart(event) {
   if (stack !== undefined) {
     context += `\n\n<EXTREMELY_IMPORTANT>\nThis project targets a specific tech stack. Follow this guidance.\n\n${stack}\n</EXTREMELY_IMPORTANT>`;
   }
+  // One-line onboarding nudge when the workspace has neither the generated
+  // doc nor an analysis cache. Never auto-analyze; the skill is manual-only.
+  if (typeof workspace === "string" && workspace.length > 0
+      && !existsSync(join(workspace, "ONBOARDING.md"))
+      && !existsSync(join(workspace, ".flavor", "superharness", "onboarding", "cache.json"))) {
+    context += `\n\n<superharness-onboarding-hint>\nNo onboarding guide for this workspace yet. Run /onboarding (superharness:onboarding) to analyze the codebase, map module business relationships, and generate ONBOARDING.md plus an interactive module mind map. The agent decides when to run it - nothing is analyzed automatically.\n</superharness-onboarding-hint>`;
+  }
   return { decision: "allow", additionalContext: context };
 }
 
@@ -152,8 +164,9 @@ function onStop(event) {
 }
 
 // Called when the session ends (host fires SessionEnd). Records a final
-// trace event and clears any remaining ralph state so the next session
-// starts with a clean slate.
+// trace checkpoint. It deliberately preserves .current-task: ending a host
+// session is not the same as completing the go task, and cold-start resume
+// relies on that pointer.
 function onSessionEnd(event) {
   const root = projectRoot(event);
   const current = getCurrentTask(root);
@@ -161,8 +174,6 @@ function onSessionEnd(event) {
   const tasks = readJson(join(ralphDir(root), "task.json"));
   const phase = typeof tasks?.phase === "string" && tasks.phase.length > 0 ? tasks.phase : "go";
   appendTrace(root, phase, "session:end", "session ended");
-  // Clear the active-task pointer so the Stop hook no longer records heartbeats.
-  try { rmSync(currentTaskPath(root), { force: true }); } catch { /* ignore */ }
   return ALLOW;
 }
 
@@ -208,8 +219,13 @@ function onSubagentStop(event) {
   if (current === undefined) return ALLOW;
   const tasks = readJson(join(ralphDir(root), "task.json"));
   const phase = typeof tasks?.phase === "string" && tasks.phase.length > 0 ? tasks.phase : "go";
-  const outcome = typeof event?.payload?.outcome === "string" ? event.payload.outcome : "completed";
-  appendTrace(root, phase, "subagent:stop", `subagent ${outcome}`);
+  const status = typeof event?.payload?.status === "string"
+    ? event.payload.status
+    : typeof event?.payload?.outcome === "string" ? event.payload.outcome : "completed";
+  const error = typeof event?.payload?.error === "string" && event.payload.error.length > 0
+    ? `: ${event.payload.error}`
+    : "";
+  appendTrace(root, phase, "subagent:stop", `subagent ${status}${error}`);
   return ALLOW;
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flavor-code/superharness",
-  "version": "1.0.0",
-  "description": "为 flavor-code 注入规划、调试、测试与交付工作流的工程增强插件。",
+  "version": "1.0.3",
+  "description": "superharness",
   "type": "module",
   "main": "./index.js",
   "files": [
@@ -11,11 +11,9 @@
   "keywords": [
     "flavor-code",
     "flavor-plugin",
-    "workflow",
-    "skills",
-    "hooks"
+    "superharness"
   ],
-  "author": "Flavor Code",
+  "author": "yachuanwzh",
   "repository": "C:\\Users\\wangzh\\Desktop\\idea\\superharness",
   "flavorPlugin": {
     "apiVersion": "1"

package/skills/brainstorm/scripts/mindmap.html

@@ -19,6 +19,8 @@
   .node { cursor: pointer; }
   .node text { font-size: 13px; fill: var(--text); }
   .node.rejected text { fill: var(--muted); text-decoration: line-through; }
+  .node.stale { opacity: 0.45; }
+  .node.stale text { fill: var(--muted); font-style: italic; }
   .link { fill: none; stroke: #4a4e5e; stroke-width: 1.5; }
   #hint { position: fixed; bottom: 10px; right: 14px; color: var(--muted); font-size: 12px; z-index: 10; }
 </style>
@@ -48,6 +50,7 @@ const SVG_NS = 'http://www.w3.org/2000/svg';
 const KIND_COLORS = {
   topic: '#3d5afe', question: '#8e6cf0', option: '#2a9d8f', decision: '#e9933a',
   requirement: '#4fa3e3', risk: '#e35d6a', note: '#6c757d',
+  module: '#00b4d8', flow: '#90be6d', entity: '#b388eb',
 };
 const svg = document.getElementById('canvas');
 const viewport = document.getElementById('viewport');

package/skills/brainstorm/scripts/server.cjs

@@ -19,7 +19,10 @@ const EVENTS_FILE = path.join(STATE_DIR, 'events');
 const EDITS_FILE = path.join(STATE_DIR, 'edits');
 const INFO_FILE = path.join(STATE_DIR, 'server-info');
 const STOPPED_FILE = path.join(STATE_DIR, 'server-stopped');
-const PORT = Number(process.env.SUPERHARNESS_PORT) || (49152 + Math.floor(Math.random() * 16383));
+// Let the OS allocate an available ephemeral port unless the caller explicitly
+// pins one. Randomly guessing a high port can still collide under parallel tests
+// or when several brainstorm sessions start together.
+const PORT = process.env.SUPERHARNESS_PORT ? Number(process.env.SUPERHARNESS_PORT) : 0;
 const HOST = process.env.SUPERHARNESS_HOST || '127.0.0.1';
 const IDLE_TIMEOUT_MS = Number(process.env.SUPERHARNESS_IDLE_TIMEOUT_MS) || 30 * 60 * 1000;
 const IDLE_CHECK_MS = Math.min(5000, IDLE_TIMEOUT_MS);
@@ -192,13 +195,15 @@ setInterval(() => {
   if (Date.now() - lastActivity > IDLE_TIMEOUT_MS) shutdown(0);
 }, IDLE_CHECK_MS).unref();
 
-server.listen(PORT, HOST, () => {
-  try { fs.unlinkSync(STOPPED_FILE); } catch {}
-  const urlHost = HOST === '127.0.0.1' ? 'localhost' : HOST;
-  const info = {
-    type: 'server-started',
-    port: PORT,
-    url: 'http://' + urlHost + ':' + PORT,
+server.listen(PORT, HOST, () => {
+  try { fs.unlinkSync(STOPPED_FILE); } catch {}
+  const address = server.address();
+  const actualPort = typeof address === 'object' && address !== null ? address.port : PORT;
+  const urlHost = HOST === '127.0.0.1' ? 'localhost' : HOST;
+  const info = {
+    type: 'server-started',
+    port: actualPort,
+    url: 'http://' + urlHost + ':' + actualPort,
     pid: process.pid,
     content_dir: CONTENT_DIR,
     state_dir: STATE_DIR,

package/skills/onboarding/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: onboarding
+description: Use when the user runs /superharness:onboarding or /onboarding, or asks to onboard a newcomer / understand the codebase's business logic - deeply analyzes the workspace codebase (module responsibilities, cross-module business flows, data models) and produces ONBOARDING.md plus a live interactive mind map; supports incremental re-runs via cache
+argument-hint: [optional focus: module name, flow, or "drill <node>"]
+---
+
+# Superharness Onboarding — deep business-logic analysis for newcomers
+
+**Focus:** $ARGUMENTS
+
+**Announce at start:** "Superharness onboarding engaged. Analyzing workspace: <goal or 'full overview'>."
+
+Turn the current workspace into something a new team member can understand fast:
+a committed `ONBOARDING.md` + per-topic docs, mirrored live to an interactive
+mind map in the browser. The analysis is **layered** (overview → drill-down) and
+**incremental** (cache keyed by git hash). Deep business-logic interpretation is
+done by you (the agent); mechanical graph work is delegated to the astgraph
+plugin when available, with a mandatory fallback when it is not.
+
+**Cache path (exact, per host — do not double-nest):** the SessionStart hooks
+and incremental runs all key off ONE file per host:
+
+- Claude Code: `.claude/superharness/onboarding/cache.json`
+- flavor-code: `.flavor/superharness/onboarding/cache.json`
+
+(the directory above the filename is referred to as the onboarding cache dir
+below). Both are gitignored by the superharness installers. Generated docs
+(`ONBOARDING.md`, `docs/onboarding/`) are committed repo files; the cache is not.
+
+<HARD-GATE>
+Never modify source files. This skill only reads code and writes: the
+onboarding cache (state root, gitignored), ONBOARDING.md, docs/onboarding/*,
+and mind-map snapshots. Do not refactor, fix, or "improve" the analyzed code.
+</HARD-GATE>
+
+## Phase 0 — Engine detection (never blocks on astgraph)
+
+1. Determine the workspace root and state root.
+2. Decide the analysis engine — pipe a JSON object with booleans
+   `astToolsAvailable` / `indexDbExists` to the deterministic helper (write the
+   JSON to a temp file and pipe it; raw `echo '...'` quoting differs between
+   cmd.exe and POSIX shells):
+
+   ```
+   <json-file> | node <this skill's base directory>/scripts/onboarding-lib.cjs engine
+   ```
+
+   - `astToolsAvailable` = this session actually exposes `ast_search /
+     ast_callers / ast_callees / ast_impact / ast_context` (flavor-code with the
+     astgraph plugin; Claude Code hosts normally do NOT).
+   - `indexDbExists` = `.flavor/astgraph/index.db` exists in the workspace.
+3. Outcomes:
+   - `{engine:"astgraph"}` → use astgraph retrieval throughout Phase B.
+   - `{engine:"fallback", suggestAstInit:true}` → tools exist but no graph yet:
+     **tell the user they can run `/ast init` for sharper analysis later, and
+     continue right now with the fallback engine** — never wait for it.
+   - `{engine:"fallback"}` → no astgraph at all (plugin not installed, Claude
+     Code host, or non-TS/JS project): fallback is the plan, not a failure.
+4. Fallback engine = Glob/Grep/Read + LSP (`LspFindRefs`, `LspHover`). Record
+   the engine in the cache and stamp each generated doc header with
+   `分析引擎: astgraph|fallback` so readers know the precision level.
+
+## Phase 1 — Session + cache
+
+1. Read the onboarding cache (`.claude/superharness/onboarding/cache.json` or
+   `.flavor/superharness/onboarding/cache.json`) if present (may be empty/absent).
+2. Get `git rev-parse HEAD` and the changed-file set:
+   - with cache: `git diff --name-only <cache.gitHash> HEAD` plus
+     `git status --porcelain` (dirty files);
+   - no cache → full pass.
+3. Plan the pass with the helper:
+
+   ```
+   <json-file: {"cache":<cache-or-null>,"headHash":"<head>","changedFiles":[...]}> | node <skill base>/scripts/onboarding-lib.cjs refresh
+   ```
+
+   `{full:true}` → module discovery for everything; otherwise only the
+   `changed` module ids get (re-)analyzed in depth.
+
+**Mind map session** (like brainstorm; degrade gracefully to terminal-only if node/scripts fail):
+
+```
+powershell -NoProfile -ExecutionPolicy Bypass -File "<superharness skills dir>/brainstorm/scripts/start-server.ps1" -ProjectDir "<project root>"
+```
+
+Save `url`, `content_dir`, `state_dir` from the JSON it prints, tell the user to
+open the URL, and remind them the brainstorm session dir (`.claude/superharness/brainstorm/`
+or `.flavor/superharness/brainstorm/`) should be gitignored. Push snapshots using
+the brainstorm message protocol (`type:"mindmap:snapshot"`); node `kind` values
+additionally used here are `module`, `flow`, `entity`; stale entries are pushed
+with `state: "stale"` (the viewer greys them out).
+
+## Phase 2 — Phase A: module overview (shallow, bounded cost)
+
+1. **Discover modules**: directory/package structure (`package.json`, workspace
+   configs, top-level dirs), entry points, and import/dependency edges — via
+   `ast_search` when astgraph is live, else Grep for import/require statements.
+   Cluster into modules by directory/package boundary (keep the project's own
+   vocabulary for names).
+2. **Rank by connectivity**; deep-analyze at most the top 8 modules this run
+   (spec: control LLM cost on first pass). Mark the rest `待下钻` in the map.
+3. For each analyzed module produce the cached row:
+   `{ "summary": 一句话职责, "files": [ownership paths], "deps": [module ids], "doc": docs/onboarding/<id>.md }`
+   and note **business relations** — who calls it in which scenario, what data
+   crosses the boundary (read the code; do not guess).
+4. Push the overview snapshot (root = project name, children = module nodes with
+   one-line labels, dependency edges as `note` children on the callee), and
+   write/update `ONBOARDING.md`:
+   - 项目一句话 + 技术栈
+   - Mermaid module map (`graph LR` with dependency arrows)
+   - 模块速览表（职责 / 关键入口 file:line / 依赖）
+   - 推荐上手路径（读代码顺序，3–5 步，每步给 file:line）
+   - 核心业务流程索引（链接 docs/onboarding/*.md）
+   - 头部署名：`分析引擎` + 缓存 git hash（短格式）
+
+## Phase 3 — Phase B: drill-down (deep, demand-driven)
+
+Two entry paths, same loop:
+- **Terminal** (always available): user asks, e.g. "深入 install 模块" /
+  "一次 go 任务从头到尾经过哪些模块" / `"/onboarding drill <node-or-flow>"`.
+- **Browser clicks**: after each snapshot, poll `<state_dir>/events` (like
+  brainstorm edit rounds). A `node:click` on a `module` / `flow` node = drill
+  request for that node.
+
+Per drill-down:
+1. Pick 1–3 representative **business flows** through the target (entry → ... →
+   persistence/output). For each hop, record `file:line`.
+   - astgraph: `ast_callers` / `ast_callees` walk the chain; `ast_impact
+     --hops 3` gives the cross-module blast radius; `ast_context` reads ranges.
+   - fallback: `LspFindRefs` for call sites, Grep for dynamic/dispatch calls,
+     Read for the semantics. Say explicitly in the doc when a link is inferred
+     rather than graph-verified.
+2. Identify **data flow**: the entities that cross module boundaries, where
+   they're created, transformed, stored. Add `entity` nodes to the map.
+3. Write `docs/onboarding/<topic>.md`: 场景说明 → 调用链（编号步骤 + file:line）
+   → 模块协作图（Mermaid sequenceDiagram）→ 数据流转 → 改动影响面（ast_impact
+   结果或 Grep 依据）→ 常见坑（来自真实代码观察）。
+4. Push an updated snapshot (rev+1) with the new branch expanded, update cache,
+   and refresh the `ONBOARDING.md` flow index.
+
+Loop until the user stops asking or the map is fully explored. Keep each drill
+focused; do not re-analyze cached unchanged modules.
+
+## Phase 4 — Phase C: self-check + finish
+
+1. **Stale sweep**:
+
+   ```
+   <json-file: {"cache":<cache>,"existingFiles":[...workspace file list...]}> | node <skill base>/scripts/onboarding-lib.cjs stale
+   ```
+
+   Mark returned entries `stale: true` in cache and grey them in the map;
+   offer to re-analyze them (they'll appear as `changed` next refresh).
+2. Save cache atomically with the new `gitHash` + engine + timestamp.
+3. Stop the mind-map server:
+
+   ```
+   powershell -NoProfile -ExecutionPolicy Bypass -File "<superharness skills dir>/brainstorm/scripts/stop-server.ps1" -SessionDir "<session directory>"
+   ```
+
+4. Report: which docs were created/updated, engine used, what was marked stale.
+   Remind the user that `ONBOARDING.md` and `docs/onboarding/` are plain repo
+   files they (or the team) decide whether to commit — this skill never commits.
+
+## Incremental re-runs
+
+Second `/onboarding` invocation: refresh-plan → only changed/deep-missing
+modules re-analyzed, stale sweep runs, map is re-pushed from cache. If
+`git` is unavailable, treat everything as changed (full pass) and note it.
+
+## Red Flags
+
+| Thought | Reality |
+|---------|---------|
+| "No astgraph, let me bail" | Fallback engine is a first-class path. Continue. |
+| "Let me ask them to /ast init first" | Hint it, then proceed with fallback — never block. |
+| "I'll analyze every module deeply now" | Top-8 by connectivity, rest on demand. Cost discipline. |
+| "This call link looks obvious, skip verification" | Guessing creates docs that mislead newcomers. Cite file:line. |
+| "I'll tidy this messy module while here" | Read-only. HARD-GATE: no source edits. |

package/skills/onboarding/scripts/onboarding-lib.cjs

@@ -0,0 +1,112 @@
+// Superharness onboarding skill — deterministic analysis helpers.
+// The agent (SKILL.md) drives the semantic deep dives; this library owns the
+// mechanical decisions so they are testable and stable across hosts:
+//   engine   — pick astgraph vs. fallback (fallback is mandatory-capable)
+//   refresh  — what actually needs re-analysis given cache + changed files
+//   stale    — cached docs/anchors that no longer match the working tree
+//
+// CLI: node onboarding-lib.cjs <engine|refresh|stale>   (reads JSON on stdin)
+
+'use strict';
+
+const STALE_PREFIX = 'flow:';
+
+function normalizeRel(p) {
+  return String(p || '').replace(/\\/g, '/').replace(/^\.\//, '').toLowerCase();
+}
+
+// Double detection (spec): ast_* tool availability AND .flavor/astgraph/index.db
+// existence. Tools without an index never block the run: fall back immediately
+// and merely suggest `/ast init` for future precision.
+function detectEngine({ astToolsAvailable = false, indexDbExists = false } = {}) {
+  if (astToolsAvailable && indexDbExists) return { engine: 'astgraph' };
+  const result = { engine: 'fallback' };
+  if (astToolsAvailable && !indexDbExists) result.suggestAstInit = true;
+  return result;
+}
+
+// Module membership: a cached module owns the file when its recorded file list
+// contains it (prefix rules like "dir/*" match by directory).
+function moduleOwnsFile(module, file) {
+  const f = normalizeRel(file);
+  return (module.files || []).some((owned) => {
+    const o = normalizeRel(owned);
+    if (o.endsWith('/*')) return f.startsWith(o.slice(0, -1));
+    if (o.endsWith('/')) return f.startsWith(o);
+    return f === o;
+  });
+}
+
+// cache: { gitHash, modules: { id: { files: [...] } } } | null
+// changedFiles: workspace-relative paths (git diff --name-only HEAD <hash> etc.)
+function planRefresh({ cache, headHash, changedFiles = [] } = {}) {
+  if (!cache || !cache.modules) {
+    return { full: true, headHash, changed: [] };
+  }
+  if (cache.gitHash === headHash && changedFiles.length === 0) {
+    return { full: false, headHash, changed: [] };
+  }
+  const changed = new Set();
+  for (const file of changedFiles) {
+    for (const [id, module] of Object.entries(cache.modules)) {
+      if (moduleOwnsFile(module, file)) changed.add(id);
+    }
+  }
+  return { full: false, headHash, changed: [...changed] };
+}
+
+// Walk cached docs and flow anchors; anything the fileExists probe rejects is
+// reported as stale (flows are prefixed with "flow:" to keep ids unique).
+function staleCheck(cache, { fileExists } = {}) {
+  const stale = [];
+  const exists = typeof fileExists === 'function' ? fileExists : () => true;
+  const modules = (cache && cache.modules) || {};
+  const flows = (cache && cache.flows) || {};
+  for (const [id, m] of Object.entries(modules)) {
+    if (m && typeof m.doc === 'string' && !exists(m.doc)) stale.push(id);
+  }
+  for (const [id, f] of Object.entries(flows)) {
+    if (f && typeof f.doc === 'string' && !exists(f.doc)) { stale.push(STALE_PREFIX + id); continue; }
+    const anchors = (f && f.anchors) || [];
+    const broken = anchors.some((a) => {
+      const file = String(a).split('#')[0];
+      return file.length > 0 && !exists(file);
+    });
+    if (broken) stale.push(STALE_PREFIX + id);
+  }
+  return { stale };
+}
+
+function readStdin() {
+  return new Promise((resolve, reject) => {
+    let text = '';
+    process.stdin.on('data', (chunk) => { text += chunk; });
+    process.stdin.on('end', () => resolve(text));
+    process.stdin.on('error', reject);
+  });
+}
+
+const COMMANDS = {
+  engine: detectEngine,
+  refresh: planRefresh,
+  stale: (input) => staleCheck(input.cache, { fileExists: (p) => new Set((input.existingFiles || []).map(normalizeRel)).has(normalizeRel(p)) }),
+};
+
+if (require.main === module) {
+  (async () => {
+    const command = process.argv[2];
+    const run = COMMANDS[command];
+    if (run === undefined) {
+      process.stderr.write(`unknown command "${command ?? ''}"; expected one of: ${Object.keys(COMMANDS).join(', ')}\n`);
+      process.exit(2);
+      return;
+    }
+    const input = JSON.parse((await readStdin()) || '{}');
+    process.stdout.write(JSON.stringify(run(input)));
+  })().catch((err) => {
+    process.stderr.write(`${err.message}\n`);
+    process.exit(1);
+  });
+}
+
+module.exports = { detectEngine, planRefresh, staleCheck, normalizeRel };