@nexrall/code-core 1.4.76 → 1.4.77

package/dist/verify/verification.js

@@ -0,0 +1,315 @@
+"use strict";
+// Verification ledger + panel (§82/§83). Moved from the CLI's
+// ui/verification.ts (2026-10-04) so the VS Code panel records and shows
+// the SAME checks; the CLI module is a re-export shim.
+// Acceptance criteria (spec §82) and the verification panel (spec §83).
+//
+// WHY: the turn summary says "✓ 3 files changed · 12 tool calls" — it counts work, not
+// confidence. A user who asked for a change wants to know whether the TYPE CHECK ran, the
+// TESTS ran, the BUILD ran, and whether they saw the diff — and especially whether anything
+// they declared as a completion criterion is still unproven. The panel answers that from
+// OBSERVED tool results only: every ✓ is a command that actually exited 0 this session.
+//
+// "Not run" is a first-class answer. The panel never rounds a missing check up to a pass,
+// and a criterion that no check ever covered stays `·` until a real run covers it.
+//
+// Pure (no console, no chalk, no fs) — see test/verification.test.ts.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VerificationLedger = exports.CRITERION_LABELS = exports.CHECK_KINDS = void 0;
+exports.classifyCheck = classifyCheck;
+exports.parseTestsPassed = parseTestsPassed;
+exports.parseCriteria = parseCriteria;
+exports.canonicalOrder = canonicalOrder;
+exports.criterionStatus = criterionStatus;
+exports.unmetCriteria = unmetCriteria;
+exports.formatVerificationPanel = formatVerificationPanel;
+exports.criteriaLine = criteriaLine;
+exports.formatCriteriaList = formatCriteriaList;
+const failureTimeline_1 = require("./failureTimeline");
+/** Canonical order — the panel, the criteria list and the summary all use it. */
+exports.CHECK_KINDS = ['typecheck', 'unit', 'integration', 'lint', 'build'];
+exports.CRITERION_LABELS = {
+    typecheck: 'typecheck',
+    unit: 'unit tests',
+    integration: 'integration tests',
+    lint: 'lint',
+    build: 'build',
+    diff: 'git diff reviewed',
+};
+// ─── classification ──────────────────────────────────────────────────────────
+/** `npm run typecheck:ci` → the script is `typecheck:ci`; `npm t` → `t`. */
+const RUNNER_RE = /\b(?:npm|yarn|pnpm|bun)(?:\s+run)?\s+([^\s;&|]+)/i;
+/** Word that is exactly a script-name part, e.g. `build` in `build:css`. */
+const scriptWord = (word, s) => new RegExp(`(^|[:.-])${word}([:.-]|$)`, 'i').test(s);
+const INTEGRATION_TOOLS = /\b(e2e|integration|cypress|playwright|selenium|nightwatch|testcafe|newman)\b/;
+const TYPECHECK_TOOLS = /\b(tsc|vue-tsc|svelte-check|mypy|pyright|pyre|typecheck|type-check|types)\b/;
+const LINT_TOOLS = /\b(eslint|oxlint|stylelint|ruff|flake8|pylint|biome|clippy|golangci|staticcheck|phpcs|phpstan|psalm|rubocop|swiftlint|ktlint|detekt|shellcheck|hadolint|cppcheck|clang-tidy|luacheck|jshint|standard)\b/;
+const BUILD_TOOLS = /\b(build|compile|webpack|rollup|esbuild|parcel|vite)\b/;
+const UNIT_TOOLS = /\b(jest|vitest|mocha|jasmine|ava|pytest|unittest|nose2|tox|rspec|minitest|phpunit|xunit|nunit|mstest)\b/;
+const words = (s) => s
+    .trim()
+    .split(/[\s;&|()]+/)
+    .filter((t) => t && !t.startsWith('-'));
+/**
+ * The kind of verification a check command performs, or undefined when it is a check
+ * (`npm run verify`, a bare `make ci`) whose kind cannot honestly be told apart.
+ *
+ * Scanned segment by segment so `cd app && npm test` classifies as `unit`, and the first
+ * segment that classifies wins (`npm run build && npm test` is a build run that also
+ * tested — calling it `unit` would hide the build, which is what the user is waiting on).
+ */
+function classifyCheck(command) {
+    if (!(0, failureTimeline_1.isCheckCommand)(command))
+        return undefined;
+    for (const seg of command.split(/&&|\|\||;/)) {
+        const kind = classifySegment(seg);
+        if (kind)
+            return kind;
+    }
+    return undefined;
+}
+function classifySegment(raw) {
+    const seg = raw.trim();
+    if (!seg)
+        return undefined;
+    const lower = seg.toLowerCase();
+    const ws = words(lower);
+    if (!ws.length)
+        return undefined;
+    const has = (t) => ws.includes(t);
+    const script = RUNNER_RE.exec(seg)?.[1] ?? '';
+    // A word that is exactly the script name or one of its `[:.-]` parts: `test:unit`,
+    // `build:prod`, and the plain `test`/`t` shorthands.
+    const scriptish = (t) => scriptWord(t, script) || ws.some((w) => w === t || scriptWord(t, w));
+    // Integration wins over unit: `npm run test:e2e` is the e2e run, `playwright test` too.
+    if (INTEGRATION_TOOLS.test(lower) || scriptish('e2e') || scriptish('integration'))
+        return 'integration';
+    if (TYPECHECK_TOOLS.test(lower) ||
+        scriptish('typecheck') ||
+        scriptish('type-check') ||
+        (has('cargo') && has('check')))
+        return 'typecheck';
+    if (LINT_TOOLS.test(lower) || scriptish('lint') || (has('go') && has('vet')))
+        return 'lint';
+    if (has('test') ||
+        has('tests') ||
+        has('spec') ||
+        has('coverage') ||
+        UNIT_TOOLS.test(lower) ||
+        /\bnode\s+--test\b/.test(lower) ||
+        scriptish('test') ||
+        scriptish('t') ||
+        scriptish('unit')) {
+        return 'unit';
+    }
+    if (BUILD_TOOLS.test(lower) ||
+        scriptish('build') ||
+        has('make') ||
+        has('gradle') ||
+        has('xcodebuild') ||
+        has('mvn')) {
+        return 'build';
+    }
+    return undefined;
+}
+class VerificationLedger {
+    constructor() {
+        this.runs = new Map();
+        this.diff = false;
+    }
+    /** Record one check result. The LATEST run of a kind wins — the panel is "as of now". */
+    note(kind, ok, command, at, testsPassed) {
+        const cmd = command.replace(/\s+/g, ' ').trim();
+        if (!cmd)
+            return;
+        const clipped = cmd.length > failureTimeline_1.MAX_CMD_CHARS ? cmd.slice(0, failureTimeline_1.MAX_CMD_CHARS - 1) + '…' : cmd;
+        this.runs.set(kind, { kind, ok, command: clipped, at, testsPassed });
+    }
+    /** `/diff` printed the changeset: the "reviewed the diff" box is now honestly tickable. */
+    noteDiffReviewed() {
+        this.diff = true;
+    }
+    get(kind) {
+        return this.runs.get(kind);
+    }
+    /** Runs recorded at or after `at` — "what this TURN verified", for the §84 block. */
+    runsSince(at) {
+        return [...this.runs.values()]
+            .filter((r) => r.at >= at)
+            .sort((a, b) => exports.CHECK_KINDS.indexOf(a.kind) - exports.CHECK_KINDS.indexOf(b.kind));
+    }
+    reviewedDiff() {
+        return this.diff;
+    }
+    reset() {
+        this.runs.clear();
+        this.diff = false;
+    }
+}
+exports.VerificationLedger = VerificationLedger;
+/** The most recent `N passed` a test runner printed, e.g. "12 passed", "2,341 tests passed". */
+function parseTestsPassed(output) {
+    const m = /(\d[\d,]*)\s+(?:tests?\s+)?passed\b/i.exec(output);
+    if (!m)
+        return undefined;
+    const n = Number(m[1].replace(/,/g, ''));
+    return Number.isFinite(n) ? n : undefined;
+}
+// ─── criteria ────────────────────────────────────────────────────────────────
+const CRITERION_WORDS = {
+    typecheck: 'typecheck',
+    type: 'typecheck',
+    types: 'typecheck',
+    tsc: 'typecheck',
+    test: 'unit',
+    tests: 'unit',
+    unittests: 'unit',
+    unit: 'unit',
+    jest: 'unit',
+    vitest: 'unit',
+    pytest: 'unit',
+    integration: 'integration',
+    e2e: 'integration',
+    it: 'integration',
+    cypress: 'integration',
+    playwright: 'integration',
+    lint: 'lint',
+    eslint: 'lint',
+    ruff: 'lint',
+    clippy: 'lint',
+    build: 'build',
+    compile: 'build',
+    diff: 'diff',
+    review: 'diff',
+    git: 'diff',
+};
+/**
+ * `/accept unittests typecheck` — the words a user would naturally type. Anything not
+ * understood is reported instead of silently dropped: a criterion the user thinks is
+ * armed but is not would make the panel lie by omission.
+ */
+function parseCriteria(arg) {
+    const ws = arg.trim().split(/\s+/).filter(Boolean);
+    if (!ws.length)
+        return { unknown: [] };
+    if (ws.length === 1 && ws[0].toLowerCase() === 'clear')
+        return { clear: true, unknown: [] };
+    const seen = new Set();
+    const unknown = [];
+    for (const w of ws) {
+        // `type-check`, `unit_tests`, `unit-tests` — separators are noise to a human.
+        const id = CRITERION_WORDS[w.toLowerCase().replace(/[-_]/g, '')];
+        if (id)
+            seen.add(id);
+        else
+            unknown.push(w);
+    }
+    return { criteria: canonicalOrder([...seen]), unknown };
+}
+const order = (id) => (id === 'diff' ? exports.CHECK_KINDS.length : exports.CHECK_KINDS.indexOf(id));
+function canonicalOrder(ids) {
+    return [...new Set(ids)].sort((a, b) => order(a) - order(b));
+}
+function criterionStatus(ledger, id) {
+    if (id === 'diff')
+        return ledger.reviewedDiff() ? 'pass' : 'pending';
+    const run = ledger.get(id);
+    if (!run)
+        return 'pending';
+    return run.ok ? 'pass' : 'fail';
+}
+function unmetCriteria(ledger, criteria) {
+    return criteria.filter((id) => criterionStatus(ledger, id) !== 'pass');
+}
+// ─── rendering ───────────────────────────────────────────────────────────────
+const clip = (s, cols) => (cols > 8 && s.length > cols ? s.slice(0, cols - 1) + '…' : s);
+/**
+ * §83. With criteria declared, every criterion gets a line — the point of declaring them is
+ * to see the ones that have NOT passed. Without criteria, only what actually ran is shown:
+ * a fixed list of five partly-empty rows would train the user to ignore it.
+ */
+function formatVerificationPanel(ledger, criteria, opts) {
+    const cols = opts.cols;
+    const lines = [clip('Verification', cols)];
+    const row = (id) => {
+        const status = criterionStatus(ledger, id);
+        const glyph = status === 'pass' ? '✓' : status === 'fail' ? '✗' : '·';
+        const label = exports.CRITERION_LABELS[id];
+        const run = id === 'diff' ? undefined : ledger.get(id);
+        const why = id === 'diff'
+            ? ledger.reviewedDiff()
+                ? '/diff was opened'
+                : 'not reviewed'
+            : run
+                ? `${run.command}${status === 'fail' ? ' (failed)' : ''}`
+                : 'not run';
+        return clip(`  ${glyph} ${label} — ${why}`, cols);
+    };
+    if (criteria.length) {
+        for (const id of criteria)
+            lines.push(row(id));
+    }
+    else {
+        let shown = 0;
+        for (const kind of exports.CHECK_KINDS)
+            if (ledger.get(kind)) {
+                lines.push(row(kind));
+                shown++;
+            }
+        if (ledger.reviewedDiff()) {
+            lines.push(row('diff'));
+            shown++;
+        }
+        if (!shown)
+            lines.push(clip('  · nothing verified yet — run a check, or /accept to declare criteria', cols));
+    }
+    if (opts.filesChanged !== undefined && opts.filesChanged > 0) {
+        lines.push(clip(`  ${opts.filesChanged} file${opts.filesChanged === 1 ? '' : 's'} changed`, cols));
+    }
+    if (criteria.length) {
+        const wins = ledger.get('unit');
+        if (wins?.ok && wins.testsPassed !== undefined) {
+            lines.push(clip(`  ${wins.testsPassed.toLocaleString('en-US')} tests passed`, cols));
+        }
+    }
+    return lines;
+}
+/**
+ * §82, one line for the END OF A TURN: "the agent should not claim completion until the
+ * configured checks pass". The CLI cannot police the model's prose, but it can make the
+ * unmet criteria impossible to miss — and say nothing at all when everything passed.
+ *
+ * Returns undefined when there is nothing worth saying (no criteria, all met, or — for
+ * the met case — `announce` is false because the panel already showed it).
+ */
+function criteriaLine(ledger, criteria, cols, announceMet = false) {
+    if (!criteria.length)
+        return undefined;
+    const unmet = unmetCriteria(ledger, criteria);
+    if (unmet.length) {
+        const names = unmet.map((id) => exports.CRITERION_LABELS[id]).join(', ');
+        return clip(`⚠ Acceptance criteria not verified: ${names} — /verify to see the panel`, cols);
+    }
+    if (!announceMet)
+        return undefined;
+    const names = criteria.map((id) => exports.CRITERION_LABELS[id]).join(', ');
+    return clip(`✓ Acceptance criteria all verified: ${names}`, cols);
+}
+/** `/accept` with no argument: what is declared, and where each one stands. */
+function formatCriteriaList(ledger, criteria, cols) {
+    if (!criteria.length) {
+        return [clip('  No acceptance criteria set. `/accept test build` arms them; /verify shows the panel.', cols)];
+    }
+    const out = [clip('  Acceptance criteria:', cols)];
+    for (const id of criteria) {
+        const status = criterionStatus(ledger, id);
+        const glyph = status === 'pass' ? '✓' : status === 'fail' ? '✗' : '·';
+        out.push(clip(`    ${glyph} ${exports.CRITERION_LABELS[id]}`, cols));
+    }
+    const unmet = unmetCriteria(ledger, criteria);
+    out.push(clip(unmet.length
+        ? '  The agent has not finished until these pass. /verify for the panel.'
+        : '  All verified this session.', cols));
+    return out;
+}
+//# sourceMappingURL=verification.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexrall/code-core",
-  "version": "1.4.76",
+  "version": "1.4.77",
   "description": "Core agent loop, tools, and extension primitives for Nexrall Code — embed an AI coding agent in any Node.js application.",
   "license": "MIT",
   "author": "Nexrall <support@nexrall.com> (https://nexrall.com)",
@@ -86,11 +86,12 @@
     "prepublishOnly": "npm run build && npm test"
   },
   "dependencies": {
-    "eventsource-parser": "^1.1.2",
-    "node-fetch": "^3.3.2",
     "docx": "^9.7.1",
+    "eventsource-parser": "^1.1.2",
     "exceljs": "^4.4.0",
-    "pptxgenjs": "^4.0.1"
+    "node-fetch": "^3.3.2",
+    "pptxgenjs": "^4.0.1",
+    "socket.io-client": "^4.8.4"
   },
   "devDependencies": {
     "@types/node": "^26.0.1",