zames_pro 2.54.0 → 2.58.0

package/scripts/coverage-gate.mjs

@@ -0,0 +1,83 @@
+import { spawnSync } from 'node:child_process'
+
+// Soft coverage FLOOR for the PURE logic modules — the ones a regression would
+// silently break without any UI symptom (command formatting, schedule parsing,
+// the raw SSE/model-answer parsing). The floors are deliberately a few points
+// BELOW the current values so ordinary churn does not fail the build; they
+// only catch a real drop (a module losing its tests).
+//
+// Node's test runner has no built-in coverage threshold, so we parse the
+// per-file line % from the coverage report it prints and compare here. This is
+// informational in the sense that the FLOORS are conservative, but a drop
+// below one is a hard failure.
+const FLOORS = {
+  'commands.ts': 85,
+  'scheduler.ts': 90,
+  'net-capture.ts': 90,
+  'xml-toolcall.ts': 90,
+  'diff.ts': 90,
+  'theme.ts': 95,
+  // Added later: core logic or already well-tested, so a silent regression
+  // that deletes their tests should be caught too. Floors sit a few points
+  // below the current values.
+  'extraTools.ts': 85,
+  'fsutil.ts': 90,
+  'sessions.ts': 90,
+  'context.ts': 85,
+  'markdown.ts': 90,
+  'tools.ts': 90,
+  'system-prompt.ts': 90,
+  'undo.ts': 85,
+}
+
+const run = spawnSync(
+  'npx',
+  ['tsx', '--test', '--experimental-test-coverage', 'test/*.test.ts'],
+  { encoding: 'utf-8', shell: process.platform === 'win32', maxBuffer: 1024 * 1024 * 64 },
+)
+
+const out = (run.stdout || '') + (run.stderr || '')
+
+if (run.status !== 0) {
+  console.error('coverage-gate: test run failed (exit ' + run.status + ')')
+  process.exit(1)
+}
+
+const linePct = new Map()
+for (const line of out.split('\n')) {
+  // Per-file rows look like:
+  //   ℹ  commands.ts      |  94.14 |  78.70 |  93.88 | 40-56 ...
+  const m = line.match(/^\s*\S?\s*([A-Za-z0-9._-]+\.ts)\s+\|\s+([\d.]+)\s+\|/)
+  if (m) linePct.set(m[1], Number(m[2]))
+}
+
+const failures = []
+for (const [file, floor] of Object.entries(FLOORS)) {
+  const pct = linePct.get(file)
+  if (pct === undefined) {
+    failures.push(file + ': no coverage row found')
+    continue
+  }
+  if (pct < floor) {
+    failures.push(file + ': ' + pct + '% < floor ' + floor + '%')
+  } else {
+    console.log('coverage-gate: ' + file + ' ' + pct + '% >= ' + floor + '%')
+  }
+}
+
+// Print the lowest-covered modules, so a dead or untested module is visible
+// in the CI log even when it has no floor yet. Informational only.
+const sorted = [...linePct.entries()].sort((a, b) => a[1] - b[1]).slice(0, 8)
+if (sorted.length) {
+  console.log('coverage-gate: lowest covered modules (informational):')
+  for (const [name, pct] of sorted) {
+    console.log('  ' + name + ' ' + pct + '%')
+  }
+}
+
+if (failures.length) {
+  console.error('coverage-gate: FAILED')
+  for (const f of failures) console.error('  ' + f)
+  process.exit(1)
+}
+console.log('coverage-gate: OK')

package/dist/confirm.js

@@ -1,105 +0,0 @@
-import * as readlinePromises from 'readline/promises';
-import { theme } from './theme.js';
-import { unifiedDiff, colorDiff } from './diff.js';
-import { translate, DEFAULT_LOCALE } from './i18n.js';
-export class ConfirmManager {
-    settings;
-    alwaysConfirm;
-    allowedForSession;
-    locale;
-    constructor({ config, locale = DEFAULT_LOCALE, } = {}) {
-        const c = config || {};
-        this.locale = locale;
-        this.settings = {
-            write: c.write !== false,
-            edit: c.edit !== false,
-            bash: c.bash !== false,
-        };
-        // An invalid operator-supplied regex must NEVER crash the run. Fall back to
-        // a literal substring match (case-insensitive) for that pattern.
-        this.alwaysConfirm = (c.alwaysConfirm || []).map((p) => {
-            try {
-                return new RegExp(p, 'i');
-            }
-            catch {
-                return new RegExp(escapeRegExp(p), 'i');
-            }
-        });
-        this.allowedForSession = new Set();
-    }
-    _matchesAlwaysConfirm(command) {
-        return this.alwaysConfirm.some((re) => re.test(command));
-    }
-    shouldAsk(kind, target = null) {
-        if (kind === 'bash' && target && this._matchesAlwaysConfirm(target)) {
-            return true;
-        }
-        if (!this.settings[kind])
-            return false;
-        if (this.allowedForSession.has(kind))
-            return false;
-        return true;
-    }
-    // Hot-update the language (from /config lang). The manager holds the locale
-    // so its prompt follows the interface language without a restart.
-    setLocale(locale) {
-        this.locale = locale;
-    }
-    async ask({ kind, target, preview = null, message, }) {
-        if (!this.shouldAsk(kind, target ?? null))
-            return true;
-        if (preview) {
-            console.log(preview);
-        }
-        const t = translate(this.locale);
-        const label = message || t('confirm.ask_label') + ' ' + kind + '?';
-        const question = theme.warn(`${label} `) +
-            theme.system('[') +
-            theme.assistant('y') +
-            theme.system(' = ' + t('common.yes') + ', ') +
-            theme.error('n') +
-            theme.system(' = ' + t('common.no') + ', ') +
-            theme.user('a') +
-            theme.system(' = ' + t('confirm.hint') + '] ');
-        const answer = await this._prompt(question);
-        if (answer === 'a') {
-            if (kind !== 'bash' || !this._matchesAlwaysConfirm(target ?? '')) {
-                this.allowedForSession.add(kind);
-            }
-            return true;
-        }
-        return answer === 'y';
-    }
-    async _prompt(question) {
-        process.stdin.resume();
-        if (process.stdin.isTTY && process.stdin.setRawMode) {
-            process.stdin.setRawMode(false);
-        }
-        const rl = readlinePromises.createInterface({
-            input: process.stdin,
-            output: process.stdout,
-        });
-        try {
-            const ans = await rl.question(question);
-            const v = (ans || '').trim().toLowerCase();
-            if (v === 'a' || v === 'always' || v === 'в')
-                return 'a';
-            if (v === 'y' || v === 'yes' || v === 'д' || v === 'да')
-                return 'y';
-            return 'n';
-        }
-        finally {
-            rl.close();
-        }
-    }
-}
-// Escape a string so it can be used as a literal regex (used when an
-// operator-supplied alwaysConfirm pattern is invalid and we fall back to a
-// substring match).
-function escapeRegExp(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, (m) => '\\' + m);
-}
-export function formatDiffPreview(oldText, newText, { label } = {}) {
-    const diff = unifiedDiff(oldText, newText, { label });
-    return colorDiff(diff);
-}