thumbgate 1.27.16 → 1.27.18

package/scripts/noop-detect.js

@@ -1,285 +0,0 @@
-'use strict';
-
-// scripts/noop-detect.js
-//
-// No-op / redundant-action detection for ThumbGate.
-//
-// Given an action's pre/post state (file diff, command exit code + output),
-// this module decides whether the action actually changed anything OR whether
-// it is byte-identical to an attempt already seen this session. Both are strong,
-// cheap "the agent is looping" repeat signals that plug into
-// track_action -> prevention_rules.
-//
-// Design goals:
-//   * Pure / file-local. No edits to shared modules from inside here.
-//   * Normalize volatile fields (timestamps, shas, ANSI, trailing whitespace)
-//     before hashing so non-deterministic output does not defeat detection.
-//   * Guard partial writes: a truncated after-state that is a strict prefix of
-//     the before-state must NOT be reported as a no-op.
-//
-// Persistence lives beside session-actions.json (derived from
-// gates-engine.SESSION_ACTIONS_PATH) so it picks up THUMBGATE_STATE_DIR
-// overrides and shares the same TTL semantics.
-
-const crypto = require('crypto');
-const fs = require('fs');
-const path = require('path');
-
-const gatesEngine = require('./gates-engine');
-
-// Match the same 1h session window the engine uses for session actions.
-const ATTEMPT_TTL_MS = 60 * 60 * 1000;
-
-// -- volatile-field normalization ------------------------------------------
-//
-// Each pattern strips a class of non-deterministic noise so that two outputs
-// which differ only by a timestamp / sha / uuid / ANSI color / trailing
-// whitespace hash-equal. Exported so the test suite can assert the contract.
-const VOLATILE_PATTERNS = [
-  // ANSI escape / color codes (e.g. \x1b[0m). Strip first so later patterns
-  // see clean text.
-  { name: 'ansi', re: /\x1b\[[0-9;]*[A-Za-z]/g, replacement: '' },
-  // ISO-8601 timestamps: 2026-05-31T12:34:56(.123)?(Z|+00:00)
-  {
-    name: 'iso8601',
-    re: /\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?/g,
-    replacement: '<TS>',
-  },
-  // UUIDs (dashed form) — must run before the hexblob pattern, otherwise the
-  // trailing 12-char hex segment gets rewritten first and the UUID never matches.
-  {
-    name: 'uuid',
-    re: /\b[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}\b/g,
-    replacement: '<UUID>',
-  },
-  // Epoch integers wider than 10 digits (ms/ns timestamps) — run before the
-  // hexblob pattern so all-decimal epochs are not swallowed as hex first.
-  { name: 'epoch', re: /\b\d{11,}\b/g, replacement: '<EPOCH>' },
-  // Long hex blobs (commit shas, uuids without dashes, content hashes): 12+ hex chars.
-  { name: 'hexblob', re: /\b[0-9a-fA-F]{12,}\b/g, replacement: '<HEX>' },
-  // Trailing whitespace is stripped in normalizeVolatile() via a bounded linear
-  // scan (not a regex) to avoid super-linear backtracking on adversarial input.
-];
-
-// Strip trailing spaces/tabs from a single line via a bounded reverse scan.
-// Linear in line length; replaces /[ \t]+$/ without any regex backtracking.
-function stripTrailingSpaceTab(line) {
-  let end = line.length;
-  while (end > 0) {
-    const c = line.charCodeAt(end - 1);
-    if (c !== 32 && c !== 9) break; // 32 = space, 9 = tab
-    end -= 1;
-  }
-  return line.slice(0, end);
-}
-
-// Normalize a string by applying every volatile pattern, then trimming a
-// trailing newline so "foo\n" and "foo" are equivalent.
-function normalizeVolatile(value) {
-  if (value === null || value === undefined) return '';
-  let out = String(value);
-  for (const pattern of VOLATILE_PATTERNS) {
-    out = out.replace(pattern.re, pattern.replacement);
-  }
-  // Strip trailing space/tab per line without a backtracking-prone regex.
-  out = out.split('\n').map(stripTrailingSpaceTab).join('\n');
-  // Normalize CRLF, then strip the trailing run of newlines via a bounded
-  // linear scan (replaces /\n+$/ without regex backtracking).
-  out = out.replace(/\r\n/g, '\n');
-  let end = out.length;
-  while (end > 0 && out.charCodeAt(end - 1) === 10) end -= 1; // 10 = \n
-  return out.slice(0, end);
-}
-
-function sha256(value) {
-  return crypto.createHash('sha256').update(value, 'utf8').digest('hex');
-}
-
-// -- state hashing ----------------------------------------------------------
-//
-// computeActionStateHash produces a single stable fingerprint for an action's
-// observable state. For file actions the fingerprint is the normalized content;
-// for command actions it is exit code + normalized stdout/stderr.
-function computeActionStateHash(action = {}) {
-  const kind = action.kind === 'command' ? 'command' : 'file';
-
-  if (kind === 'command') {
-    const exitCode = action.exitCode === undefined || action.exitCode === null
-      ? ''
-      : String(action.exitCode);
-    const parts = [
-      'command',
-      `exit:${exitCode}`,
-      `stdout:${normalizeVolatile(action.stdout)}`,
-      `stderr:${normalizeVolatile(action.stderr)}`,
-    ];
-    return sha256(parts.join('\x00'));
-  }
-
-  // file kind: hash the relevant content (after-content is the canonical state
-  // for a single snapshot; for diff comparisons detectNoop compares before/after
-  // separately). Include filePath so two unrelated files never collide.
-  const content = action.afterContent !== undefined && action.afterContent !== null
-    ? action.afterContent
-    : action.beforeContent;
-  const parts = [
-    'file',
-    `path:${action.filePath || ''}`,
-    `content:${normalizeVolatile(content)}`,
-  ];
-  return sha256(parts.join('\x00'));
-}
-
-// Hash just a content blob for before/after comparison (no path/kind framing).
-function contentHash(content) {
-  return sha256(normalizeVolatile(content));
-}
-
-// -- no-op detection --------------------------------------------------------
-//
-// detectNoop({ before, after }) returns { noop, reason }.
-//   before/after: { kind, filePath, beforeContent/afterContent OR content,
-//                   exitCode, stdout, stderr }
-//
-// We accept a flexible shape: the caller may pass a single action object with
-// beforeContent/afterContent, or split before/after sub-objects. Both forms
-// resolve to the same decision.
-function detectNoop(input = {}) {
-  const before = input.before || {};
-  const after = input.after || {};
-
-  // Determine kind from whichever side declares it (default file).
-  const kind = (before.kind || after.kind || input.kind) === 'command'
-    ? 'command'
-    : 'file';
-
-  if (kind === 'command') {
-    const beforeExit = before.exitCode;
-    const afterExit = after.exitCode;
-    if (beforeExit !== undefined && afterExit !== undefined && beforeExit !== afterExit) {
-      return { noop: false, reason: 'exit-code-changed' };
-    }
-    const beforeOut = contentHash(`${normalizeVolatile(before.stdout)}\x00${normalizeVolatile(before.stderr)}`);
-    const afterOut = contentHash(`${normalizeVolatile(after.stdout)}\x00${normalizeVolatile(after.stderr)}`);
-    if (beforeOut === afterOut) {
-      return { noop: true, reason: 'command-output-unchanged' };
-    }
-    return { noop: false, reason: 'command-output-changed' };
-  }
-
-  // file kind.
-  const beforeContent = before.content !== undefined ? before.content
-    : (before.beforeContent !== undefined ? before.beforeContent : input.beforeContent);
-  const afterContent = after.content !== undefined ? after.content
-    : (after.afterContent !== undefined ? after.afterContent : input.afterContent);
-
-  const beforeStr = beforeContent === undefined || beforeContent === null ? '' : String(beforeContent);
-  const afterStr = afterContent === undefined || afterContent === null ? '' : String(afterContent);
-
-  // Partial-write guard: an after-state that is a strict, shorter prefix of the
-  // before-state is a truncation, not a no-op — even though hashes differ, we
-  // make the intent explicit so callers never mistake it.
-  if (afterStr.length > 0 && afterStr.length < beforeStr.length && beforeStr.startsWith(afterStr)) {
-    return { noop: false, reason: 'partial-write-truncation' };
-  }
-
-  if (contentHash(beforeStr) === contentHash(afterStr)) {
-    return { noop: true, reason: 'file-content-unchanged' };
-  }
-  return { noop: false, reason: 'file-content-changed' };
-}
-
-// -- attempt persistence ----------------------------------------------------
-//
-// Stores (sessionId -> { "actionId\x00stateHash": timestamp }) so a repeated
-// (actionId, stateHash) tuple within the TTL window is a strong repeat signal.
-function attemptsPath() {
-  const sessionActionsPath = gatesEngine.SESSION_ACTIONS_PATH;
-  return path.join(path.dirname(sessionActionsPath), 'noop-attempts.json');
-}
-
-function loadAttempts() {
-  try {
-    const raw = fs.readFileSync(attemptsPath(), 'utf8');
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== 'object') return {};
-    return parsed;
-  } catch (e) {
-    return {};
-  }
-}
-
-function pruneExpired(store, now) {
-  let changed = false;
-  for (const sessionId of Object.keys(store)) {
-    const bucket = store[sessionId];
-    if (!bucket || typeof bucket !== 'object') {
-      delete store[sessionId];
-      changed = true;
-      continue;
-    }
-    for (const key of Object.keys(bucket)) {
-      const ts = bucket[key];
-      if (typeof ts !== 'number' || now - ts >= ATTEMPT_TTL_MS) {
-        delete bucket[key];
-        changed = true;
-      }
-    }
-    if (Object.keys(bucket).length === 0) {
-      delete store[sessionId];
-      changed = true;
-    }
-  }
-  return changed;
-}
-
-function saveAttempts(store) {
-  const file = attemptsPath();
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, JSON.stringify(store, null, 2) + '\n');
-}
-
-function attemptKey(actionId, stateHash) {
-  return `${String(actionId)}\x00${String(stateHash)}`;
-}
-
-// recordActionAttempt persists that (sessionId, actionId, stateHash) was seen.
-// Returns { recorded: boolean, alreadySeen: boolean }.
-function recordActionAttempt(sessionId, actionId, stateHash) {
-  const sid = String(sessionId || 'default');
-  const now = Date.now();
-  const store = loadAttempts();
-  pruneExpired(store, now);
-
-  if (!store[sid] || typeof store[sid] !== 'object') store[sid] = {};
-  const key = attemptKey(actionId, stateHash);
-  const alreadySeen = Object.prototype.hasOwnProperty.call(store[sid], key);
-  store[sid][key] = now;
-  saveAttempts(store);
-  return { recorded: true, alreadySeen };
-}
-
-// isRepeatAttempt returns true when this exact (actionId, stateHash) tuple was
-// already recorded for this session within the TTL window.
-function isRepeatAttempt(sessionId, actionId, stateHash) {
-  const sid = String(sessionId || 'default');
-  const now = Date.now();
-  const store = loadAttempts();
-  const bucket = store[sid];
-  if (!bucket || typeof bucket !== 'object') return false;
-  const ts = bucket[attemptKey(actionId, stateHash)];
-  if (typeof ts !== 'number') return false;
-  return now - ts < ATTEMPT_TTL_MS;
-}
-
-module.exports = {
-  VOLATILE_PATTERNS,
-  ATTEMPT_TTL_MS,
-  normalizeVolatile,
-  computeActionStateHash,
-  detectNoop,
-  recordActionAttempt,
-  isRepeatAttempt,
-  // Exposed for tests / introspection.
-  attemptsPath,
-};

