@gobing-ai/knowledge-kit 0.0.12 → 0.0.14

package/plugins/sp/scripts/daily-summary/logger.ts

@@ -0,0 +1,28 @@
+/**
+ * Minimal self-contained logger for the embedded daily-summary script.
+ *
+ * The skill script stays self-contained (no CLI extraction, no monorepo coupling), so it carries its
+ * own tiny logger rather than importing the host plugin's. API mirrors the logger subset the script
+ * and test use: `logger.{info,warn,error}` and `enableLogger(console, file)`.
+ */
+
+type Channels = { console: boolean; file: boolean };
+
+const state: Channels = { console: true, file: false };
+
+/** Toggle output channels. Only the console channel is honoured here (no file appender by design). */
+export function enableLogger(consoleOn: boolean, fileOn: boolean): void {
+    state.console = consoleOn;
+    state.file = fileOn;
+}
+
+function emit(stream: 'log' | 'warn' | 'error', message: string): void {
+    if (!state.console) return;
+    console[stream](message);
+}
+
+export const logger = {
+    info: (message: string): void => emit('log', message),
+    warn: (message: string): void => emit('warn', message),
+    error: (message: string): void => emit('error', message),
+};

package/plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.mjs

@@ -0,0 +1,223 @@
+#!/usr/bin/env node
+import { createRequire } from 'node:module';
+
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts
+var PIPELINE_TOKENS = [
+    '--next',
+    'dev-runall',
+    'dev-wrapall',
+    'dev-refineall',
+    'dev-verifyall',
+    'dev-run',
+    'dev-wrap',
+    'dev-idea',
+    'refineall',
+    'verifyall',
+    'runall',
+    'wrapall',
+    'run',
+    'wrap',
+    'idea',
+];
+var PIPELINE_DRIVING_REFUSE_MESSAGE =
+    '⚠ pipeline-driving testee detected; pass --max-retry 0 (observe-only) or --max-retry N (fix mode, tree mutation acknowledged)';
+var MUTATING_FIX_REFUSE_MESSAGE =
+    '⚠ mutating --fix mode detected (--fix all | --fix blockers-first); pass --max-retry 0 (observe-only for the driver; the testee still mutates the tree) or --max-retry N (fix mode, driver + testee both mutate)';
+var IMPLEMENT_HEAVY_ADVISORY_MESSAGE =
+    '⚠ implement-heavy pipeline dogfood: prefer --max-retry 0 (observe-only) or step-split; operator --max-retry N overrides';
+var IMPLEMENT_HEAVY_TOKENS = [
+    'dev-runall',
+    'dev-wrapall',
+    'dev-run',
+    'dev-wrap',
+    'dev-idea',
+    'runall',
+    'wrapall',
+    'run',
+    'wrap',
+    'idea',
+    'implement',
+];
+function hasMutatingFixMode(step) {
+    return /(?<![\w-])--fix[=\s]+(all|blockers-first)(?![\w-])/i.test(step);
+}
+function tokenMatches(testee, token) {
+    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const re = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, 'i');
+    return re.test(testee);
+}
+function detectPipelineDriving(testee) {
+    if (typeof testee !== 'string' || testee.length === 0) {
+        return false;
+    }
+    return PIPELINE_TOKENS.some((token) => tokenMatches(testee, token));
+}
+function isImplementHeavyStep(step) {
+    if (typeof step !== 'string' || step.length === 0) return false;
+    const nonMutatingOnly =
+        tokenMatches(step, 'dev-verify') || tokenMatches(step, 'dev-review') || tokenMatches(step, 'dev-unit');
+    const hasMutating = IMPLEMENT_HEAVY_TOKENS.some((token) => tokenMatches(step, token)) || hasMutatingFixMode(step);
+    if (nonMutatingOnly && !hasMutating) return false;
+    if (tokenMatches(step, 'dev-refine') && !hasMutating && !tokenMatches(step, '--next')) {
+        return false;
+    }
+    if (tokenMatches(step, 'dev-refine') && tokenMatches(step, '--next')) {
+        return true;
+    }
+    return hasMutating;
+}
+function detectImplementHeavy(testee, derivedSteps = []) {
+    if (isImplementHeavyStep(testee)) return true;
+    if (!detectPipelineDriving(testee)) return false;
+    return derivedSteps.some((step) => isImplementHeavyStep(step));
+}
+function evaluateDogfoodGate(testee, options = {}) {
+    const maxRetryPresent = options.maxRetryPresent === true;
+    const steps = options.steps ?? [];
+    const pipelineDriving = detectPipelineDriving(testee);
+    const mutatingFix = hasMutatingFixMode(testee);
+    const implementHeavy = detectImplementHeavy(testee, steps);
+    if (pipelineDriving && !maxRetryPresent) {
+        return {
+            pipelineDriving,
+            mutatingFix,
+            maxRetryPresent,
+            implementHeavy,
+            refuse: true,
+            advisory: false,
+            message: PIPELINE_DRIVING_REFUSE_MESSAGE,
+            exitCode: 2,
+        };
+    }
+    if (mutatingFix && !maxRetryPresent) {
+        return {
+            pipelineDriving,
+            mutatingFix,
+            maxRetryPresent,
+            implementHeavy,
+            refuse: true,
+            advisory: false,
+            message: MUTATING_FIX_REFUSE_MESSAGE,
+            exitCode: 2,
+        };
+    }
+    if (implementHeavy) {
+        return {
+            pipelineDriving,
+            mutatingFix,
+            maxRetryPresent,
+            implementHeavy,
+            refuse: false,
+            advisory: true,
+            message: IMPLEMENT_HEAVY_ADVISORY_MESSAGE,
+            exitCode: 0,
+        };
+    }
+    return {
+        pipelineDriving,
+        mutatingFix,
+        maxRetryPresent,
+        implementHeavy,
+        refuse: false,
+        advisory: false,
+        message: null,
+        exitCode: 0,
+    };
+}
+function parseCliArgs(argv) {
+    let testee = null;
+    let maxRetryPresent = false;
+    let steps = [];
+    let json = false;
+    let help = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--help' || a === '-h') {
+            help = true;
+        } else if (a === '--json') {
+            json = true;
+        } else if (a === '--max-retry-present') {
+            maxRetryPresent = true;
+        } else if (a === '--testee') {
+            testee = argv[++i] ?? null;
+        } else if (a === '--steps') {
+            const raw = argv[++i] ?? '';
+            steps =
+                raw.length === 0
+                    ? []
+                    : raw
+                          .split('||')
+                          .map((s) => s.trim())
+                          .filter(Boolean);
+        } else if (a === '--') {
+            testee = argv.slice(i + 1).join(' ');
+            break;
+        } else if (!a.startsWith('-') && testee === null) {
+            testee = a;
+        }
+    }
+    return { testee, maxRetryPresent, steps, json, help };
+}
+var CLI_USAGE = `Usage:
+  bun plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts \\
+    --testee "<testee string>" [--max-retry-present] [--steps "s1||s2"] [--json]
+
+Exit codes:
+  0  proceed (stdout may carry implement-heavy advisory)
+  2  refuse — pipeline-driving OR mutating --fix mode without --max-retry
+  1  usage error
+
+Phase 1.0: run BEFORE deriving steps (omit --steps).
+Phase 1 W8: re-run AFTER step derivation with --steps "label1||label2".`;
+function runCli(argv) {
+    const { testee, maxRetryPresent, steps, json, help } = parseCliArgs(argv);
+    if (help) {
+        return { exitCode: 0, stdout: '', stderr: CLI_USAGE };
+    }
+    if (testee === null || testee.length === 0) {
+        return { exitCode: 1, stdout: '', stderr: CLI_USAGE };
+    }
+    const result = evaluateDogfoodGate(testee, { maxRetryPresent, steps });
+    if (json) {
+        return {
+            exitCode: result.exitCode,
+            stdout: `${JSON.stringify(result, null, 2)}
+`,
+            stderr: '',
+        };
+    }
+    if (result.message) {
+        return {
+            exitCode: result.exitCode,
+            stdout: `${result.message}
+`,
+            stderr: '',
+        };
+    }
+    return { exitCode: result.exitCode, stdout: '', stderr: '' };
+}
+{
+    const { exitCode, stdout, stderr } = runCli(process.argv.slice(2));
+    if (stdout) process.stdout.write(stdout);
+    if (stderr)
+        process.stderr.write(`${stderr}
+`);
+    process.exit(exitCode);
+}
+
+export {
+    CLI_USAGE,
+    detectImplementHeavy,
+    detectPipelineDriving,
+    evaluateDogfoodGate,
+    hasMutatingFixMode,
+    IMPLEMENT_HEAVY_ADVISORY_MESSAGE,
+    isImplementHeavyStep,
+    MUTATING_FIX_REFUSE_MESSAGE,
+    PIPELINE_DRIVING_REFUSE_MESSAGE,
+    PIPELINE_TOKENS,
+    parseCliArgs,
+    runCli,
+};

