agentic-qe 3.14.5 → 3.14.6

package/dist/learning/sqlite-persistence.js

@@ -54,6 +54,13 @@ export function hashEmbedding(text, dimension = 384) {
     }
     return embedding;
 }
+/**
+ * Lowercased letter/digit tokens with diacritics removed, approximating the
+ * FTS5 unicode61 tokenizer so query terms and stored text compare alike.
+ */
+function ftsTokens(text) {
+    return text.normalize('NFKD').replace(/\p{M}+/gu, '').toLowerCase().match(/[\p{L}\p{N}]+/gu) ?? [];
+}
 /**
  * SQLite-based pattern persistence
  */
@@ -465,20 +472,29 @@ export class SQLitePatternStore {
     }
     /**
      * FTS5 full-text search for patterns.
-     * Returns pattern IDs with BM25 relevance scores.
+     * Returns pattern IDs with BM25 relevance scores. `phrase` marks hits that
+     * also contain the whole query as a phrase (near-duplicate evidence).
+     * `coverage` is the fraction of distinct query terms the hit contains: an
+     * absolute measure, unlike `ftsScore`, which is relative to the best hit.
      */
     searchFTS(query, limit = 20) {
         if (!this.db)
             throw new Error('Database not initialized');
         if (!query.trim())
             return [];
-        // Sanitize: wrap in double quotes to force literal phrase match,
-        // escaping any internal double quotes to prevent FTS5 syntax injection
-        const sanitized = '"' + query.replace(/"/g, '""') + '"';
+        // #653: match any query term (BM25 ranks docs matching more/rarer terms
+        // higher). A whole-query phrase almost never matched sentence-style task
+        // queries. Terms are letters/digits only, quoted, so FTS5 syntax can't leak in.
+        const terms = [...new Set(ftsTokens(query))]
+            .filter(term => term.length >= 2)
+            .slice(0, 32);
+        if (terms.length === 0)
+            return [];
+        const sanitized = terms.map(term => `"${term}"`).join(' OR ');
         const start = performance.now();
         try {
             const rows = this.db.prepare(`
-        SELECT p.id, rank AS fts_score
+        SELECT p.id, rank AS fts_score, p.name, p.description, p.pattern_type, p.qe_domain
         FROM qe_patterns_fts fts
         JOIN qe_patterns p ON p.rowid = fts.rowid
         WHERE qe_patterns_fts MATCH ?
@@ -494,16 +510,40 @@ export class SQLitePatternStore {
             // Use Math.max(maxScore, 1.0) to prevent single-result inflation:
             // without this, a single FTS5 result always normalizes to 1.0
             const maxAbsScore = Math.max(...rows.map(r => Math.abs(r.fts_score)), 1.0);
-            return rows.map(r => ({
-                id: r.id,
-                ftsScore: Math.abs(r.fts_score) / maxAbsScore,
-            }));
+            const phraseIds = rows.length > 0 ? this.searchFTSPhraseIds(query, limit) : new Set();
+            return rows.map(r => {
+                const docTerms = new Set(ftsTokens([r.name, r.description, r.pattern_type, r.qe_domain].filter(Boolean).join(' ')));
+                const matched = terms.filter(term => docTerms.has(term)).length;
+                return {
+                    id: r.id,
+                    ftsScore: Math.abs(r.fts_score) / maxAbsScore,
+                    phrase: phraseIds.has(r.id),
+                    coverage: matched / terms.length,
+                };
+            });
         }
         catch {
             // FTS5 table may not exist yet (unified DB migrated before schema update)
             return [];
         }
     }
+    /** IDs whose FTS5 text contains the whole query as one phrase. */
+    searchFTSPhraseIds(query, limit) {
+        // Whole query quoted as one phrase, internal quotes escaped (FTS5 syntax-safe)
+        const phrase = '"' + query.replace(/"/g, '""') + '"';
+        try {
+            const rows = this.db.prepare(`
+        SELECT p.id FROM qe_patterns_fts fts
+        JOIN qe_patterns p ON p.rowid = fts.rowid
+        WHERE qe_patterns_fts MATCH ?
+        LIMIT ?
+      `).all(phrase, limit);
+            return new Set(rows.map(r => r.id));
+        }
+        catch {
+            return new Set();
+        }
+    }
     /** Last FTS5 search latency in ms, for instrumentation */
     _lastFtsLatencyMs = 0;
     get lastFtsLatencyMs() { return this._lastFtsLatencyMs; }

package/dist/logging/console-logger.d.ts

@@ -69,13 +69,10 @@ export declare class ConsoleLogger implements Logger {
      */
     private mergeContext;
     /**
-     * Format context object for display
+     * Format context object for display. The context is first reduced to a
+     * redacted, bounded, cycle-free copy (#740), so it serializes safely.
      */
     private formatContext;
-    /**
-     * Create a JSON replacer that handles circular references and depth limiting
-     */
-    private createReplacer;
 }
 /**
  * No-op Logger implementation for use when logging is disabled

package/dist/logging/console-logger.js

@@ -10,6 +10,7 @@
  * - Error stack trace handling
  */
 import { LogLevel, LOG_LEVEL_NAMES, } from './logger.js';
+import { redactLogText, redactLogValue } from './redaction.js';
 /**
  * Default configuration for ConsoleLogger
  */
@@ -61,11 +62,11 @@ export class ConsoleLogger {
                 if (error.stack) {
                     errorContext.stack = error.stack;
                 }
-                // Capture any additional properties on the error
+                // Keep the cause structured; format() redacts it with everything else
                 // Use type assertion for ES2022 Error.cause compatibility
                 const errorWithCause = error;
                 if (errorWithCause.cause !== undefined) {
-                    errorContext.cause = String(errorWithCause.cause);
+                    errorContext.cause = errorWithCause.cause;
                 }
             }
             this.output(LogLevel.ERROR, message, errorContext);
@@ -115,8 +116,8 @@ export class ConsoleLogger {
         }
         // Add domain
         parts.push(`[${this.domain}]`);
-        // Add message
-        parts.push(message);
+        // Add message (#740: redaction is a sink invariant, at every level)
+        parts.push(redactLogText(message));
         // Add context if provided
         const mergedContext = this.mergeContext(context);
         if (mergedContext && Object.keys(mergedContext).length > 0) {
@@ -159,58 +160,21 @@ export class ConsoleLogger {
         };
     }
     /**
-     * Format context object for display
+     * Format context object for display. The context is first reduced to a
+     * redacted, bounded, cycle-free copy (#740), so it serializes safely.
      */
     formatContext(context) {
         try {
+            const safe = redactLogValue(context, { maxDepth: this.config.maxContextDepth + 1 });
             if (this.config.prettyPrint) {
-                return '\n' + JSON.stringify(context, this.createReplacer(), 2);
+                return '\n' + JSON.stringify(safe, null, 2);
             }
-            return JSON.stringify(context, this.createReplacer());
+            return JSON.stringify(safe);
         }
         catch {
             return '[unserializable context]';
         }
     }
-    /**
-     * Create a JSON replacer that handles circular references and depth limiting
-     */
-    createReplacer() {
-        const seen = new WeakSet();
-        let depth = 0;
-        return (_key, value) => {
-            // Handle depth limiting
-            if (typeof value === 'object' && value !== null) {
-                if (depth >= this.config.maxContextDepth) {
-                    return '[object]';
-                }
-                // Handle circular references
-                if (seen.has(value)) {
-                    return '[circular]';
-                }
-                seen.add(value);
-                depth++;
-            }
-            // Handle special types
-            if (value instanceof Error) {
-                return {
-                    name: value.name,
-                    message: value.message,
-                    stack: value.stack,
-                };
-            }
-            if (typeof value === 'bigint') {
-                return value.toString();
-            }
-            if (typeof value === 'function') {
-                return '[function]';
-            }
-            if (typeof value === 'symbol') {
-                return value.toString();
-            }
-            return value;
-        };
-    }
 }
 /**
  * No-op Logger implementation for use when logging is disabled

package/dist/logging/index.d.ts

@@ -39,4 +39,6 @@ export type { ConsoleLoggerConfig } from './console-logger.js';
 export { ConsoleLogger, NullLogger, DEFAULT_CONSOLE_LOGGER_CONFIG } from './console-logger.js';
 export type { LoggerFactoryConfig, LoggerProvider } from './logger-factory.js';
 export { LoggerFactory, createLogger, getLogger } from './logger-factory.js';
+export type { LogRedactionOptions } from './redaction.js';
+export { redactLogValue, redactLogText, formatErrorForLog, isSensitiveLogKey } from './redaction.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/logging/index.js

@@ -36,4 +36,5 @@
 export { LogLevel, LOG_LEVEL_NAMES, parseLogLevel, isLogger } from './logger.js';
 export { ConsoleLogger, NullLogger, DEFAULT_CONSOLE_LOGGER_CONFIG } from './console-logger.js';
 export { LoggerFactory, createLogger, getLogger } from './logger-factory.js';
+export { redactLogValue, redactLogText, formatErrorForLog, isSensitiveLogKey } from './redaction.js';
 //# sourceMappingURL=index.js.map

package/dist/logging/redaction.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Agentic QE v3 - Log redaction (issue #740)
+ *
+ * Sink-side sanitizer applied before any log text is written. Redacts values
+ * under sensitive keys and credential-shaped strings anywhere in a value.
+ * Non-mutating, cycle-safe, bounded, never invokes getters or toJSON, and
+ * fails closed: a value that cannot be inspected is replaced, not printed.
+ *
+ * Heuristic redaction is defense in depth: it does not replace keeping
+ * payloads, headers and configuration out of log events in the first place.
+ */
+export interface LogRedactionOptions {
+    /** Nesting depth beyond which objects become '[object]' */
+    maxDepth?: number;
+    /** Array items / object keys kept per level */
+    maxEntries?: number;
+    /** Characters kept per string after redaction */
+    maxStringLength?: number;
+}
+export declare function isSensitiveLogKey(key: string): boolean;
+/** Redact credential-shaped substrings from free text. */
+export declare function redactLogText(text: string, maxLength?: number): string;
+/** Return a sanitized, JSON-safe copy of `value`. The input is never modified. */
+export declare function redactLogValue(value: unknown, options?: LogRedactionOptions): unknown;
+/** Render a thrown value (Error or not) as redacted text for direct console output. */
+export declare function formatErrorForLog(error: unknown): string;
+//# sourceMappingURL=redaction.d.ts.map

package/dist/logging/redaction.js

@@ -0,0 +1,170 @@
+/**
+ * Agentic QE v3 - Log redaction (issue #740)
+ *
+ * Sink-side sanitizer applied before any log text is written. Redacts values
+ * under sensitive keys and credential-shaped strings anywhere in a value.
+ * Non-mutating, cycle-safe, bounded, never invokes getters or toJSON, and
+ * fails closed: a value that cannot be inspected is replaced, not printed.
+ *
+ * Heuristic redaction is defense in depth: it does not replace keeping
+ * payloads, headers and configuration out of log events in the first place.
+ */
+import { redact } from '../routing/advisor/redaction.js';
+const DEFAULTS = { maxDepth: 6, maxEntries: 100, maxStringLength: 8192 };
+/** Strings above this size are dropped rather than scanned. */
+const MAX_SCAN_LENGTH = 1_000_000;
+const SENSITIVE_KEYS = new Set([
+    'auth', 'dsn', 'pwd', 'proxyauthorization', 'setcookie', 'sessionid',
+]);
+const SENSITIVE_SUFFIXES = [
+    'token', 'secret', 'password', 'passwd', 'passphrase', 'apikey', 'privatekey',
+    'accesskey', 'secretkey', 'credential', 'credentials', 'cookie', 'authorization',
+    'sessionid', 'connectionstring',
+];
+/** Log-specific credential shapes, applied before the shared advisor patterns. */
+const LOG_PATTERNS = [
+    // Anchored on '://' rather than a scheme prefix: `\b[a-z][a-z0-9+.-]*://`
+    // backtracks quadratically on inputs such as 'a.a.a.…' (seconds per call at
+    // 100 KB). The scheme is left in place; an empty user (://:pw@) is covered.
+    [/(:\/\/)[^\s/@:"']*:[^\s/@"']+@/g, '$1<REDACTED:credentials>@'],
+    [/\b(Bearer|Basic)\s+[A-Za-z0-9._~+/=-]{8,}/gi, '$1 <REDACTED:credential>'],
+    [/\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{16,}/g, '<REDACTED:api_key>'],
+    [/\b(set-cookie|cookie):\s*[^\n]+/gi, '$1: <REDACTED:cookie>'],
+    // Compound query/assignment keys the shared pattern misses: access_token=, client_secret=
+    [/\b([A-Za-z0-9_-]{0,64}?[_-](?:token|secret|password|passwd))=([^\s&"'#]+)/gi, '$1=<REDACTED:credential>'],
+];
+/**
+ * JSON / repr serialized fields ("apiKey":"…", 'password': 123). The key is
+ * checked with isSensitiveLogKey() so text and structured values agree.
+ * Unterminated strings are redacted to end of line (fail closed).
+ */
+const SERIALIZED_FIELD = /(["'])([A-Za-z0-9_.-]{1,64})\1(\s*:\s*)("(?:[^"\\\n]|\\.)*"?|'(?:[^'\\\n]|\\.)*'?|-?\d[\d.eE+-]*)/g;
+function redactSerializedFields(text) {
+    return text.replace(SERIALIZED_FIELD, (match, q, key, sep) => isSensitiveLogKey(key) ? `${q}${key}${q}${sep}${q}<REDACTED:sensitive-key>${q}` : match);
+}
+export function isSensitiveLogKey(key) {
+    const normalized = key.toLowerCase().replace(/[^a-z0-9]/g, '');
+    return SENSITIVE_KEYS.has(normalized) || SENSITIVE_SUFFIXES.some(suffix => normalized.endsWith(suffix));
+}
+/** Redact credential-shaped substrings from free text. */
+export function redactLogText(text, maxLength = DEFAULTS.maxStringLength) {
+    // Untyped (JS / `any`) callers may pass a non-string message; render it
+    // safely instead of throwing from inside the logger.
+    if (typeof text !== 'string')
+        return formatErrorForLog(text);
+    if (text.length > MAX_SCAN_LENGTH)
+        return `[REDACTED:size-limit ${text.length} chars]`;
+    let result = text;
+    for (const [regex, replacement] of LOG_PATTERNS)
+        result = result.replace(regex, replacement);
+    result = redactSerializedFields(result);
+    result = redact(result, 'balanced').text;
+    return result.length > maxLength
+        ? `${result.slice(0, maxLength)}…[truncated ${result.length - maxLength} chars]`
+        : result;
+}
+/** Return a sanitized, JSON-safe copy of `value`. The input is never modified. */
+export function redactLogValue(value, options = {}) {
+    return sanitize(value, { ...DEFAULTS, ...options }, 0, []);
+}
+/** Render a thrown value (Error or not) as redacted text for direct console output. */
+export function formatErrorForLog(error) {
+    try {
+        if (error instanceof Error) {
+            let text = redactLogText(error.stack || `${error.name}: ${error.message}`);
+            let cause = error.cause;
+            for (let hops = 0; cause !== undefined && hops < 3; hops++) {
+                text += `\nCaused by: ${cause instanceof Error
+                    ? redactLogText(cause.stack || `${cause.name}: ${cause.message}`)
+                    : JSON.stringify(redactLogValue(cause, { maxDepth: 3 }))}`;
+                cause = cause instanceof Error ? cause.cause : undefined;
+            }
+            return text;
+        }
+        return typeof error === 'string'
+            ? redactLogText(error)
+            : JSON.stringify(redactLogValue(error, { maxDepth: 3 })) ?? String(error);
+    }
+    catch {
+        return '[REDACTED:sanitization-failed]';
+    }
+}
+function sanitize(value, opts, depth, ancestors) {
+    try {
+        if (value === null || value === undefined || typeof value === 'number' || typeof value === 'boolean')
+            return value;
+        if (typeof value === 'string')
+            return redactLogText(value, opts.maxStringLength);
+        if (typeof value === 'bigint')
+            return value.toString();
+        if (typeof value === 'symbol')
+            return value.toString();
+        if (typeof value === 'function')
+            return '[function]';
+        const obj = value;
+        if (ancestors.includes(obj))
+            return '[circular]';
+        if (depth >= opts.maxDepth)
+            return '[object]';
+        if (ArrayBuffer.isView(obj))
+            return `[binary ${obj.byteLength} bytes]`;
+        if (obj instanceof ArrayBuffer)
+            return `[binary ${obj.byteLength} bytes]`;
+        if (obj instanceof Date)
+            return Number.isNaN(obj.getTime()) ? '[invalid date]' : obj.toISOString();
+        if (obj instanceof Map || obj instanceof Set)
+            return `[${obj.constructor.name}(${obj.size})]`;
+        const path = [...ancestors, obj];
+        if (Array.isArray(obj)) {
+            const items = obj.slice(0, opts.maxEntries).map(item => sanitize(item, opts, depth + 1, path));
+            if (obj.length > opts.maxEntries)
+                items.push(`[+${obj.length - opts.maxEntries} more]`);
+            return items;
+        }
+        if (obj instanceof Error)
+            return sanitizeError(obj, opts, depth, path);
+        return sanitizeRecord(obj, Object.keys(obj), opts, depth, path);
+    }
+    catch {
+        return '[REDACTED:sanitization-failed]';
+    }
+}
+function sanitizeError(error, opts, depth, path) {
+    const out = {
+        name: redactLogText(String(error.name), opts.maxStringLength),
+        message: redactLogText(String(error.message), opts.maxStringLength),
+    };
+    if (typeof error.stack === 'string')
+        out.stack = redactLogText(error.stack, opts.maxStringLength);
+    const code = error.code;
+    if (typeof code === 'string' || typeof code === 'number')
+        out.code = code;
+    const cause = error.cause;
+    if (cause !== undefined)
+        out.cause = sanitize(cause, opts, depth + 1, path);
+    return out;
+}
+function sanitizeRecord(obj, keys, opts, depth, path) {
+    const out = {};
+    for (const key of keys.slice(0, opts.maxEntries)) {
+        const descriptor = Object.getOwnPropertyDescriptor(obj, key);
+        if (!descriptor)
+            continue;
+        if (!('value' in descriptor)) {
+            out[key] = '[getter]';
+            continue;
+        }
+        const v = descriptor.value;
+        // Numbers are redacted too (numeric PINs, session IDs); counters such as
+        // maxTokens/tokensUsed do not match a sensitive suffix in the first place.
+        if (isSensitiveLogKey(key) && v !== null && v !== undefined && typeof v !== 'boolean') {
+            out[key] = '[REDACTED:sensitive-key]';
+            continue;
+        }
+        out[key] = sanitize(v, opts, depth + 1, path);
+    }
+    if (keys.length > opts.maxEntries)
+        out['[truncated]'] = `${keys.length - opts.maxEntries} more keys`;
+    return out;
+}
+//# sourceMappingURL=redaction.js.map