package/scripts/omlx-smoke.js

@@ -1,192 +0,0 @@
-#!/usr/bin/env node
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-function loadDotEnv(filePath = path.join(process.cwd(), '.env')) {
-  if (!fs.existsSync(filePath)) return false;
-  const text = fs.readFileSync(filePath, 'utf8');
-  for (const line of text.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-    const eq = trimmed.indexOf('=');
-    if (eq <= 0) continue;
-    const key = trimmed.slice(0, eq).trim();
-    const rawValue = trimmed.slice(eq + 1).trim();
-    if (!key || process.env[key]) continue;
-    process.env[key] = rawValue.replace(/^['"]|['"]$/g, '');
-  }
-  return true;
-}
-
-function parseArgs(argv = []) {
-  const out = {
-    json: argv.includes('--json'),
-    requireLive: argv.includes('--require-live'),
-    chat: argv.includes('--chat'),
-    baseUrl: null,
-    model: null,
-  };
-
-  for (let i = 0; i < argv.length; i += 1) {
-    if (argv[i] === '--base-url') out.baseUrl = argv[++i];
-    if (argv[i] === '--model') out.model = argv[++i];
-  }
-
-  return out;
-}
-
-function normalizeBaseUrl(baseUrl) {
-  return String(baseUrl || '')
-    .replace(/\/chat\/completions\/?$/i, '')
-    .replace(/\/models\/?$/i, '')
-    .replace(/\/+$/, '');
-}
-
-function extractModels(payload) {
-  const data = Array.isArray(payload?.data) ? payload.data : [];
-  return data
-    .map((entry) => {
-      if (typeof entry === 'string') return entry;
-      if (entry && typeof entry === 'object') return entry.id || entry.name || null;
-      return null;
-    })
-    .filter(Boolean);
-}
-
-async function fetchModels(baseUrl, fetchImpl = global.fetch) {
-  if (typeof fetchImpl !== 'function') {
-    return { ok: false, status: 'fetch_unavailable', models: [] };
-  }
-
-  const url = `${normalizeBaseUrl(baseUrl)}/models`;
-  try {
-    const response = await fetchImpl(url, { method: 'GET' });
-    if (!response || !response.ok) {
-      return {
-        ok: false,
-        status: 'models_endpoint_failed',
-        httpStatus: response?.status || null,
-        url,
-        models: [],
-      };
-    }
-    const payload = await response.json();
-    return {
-      ok: true,
-      status: 'models_ready',
-      httpStatus: response.status || 200,
-      url,
-      models: extractModels(payload),
-    };
-  } catch (error) {
-    return {
-      ok: false,
-      status: 'models_endpoint_error',
-      url,
-      message: error?.message || String(error),
-      models: [],
-    };
-  }
-}
-
-async function run(options = {}) {
-  loadDotEnv();
-  const {
-    callOmlx,
-    getOmlxBaseUrl,
-    getOmlxModel,
-  } = require('./llm-client');
-
-  const baseUrl = normalizeBaseUrl(options.baseUrl || getOmlxBaseUrl());
-  const modelsResult = await fetchModels(baseUrl, options.fetchImpl || global.fetch);
-  const configuredModel = options.model || getOmlxModel();
-  const selectedModel = options.model || modelsResult.models[0] || configuredModel;
-  const result = {
-    ok: modelsResult.ok,
-    status: modelsResult.status,
-    provider: 'omlx',
-    baseUrl,
-    model: selectedModel,
-    models: modelsResult.models,
-    modelsUrl: modelsResult.url,
-    httpStatus: modelsResult.httpStatus || null,
-  };
-
-  if (!modelsResult.ok) {
-    result.message = modelsResult.message || 'oMLX /v1/models is not reachable';
-    if (options.requireLive) process.exitCode = 1;
-    return result;
-  }
-
-  if (!options.chat) {
-    result.status = modelsResult.models.length > 0 ? 'models_ready' : 'models_empty';
-    result.ok = !options.requireLive || modelsResult.models.length > 0;
-    if (!result.ok) process.exitCode = 1;
-    return result;
-  }
-
-  process.env.THUMBGATE_OMLX_ENABLED = '1';
-  process.env.THUMBGATE_OMLX_BASE_URL = baseUrl;
-  process.env.THUMBGATE_OMLX_MODEL = selectedModel;
-
-  const chat = await callOmlx({
-    systemPrompt: 'You are a local inference smoke test.',
-    userPrompt: 'Say that ThumbGate local oMLX inference is reachable.',
-    maxTokens: 64,
-    temperature: 0,
-    returnMetadata: true,
-  });
-
-  if (!chat || typeof chat.text !== 'string' || chat.text.trim().length < 1) {
-    process.exitCode = 1;
-    return {
-      ...result,
-      ok: false,
-      status: 'chat_failed',
-      message: 'oMLX /v1/chat/completions did not return assistant text',
-    };
-  }
-
-  return {
-    ...result,
-    ok: true,
-    status: 'ready',
-    model: chat.model || selectedModel,
-    textPreview: chat.text.slice(0, 200),
-    usage: chat.usage || null,
-  };
-}
-
-async function main(argv = process.argv.slice(2)) {
-  const options = parseArgs(argv);
-  const result = await run(options);
-  if (options.json) {
-    console.log(JSON.stringify(result, null, 2));
-    return;
-  }
-
-  console.log(`oMLX smoke status: ${result.status}`);
-  console.log(`Provider: ${result.provider}`);
-  console.log(`Base URL: ${result.baseUrl}`);
-  console.log(`Model: ${result.model}`);
-  console.log(`Models: ${result.models.length}`);
-  console.log(`Result: ${result.ok ? 'ready' : result.message || 'not ready'}`);
-}
-
-if (require.main === module) {
-  main().catch((error) => {
-    console.error(error?.message || error);
-    process.exit(1);
-  });
-}
-
-module.exports = {
-  loadDotEnv,
-  parseArgs,
-  normalizeBaseUrl,
-  extractModels,
-  fetchModels,
-  run,
-};