package/plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts

@@ -0,0 +1,367 @@
+/**
+ * detect-pipeline-driving — @1.2 pipeline-driving testee detector (task 0277, W7).
+ *
+ * Pure function over the raw testee string → boolean. Used by the dogfood driver
+ * (Phase 1.0 refuse-ambiguous gate) and by unit tests so the matcher contract is
+ * machine-checked rather than agent-interpreted.
+ *
+ * Also ships a **CLI gate** (import.meta.main) so Phase 1.0 is a live shell call,
+ * not agent-only prose interpretation:
+ *
+ *   bun plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts \
+ *     --testee "/sp:dev-run 0125 --auto --next" [--max-retry-present] \
+ *     [--steps "step1||step2"] [--json]
+ *
+ * Exit codes:
+ *   0 — proceed (may print implement-heavy advisory on stderr)
+ *   2 — refuse: pipeline-driving without explicit --max-retry
+ *   1 — usage / argument error
+ *
+ * Contract (0274 §3 dogfood-pipeline-detect, 0277 R1):
+ *   - Word-boundary matchers with `-` treated as a word char (NOT a boundary).
+ *     A token counts only when it is a distinct hyphen-word, not when it is a
+ *     substring of a longer alphanumeric or hyphen run. This removes the
+ *     leading-space dependency of the @1.1 prose detector.
+ *   - Two token shapes, both with strict `[^\w-]` boundaries:
+ *       (a) complete tokens — `--next`, `dev-run`, `dev-runall`, `dev-wrap`,
+ *           `dev-wrapall`, `dev-idea` — matched as whole hyphen-words so the
+ *           slash form `/sp:dev-run` matches on its `dev-run` tail whether or
+ *           not it is preceded by a space, but `--next` does NOT match inside
+ *           `--next-gen` (the trailing `-gen` breaks the boundary).
+ *       (b) bare nouns — `run`, `runall`, `wrap`, `wrapall`, `idea` — matched
+ *           only as standalone words, so `run` matches in
+ *           `bun ... task run 0042` but NOT inside `runaway`/`prerun`, and
+ *           `idea` does NOT match inside `idealist`/`ideal`.
+ *   - Listing both shapes is what makes the detector leading-space invariant
+ *     (the slash form is caught by its `dev-*` tail; the bare noun is caught
+ *     when it appears as its own word) without letting `run` leak into every
+ *     `-run-` identifier.
+ *
+ * Non-goals of detectPipelineDriving: decides ambiguity only. It does NOT decide
+ * observe vs fix — any explicit `--max-retry` value proceeds regardless.
+ * Implement-heavy advisory is a separate helper (detectImplementHeavy).
+ */
+
+/**
+ * Tokens whose presence makes a testee pipeline-driving. Ordered for stable
+ * diagnostics. Two shapes per the contract above: complete `dev-*` / `--next`
+ * tokens first, then bare nouns.
+ */
+const PIPELINE_TOKENS = [
+    '--next',
+    'dev-runall',
+    'dev-wrapall',
+    'dev-refineall',
+    'dev-verifyall',
+    'dev-run',
+    'dev-wrap',
+    'dev-idea',
+    'refineall',
+    'verifyall',
+    'runall',
+    'wrapall',
+    'run',
+    'wrap',
+    'idea',
+] as const;
+
+/** Refuse message when pipeline-driving and `--max-retry` was not passed (exact string). */
+export const PIPELINE_DRIVING_REFUSE_MESSAGE =
+    '⚠ pipeline-driving testee detected; pass --max-retry 0 (observe-only) or --max-retry N (fix mode, tree mutation acknowledged)';
+
+/**
+ * Refuse message when the testee carries a mutating `--fix` mode (`--fix all` /
+ * `--fix blockers-first`) and `--max-retry` was not passed. A mutating fix mode
+ * mutates the working tree independent of pipeline-driving (task 0293 R1/R2):
+ * `--max-retry 0` bounds the **driver** only — the testee's own `--fix` pass
+ * still mutates the tree — so the message must not imply otherwise.
+ */
+export const MUTATING_FIX_REFUSE_MESSAGE =
+    '⚠ mutating --fix mode detected (--fix all | --fix blockers-first); pass --max-retry 0 (observe-only for the driver; the testee still mutates the tree) or --max-retry N (fix mode, driver + testee both mutate)';
+
+/** Advisory when pipeline-driving + implement-heavy derived steps (exact string). */
+export const IMPLEMENT_HEAVY_ADVISORY_MESSAGE =
+    '⚠ implement-heavy pipeline dogfood: prefer --max-retry 0 (observe-only) or step-split; operator --max-retry N overrides';
+
+/**
+ * Tokens that mark a derived step as implement-heavy (mutates product/code or
+ * drives a mutating pipeline leg). Deliberately excludes verify/review/unit-only
+ * surfaces even when they carry `--next`.
+ */
+const IMPLEMENT_HEAVY_TOKENS = [
+    'dev-runall',
+    'dev-wrapall',
+    'dev-run',
+    'dev-wrap',
+    'dev-idea',
+    'runall',
+    'wrapall',
+    // bare `run` / `wrap` / `idea` — only when not clearly a non-mutating surface
+    'run',
+    'wrap',
+    'idea',
+    'implement',
+] as const;
+
+/**
+ * A verify/review surface stops being non-mutating the moment it carries a
+ * repair mode: `--fix all` / `--fix blockers-first` applies Edit/Write repairs
+ * to the working tree (0280 dogfood, finding P2). `--fix none` stays
+ * observational. Boundary-guarded so `--prefix all` / `--focus all` never match.
+ * Exported so the Phase 1.0 gate and tests share one matcher (task 0293 R1/R4).
+ */
+export function hasMutatingFixMode(step: string): boolean {
+    return /(?<![\w-])--fix[=\s]+(all|blockers-first)(?![\w-])/i.test(step);
+}
+
+/**
+ * Match a token at a word boundary. A "word boundary" here is the position
+ * between a non-`[\w-]` char (or string start) and the token, and between the
+ * token and a non-`[\w-]` char (or string end). Treating `-` as a word char
+ * is what makes `--next` reject `--next-gen` and `dev-run` reject `dev-runner`.
+ */
+function tokenMatches(testee: string, token: string): boolean {
+    const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    // (?<![\w-]) — not preceded by a word char or hyphen.
+    // (?![\w-])  — not followed by a word char or hyphen.
+    const re = new RegExp(`(?<![\\w-])${escaped}(?![\\w-])`, 'i');
+    return re.test(testee);
+}
+
+/**
+ * Returns whether the testee string is pipeline-driving (contains any of the
+ * pipeline-driving tokens as a distinct hyphen-word). Machine-checked
+ * counterpart of the prose list in SKILL.md §Pipeline-driving detection and
+ * dev-dogfood.md.
+ */
+export function detectPipelineDriving(testee: string): boolean {
+    if (typeof testee !== 'string' || testee.length === 0) {
+        return false;
+    }
+    return PIPELINE_TOKENS.some((token) => tokenMatches(testee, token));
+}
+
+/**
+ * True when a single step label (or the whole testee) is implement-heavy —
+ * it chains into real implementation / wrap / idea work, not verify-only.
+ *
+ * Non-mutating surfaces (`dev-verify`, `dev-review`, `dev-unit`, plain
+ * `dev-refine` without a further run) are never implement-heavy even if
+ * pipeline-driving via `--next` — UNLESS they carry a mutating repair mode
+ * (`--fix all` / `--fix blockers-first`), which turns the verify/review leg
+ * into a tree-mutating fix pass (0280 dogfood, finding P2).
+ */
+export function isImplementHeavyStep(step: string): boolean {
+    if (typeof step !== 'string' || step.length === 0) return false;
+    // Explicit non-mutating surfaces win unless a mutating token co-occurs.
+    const nonMutatingOnly =
+        tokenMatches(step, 'dev-verify') || tokenMatches(step, 'dev-review') || tokenMatches(step, 'dev-unit');
+    const hasMutating = IMPLEMENT_HEAVY_TOKENS.some((token) => tokenMatches(step, token)) || hasMutatingFixMode(step);
+    if (nonMutatingOnly && !hasMutating) return false;
+    // refine alone is planning, not implement-heavy; refine+run/--next chain is.
+    if (tokenMatches(step, 'dev-refine') && !hasMutating && !tokenMatches(step, '--next')) {
+        return false;
+    }
+    if (tokenMatches(step, 'dev-refine') && tokenMatches(step, '--next')) {
+        // refine --next chains into run → implement-heavy
+        return true;
+    }
+    return hasMutating;
+}
+
+/**
+ * True when the testee is implement-heavy: it carries a pipeline-driving token,
+ * a mutating `--fix` mode, OR at least one derived step (or the testee itself
+ * when no steps given) is implement-heavy. Used for the W8 Phase 1 advisory
+ * after step derivation.
+ *
+ * Task 0293 R3: a mutating `--fix` mode alone is implement-heavy even with no
+ * pipeline token — the verify/review leg itself becomes a tree-mutating fix
+ * pass.
+ */
+export function detectImplementHeavy(testee: string, derivedSteps: string[] = []): boolean {
+    if (isImplementHeavyStep(testee)) return true;
+    if (!detectPipelineDriving(testee)) return false;
+    return derivedSteps.some((step) => isImplementHeavyStep(step));
+}
+
+export interface GateResult {
+    pipelineDriving: boolean;
+    mutatingFix: boolean;
+    maxRetryPresent: boolean;
+    implementHeavy: boolean;
+    refuse: boolean;
+    advisory: boolean;
+    message: string | null;
+    exitCode: 0 | 1 | 2;
+}
+
+/**
+ * Phase 1.0 + W8 gate decision. Pure — no I/O. The CLI wrapper prints and exits.
+ *
+ * Refuse condition (task 0293 R1) is the union of two **independent** mutation
+ * sources, each gated on `!maxRetryPresent`:
+ *
+ *   1. pipeline-driving testee (`--next`, `dev-run`, …) — refuses because the
+ *      testee chains lifecycle legs whose cumulative blast radius the driver
+ *      cannot pre-attribute.
+ *   2. mutating `--fix` mode (`--fix all` / `--fix blockers-first`) — refuses
+ *      because the testee itself applies Edit/Write repairs even with no
+ *      pipeline token. `--max-retry 0` bounds the **driver** only; the testee
+ *      still mutates (honesty note in MUTATING_FIX_REFUSE_MESSAGE).
+ *
+ * Pipeline-driving is reported first when both co-occur (its refuse message is
+ * the superset — chain + tree mutation).
+ */
+export function evaluateDogfoodGate(
+    testee: string,
+    options: { maxRetryPresent?: boolean; steps?: string[] } = {},
+): GateResult {
+    const maxRetryPresent = options.maxRetryPresent === true;
+    const steps = options.steps ?? [];
+    const pipelineDriving = detectPipelineDriving(testee);
+    const mutatingFix = hasMutatingFixMode(testee);
+    const implementHeavy = detectImplementHeavy(testee, steps);
+
+    if (pipelineDriving && !maxRetryPresent) {
+        return {
+            pipelineDriving,
+            mutatingFix,
+            maxRetryPresent,
+            implementHeavy,
+            refuse: true,
+            advisory: false,
+            message: PIPELINE_DRIVING_REFUSE_MESSAGE,
+            exitCode: 2,
+        };
+    }
+
+    if (mutatingFix && !maxRetryPresent) {
+        return {
+            pipelineDriving,
+            mutatingFix,
+            maxRetryPresent,
+            implementHeavy,
+            refuse: true,
+            advisory: false,
+            message: MUTATING_FIX_REFUSE_MESSAGE,
+            exitCode: 2,
+        };
+    }
+
+    if (implementHeavy) {
+        return {
+            pipelineDriving,
+            mutatingFix,
+            maxRetryPresent,
+            implementHeavy,
+            refuse: false,
+            advisory: true,
+            message: IMPLEMENT_HEAVY_ADVISORY_MESSAGE,
+            exitCode: 0,
+        };
+    }
+
+    return {
+        pipelineDriving,
+        mutatingFix,
+        maxRetryPresent,
+        implementHeavy,
+        refuse: false,
+        advisory: false,
+        message: null,
+        exitCode: 0,
+    };
+}
+
+export { PIPELINE_TOKENS };
+
+// ── CLI entry (live Phase 1.0 gate) ──────────────────────────────────────────
+
+export interface CliArgs {
+    testee: string | null;
+    maxRetryPresent: boolean;
+    steps: string[];
+    json: boolean;
+    help: boolean;
+}
+
+/** Parse CLI argv (everything after the script name). Exported for unit tests. */
+export function parseCliArgs(argv: string[]): CliArgs {
+    let testee: string | null = null;
+    let maxRetryPresent = false;
+    let steps: string[] = [];
+    let json = false;
+    let help = false;
+
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--help' || a === '-h') {
+            help = true;
+        } else if (a === '--json') {
+            json = true;
+        } else if (a === '--max-retry-present') {
+            maxRetryPresent = true;
+        } else if (a === '--testee') {
+            testee = argv[++i] ?? null;
+        } else if (a === '--steps') {
+            const raw = argv[++i] ?? '';
+            steps =
+                raw.length === 0
+                    ? []
+                    : raw
+                          .split('||')
+                          .map((s) => s.trim())
+                          .filter(Boolean);
+        } else if (a === '--') {
+            testee = argv.slice(i + 1).join(' ');
+            break;
+        } else if (!a.startsWith('-') && testee === null) {
+            testee = a;
+        }
+    }
+
+    return { testee, maxRetryPresent, steps, json, help };
+}
+
+export const CLI_USAGE = `Usage:
+  bun plugins/sp/scripts/dogfood-testing/detect-pipeline-driving.ts \\
+    --testee "<testee string>" [--max-retry-present] [--steps "s1||s2"] [--json]
+
+Exit codes:
+  0  proceed (stdout may carry implement-heavy advisory)
+  2  refuse — pipeline-driving OR mutating --fix mode without --max-retry
+  1  usage error
+
+Phase 1.0: run BEFORE deriving steps (omit --steps).
+Phase 1 W8: re-run AFTER step derivation with --steps "label1||label2".`;
+
+/**
+ * Pure CLI runner for tests: returns { exitCode, stdout, stderr } without
+ * process.exit / console I/O side effects.
+ */
+export function runCli(argv: string[]): { exitCode: number; stdout: string; stderr: string } {
+    const { testee, maxRetryPresent, steps, json, help } = parseCliArgs(argv);
+    if (help) {
+        return { exitCode: 0, stdout: '', stderr: CLI_USAGE };
+    }
+    if (testee === null || testee.length === 0) {
+        return { exitCode: 1, stdout: '', stderr: CLI_USAGE };
+    }
+
+    const result = evaluateDogfoodGate(testee, { maxRetryPresent, steps });
+    if (json) {
+        return { exitCode: result.exitCode, stdout: `${JSON.stringify(result, null, 2)}\n`, stderr: '' };
+    }
+    if (result.message) {
+        return { exitCode: result.exitCode, stdout: `${result.message}\n`, stderr: '' };
+    }
+    return { exitCode: result.exitCode, stdout: '', stderr: '' };
+}
+
+if (import.meta.main) {
+    const { exitCode, stdout, stderr } = runCli(process.argv.slice(2));
+    if (stdout) process.stdout.write(stdout);
+    if (stderr) process.stderr.write(`${stderr}\n`);
+    process.exit(exitCode);
+}