@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/providers/provider-definitions.mjs

@@ -0,0 +1,159 @@
+import { homedir } from 'os';
+import { resolve } from 'path';
+
+const MCP_INJECTION_DEFINITIONS = [
+  {
+    id: 'claude',
+    aliases: ['claude-code'],
+    mcp: {
+      providerId: 'claude-code',
+      includeInSupportedProviders: true,
+      configFormat: 'json',
+      serverConfigFormat: 'standard',
+      serversKey: 'mcpServers',
+      configPath: { scope: 'project', path: '.claude/settings.local.json' },
+      supportsEphemeral: true,
+    },
+  },
+  {
+    id: 'cursor',
+    aliases: [],
+    mcp: {
+      providerId: 'cursor',
+      includeInSupportedProviders: true,
+      configFormat: 'json',
+      serverConfigFormat: 'standard',
+      serversKey: 'mcpServers',
+      configPath: { scope: 'project', path: '.cursor/mcp.json' },
+      supportsEphemeral: true,
+    },
+  },
+  {
+    id: 'factory',
+    aliases: ['factory-ai'],
+    mcp: {
+      providerId: 'factory',
+      includeInSupportedProviders: true,
+      configFormat: 'json',
+      serverConfigFormat: 'factory',
+      serversKey: 'mcpServers',
+      configPath: { scope: 'home', path: '.factory/mcp.json' },
+      supportsEphemeral: true,
+    },
+  },
+  {
+    id: 'codex',
+    aliases: ['openai'],
+    mcp: {
+      providerId: 'codex',
+      acceptedProviderIds: ['openai'],
+      includeInSupportedProviders: true,
+      configFormat: 'toml',
+      serverConfigFormat: 'toml',
+      serversKey: null,
+      configPath: { scope: 'home', path: '.codex/config.toml' },
+      supportsEphemeral: true,
+    },
+  },
+  {
+    id: 'opencode',
+    aliases: [],
+    mcp: {
+      providerId: 'opencode',
+      includeInSupportedProviders: true,
+      configFormat: 'json',
+      serverConfigFormat: 'opencode',
+      serversKey: 'mcp',
+      configPath: { scope: 'project', path: 'opencode.json' },
+      supportsEphemeral: true,
+    },
+  },
+  {
+    id: 'windsurf',
+    aliases: ['devin-desktop'],
+    mcp: {
+      providerId: 'windsurf',
+      includeInSupportedProviders: true,
+      configFormat: 'json',
+      serverConfigFormat: 'standard',
+      serversKey: 'mcpServers',
+      configPath: { scope: 'home', path: '.codeium/windsurf/mcp_config.json' },
+      supportsEphemeral: true,
+    },
+  },
+  {
+    id: 'warp',
+    aliases: [],
+    mcp: {
+      providerId: 'warp',
+      includeInSupportedProviders: true,
+      configFormat: 'json',
+      serverConfigFormat: 'standard',
+      serversKey: 'mcpServers',
+      configPath: { scope: 'home', path: '.warp/mcp.json' },
+      supportsEphemeral: false,
+      unsupportedReason: 'Warp configures MCP servers via its UI only. No file-based ephemeral config is available.',
+    },
+  },
+];
+
+function allMcpProviderIds(definition) {
+  return [
+    definition.id,
+    ...definition.aliases,
+    definition.mcp.providerId,
+    ...(definition.mcp.acceptedProviderIds || []),
+  ];
+}
+
+export function listRuntimeProviderDefinitions() {
+  return MCP_INJECTION_DEFINITIONS.map((definition) => ({
+    ...definition,
+    aliases: [...definition.aliases],
+    mcp: {
+      ...definition.mcp,
+      acceptedProviderIds: [...(definition.mcp.acceptedProviderIds || [])],
+      configPath: { ...definition.mcp.configPath },
+    },
+  }));
+}
+
+export function normalizeRuntimeProviderId(provider) {
+  const candidate = provider?.trim().toLowerCase();
+  if (!candidate) return null;
+
+  for (const definition of MCP_INJECTION_DEFINITIONS) {
+    if (allMcpProviderIds(definition).includes(candidate)) {
+      return definition.mcp.providerId;
+    }
+  }
+
+  return null;
+}
+
+export function getMcpInjectionDefinition(provider) {
+  const normalized = normalizeRuntimeProviderId(provider);
+  if (!normalized) return undefined;
+
+  return MCP_INJECTION_DEFINITIONS
+    .map((definition) => definition.mcp)
+    .find((definition) => definition.providerId === normalized);
+}
+
+export function listMcpInjectProviderIds() {
+  return MCP_INJECTION_DEFINITIONS
+    .map((definition) => definition.mcp)
+    .filter((definition) => definition.includeInSupportedProviders)
+    .map((definition) => definition.providerId);
+}
+
+export function resolveMcpConfigPath(provider, projectDir = '.') {
+  const definition = getMcpInjectionDefinition(provider);
+  if (!definition) return '';
+
+  const base = definition.configPath.scope === 'home'
+    ? (process.env.HOME || process.env.USERPROFILE || homedir())
+    : projectDir;
+
+  return resolve(base, definition.configPath.path);
+}

package/dist/src/providers/provider-inventory.js

@@ -0,0 +1,169 @@
+import { access, stat } from 'node:fs/promises';
+import { delimiter, isAbsolute, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { readAiwgConfig } from '../config/aiwg-config.js';
+import { resolveActiveProvider } from '../cli/provider-resolution.js';
+import { listProviderDefinitions, normalizeProviderDefinitionId, resolveProviderPathValue, } from './provider-definitions.js';
+const PROVIDER_EXECUTABLES = {
+    claude: ['claude'],
+    codex: ['codex'],
+    copilot: ['github-copilot-cli', 'copilot'],
+    cursor: ['cursor'],
+    factory: ['droid'],
+    hermes: ['hermes'],
+    opencode: ['opencode'],
+    openclaw: ['openclaw'],
+    openhuman: ['openhuman'],
+    warp: ['warp'],
+    windsurf: ['windsurf'],
+};
+async function defaultPathExists(filePath) {
+    try {
+        await access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function defaultFindExecutable(names, env) {
+    const pathDirs = (env.PATH ?? '').split(delimiter).filter(Boolean);
+    for (const name of names) {
+        if (isAbsolute(name) && await defaultPathExists(name))
+            return name;
+        for (const dir of pathDirs) {
+            const candidate = join(dir, name);
+            if (await defaultPathExists(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+async function readConfigProviders(projectDir, userDir) {
+    const project = new Set();
+    const user = new Set();
+    const deployed = new Map();
+    const collect = async (dir, target, scope) => {
+        try {
+            const config = await readAiwgConfig(dir);
+            for (const raw of config?.providers ?? []) {
+                const provider = normalizeProviderDefinitionId(raw);
+                if (provider)
+                    target.add(provider);
+            }
+            for (const [bundle, entry] of Object.entries(config?.installed ?? {})) {
+                for (const raw of Object.keys(entry.deployedTo ?? {})) {
+                    const provider = normalizeProviderDefinitionId(raw);
+                    if (!provider)
+                        continue;
+                    const values = deployed.get(provider) ?? [];
+                    values.push(`${scope}:${bundle}`);
+                    deployed.set(provider, values);
+                }
+            }
+        }
+        catch {
+            // Missing or malformed config contributes no evidence.
+        }
+    };
+    await collect(projectDir, project, 'project');
+    await collect(userDir, user, 'user');
+    return { project, user, deployed };
+}
+export async function collectProviderInventory(projectDir, options = {}) {
+    const env = options.env ?? process.env;
+    const homeDir = options.homeDir ?? homedir();
+    const pathExists = options.pathExists ?? defaultPathExists;
+    const findExecutable = options.findExecutable ?? defaultFindExecutable;
+    const configs = await readConfigProviders(projectDir, homeDir);
+    const active = await resolveActiveProvider({
+        cwd: projectDir,
+        env,
+        detectProcess: options.detectProcess ?? true,
+    });
+    const providers = [];
+    for (const definition of listProviderDefinitions()) {
+        if (definition.id === 'generic')
+            continue;
+        const evidence = [];
+        if (configs.project.has(definition.id)) {
+            evidence.push({ kind: 'project-config', scope: 'project', value: '.aiwg/aiwg.config' });
+        }
+        if (configs.user.has(definition.id)) {
+            evidence.push({ kind: 'user-config', scope: 'user', value: '~/.aiwg/aiwg.config' });
+        }
+        for (const deployment of configs.deployed.get(definition.id) ?? []) {
+            evidence.push({ kind: 'deployment-record', scope: deployment.startsWith('user:') ? 'user' : 'project', value: deployment });
+        }
+        for (const marker of definition.detection.env) {
+            if (env[marker])
+                evidence.push({ kind: 'runtime-env', scope: 'runtime', value: marker });
+        }
+        if (active.source === 'process' && active.provider === definition.id) {
+            evidence.push({ kind: 'process', scope: 'runtime', value: active.reason });
+        }
+        if ((active.source === 'env' || active.source === 'runtime-env') &&
+            active.provider === definition.id) {
+            evidence.push({
+                kind: 'runtime-env',
+                scope: 'runtime',
+                value: active.source === 'env' ? 'AIWG_PROVIDER/CLAUDECODE_PROVIDER' : active.reason,
+            });
+        }
+        const executable = await findExecutable(PROVIDER_EXECUTABLES[definition.id] ?? [], env);
+        if (executable) {
+            let value = executable;
+            try {
+                value = `${executable}@${(await stat(executable)).mtimeMs}`;
+            }
+            catch {
+                // A custom detector may return a synthetic path; the path remains useful evidence.
+            }
+            evidence.push({ kind: 'executable', scope: 'runtime', value });
+        }
+        const providerSpecificConfig = definition.paths.configFile
+            && !['AGENTS.md', 'README.md'].includes(definition.paths.configFile);
+        const configPath = providerSpecificConfig
+            ? resolveProviderPathValue(definition.paths.configFile.replace(/^~(?=\/|$)/, homeDir), projectDir)
+            : '';
+        if (configPath && await pathExists(resolve(configPath))) {
+            evidence.push({ kind: 'provider-config', scope: configPath.startsWith(homeDir) ? 'user' : 'project', value: configPath });
+        }
+        const configured = evidence.some(item => item.kind === 'project-config' || item.kind === 'user-config');
+        const deployed = evidence.some(item => item.kind === 'deployment-record');
+        const detected = evidence.some(item => item.kind === 'runtime-env' ||
+            item.kind === 'process' ||
+            item.kind === 'executable' ||
+            item.kind === 'provider-config');
+        const available = evidence.some(item => item.kind === 'runtime-env' ||
+            item.kind === 'process' ||
+            item.kind === 'executable');
+        const reasons = available
+            ? []
+            : [
+                `No runtime marker or provider executable (${(PROVIDER_EXECUTABLES[definition.id] ?? []).join(', ') || 'none'}) was detected.`,
+                configured
+                    ? 'The provider is configured but configuration alone does not prove it is installed.'
+                    : 'Configure or install the provider, then rerun `aiwg runtime-info --providers`.',
+            ];
+        providers.push({
+            id: definition.id,
+            displayName: definition.displayName,
+            configured,
+            deployed,
+            detected,
+            available,
+            active: active.provider === definition.id,
+            evidence,
+            reasons,
+        });
+    }
+    return {
+        generatedAt: (options.now ?? (() => new Date()))().toISOString(),
+        projectDir: resolve(projectDir),
+        providers,
+        activeProvider: active.provider,
+        activeSource: active.source,
+    };
+}
+//# sourceMappingURL=provider-inventory.js.map

package/dist/src/quality/feedback-ab.js

@@ -0,0 +1,174 @@
+/**
+ * Feedback A/B Testing Framework
+ *
+ * Provides significance testing for comparing feedback strategies
+ * using Welch's t-test and Cohen's d effect size calculations.
+ *
+ * @module quality/feedback-ab
+ * @issue #148
+ */
+// ============================================================================
+// A/B Testing Engine
+// ============================================================================
+export function runABTest(control, treatment, config = {}) {
+    const alpha = config.alpha ?? 0.05;
+    const minSamples = config.minSamples ?? 10;
+    if (control.deltas.length < minSamples || treatment.deltas.length < minSamples) {
+        throw new Error(`Insufficient samples: control=${control.deltas.length}, treatment=${treatment.deltas.length}, minimum=${minSamples}`);
+    }
+    const controlMean = mean(control.deltas);
+    const treatmentMean = mean(treatment.deltas);
+    const controlStdDev = stdDev(control.deltas);
+    const treatmentStdDev = stdDev(treatment.deltas);
+    const controlN = control.deltas.length;
+    const treatmentN = treatment.deltas.length;
+    const { tStatistic, degreesOfFreedom } = welchTTest(controlMean, treatmentMean, controlStdDev, treatmentStdDev, controlN, treatmentN);
+    const pValue = tTestPValue(Math.abs(tStatistic), degreesOfFreedom);
+    const pooledStdDev = Math.sqrt(((controlN - 1) * controlStdDev ** 2 + (treatmentN - 1) * treatmentStdDev ** 2) /
+        (controlN + treatmentN - 2));
+    const effectSize = pooledStdDev > 0 ? (treatmentMean - controlMean) / pooledStdDev : 0;
+    return {
+        controlName: control.name,
+        treatmentName: treatment.name,
+        controlMean: round(controlMean),
+        treatmentMean: round(treatmentMean),
+        controlStdDev: round(controlStdDev),
+        treatmentStdDev: round(treatmentStdDev),
+        tStatistic: round(tStatistic),
+        degreesOfFreedom: Math.round(degreesOfFreedom),
+        pValue: round(pValue, 4),
+        significant: pValue < alpha,
+        alpha,
+        effectSize: round(effectSize),
+        effectInterpretation: interpretEffectSize(Math.abs(effectSize)),
+        controlN,
+        treatmentN,
+    };
+}
+// ============================================================================
+// Statistical Helpers
+// ============================================================================
+export function mean(values) {
+    if (values.length === 0)
+        return 0;
+    return values.reduce((sum, v) => sum + v, 0) / values.length;
+}
+export function stdDev(values) {
+    if (values.length < 2)
+        return 0;
+    const m = mean(values);
+    const variance = values.reduce((sum, v) => sum + (v - m) ** 2, 0) / (values.length - 1);
+    return Math.sqrt(variance);
+}
+export function welchTTest(mean1, mean2, sd1, sd2, n1, n2) {
+    const se1 = (sd1 ** 2) / n1;
+    const se2 = (sd2 ** 2) / n2;
+    const seDiff = Math.sqrt(se1 + se2);
+    const tStatistic = seDiff > 0 ? (mean1 - mean2) / seDiff : 0;
+    const numerator = (se1 + se2) ** 2;
+    const denominator = (se1 ** 2) / (n1 - 1) + (se2 ** 2) / (n2 - 1);
+    const degreesOfFreedom = denominator > 0 ? numerator / denominator : 1;
+    return { tStatistic, degreesOfFreedom };
+}
+export function tTestPValue(tAbs, df) {
+    if (df > 1000) {
+        return 2 * normalCDF(-tAbs);
+    }
+    const x = df / (df + tAbs ** 2);
+    const p = incompleteBeta(x, df / 2, 0.5);
+    return Math.min(1, Math.max(0, p));
+}
+function normalCDF(x) {
+    const a1 = 0.254829592;
+    const a2 = -0.284496736;
+    const a3 = 1.421413741;
+    const a4 = -1.453152027;
+    const a5 = 1.061405429;
+    const p = 0.3275911;
+    const sign = x < 0 ? -1 : 1;
+    const absX = Math.abs(x);
+    const t = 1.0 / (1.0 + p * absX);
+    const y = 1.0 -
+        ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX / 2);
+    return 0.5 * (1.0 + sign * y);
+}
+function incompleteBeta(x, a, b) {
+    if (x <= 0)
+        return 0;
+    if (x >= 1)
+        return 1;
+    const lnBeta = lnGamma(a) + lnGamma(b) - lnGamma(a + b);
+    const front = Math.exp(Math.log(x) * a + Math.log(1 - x) * b - lnBeta) / a;
+    let f = 1;
+    let c = 1;
+    let d = 1 - (a + b) * x / (a + 1);
+    if (Math.abs(d) < 1e-30)
+        d = 1e-30;
+    d = 1 / d;
+    f = d;
+    for (let m = 1; m <= 200; m++) {
+        let numerator = m * (b - m) * x / ((a + 2 * m - 1) * (a + 2 * m));
+        d = 1 + numerator * d;
+        if (Math.abs(d) < 1e-30)
+            d = 1e-30;
+        c = 1 + numerator / c;
+        if (Math.abs(c) < 1e-30)
+            c = 1e-30;
+        d = 1 / d;
+        f *= c * d;
+        numerator = -(a + m) * (a + b + m) * x / ((a + 2 * m) * (a + 2 * m + 1));
+        d = 1 + numerator * d;
+        if (Math.abs(d) < 1e-30)
+            d = 1e-30;
+        c = 1 + numerator / c;
+        if (Math.abs(c) < 1e-30)
+            c = 1e-30;
+        d = 1 / d;
+        const delta = c * d;
+        f *= delta;
+        if (Math.abs(delta - 1.0) < 1e-10)
+            break;
+    }
+    return front * f;
+}
+function lnGamma(z) {
+    if (z <= 0)
+        return 0;
+    const g = 7;
+    const c = [
+        0.99999999999980993,
+        676.5203681218851,
+        -1259.1392167224028,
+        771.32342877765313,
+        -176.61502916214059,
+        12.507343278686905,
+        -0.13857109526572012,
+        9.9843695780195716e-6,
+        1.5056327351493116e-7,
+    ];
+    if (z < 0.5) {
+        return Math.log(Math.PI / Math.sin(Math.PI * z)) - lnGamma(1 - z);
+    }
+    z -= 1;
+    let x = c[0];
+    for (let i = 1; i < g + 2; i++) {
+        x += c[i] / (z + i);
+    }
+    const t = z + g + 0.5;
+    return 0.5 * Math.log(2 * Math.PI) + (z + 0.5) * Math.log(t) - t + Math.log(x);
+}
+export function interpretEffectSize(d) {
+    const absD = Math.abs(d);
+    if (absD < 0.2)
+        return 'negligible';
+    if (absD < 0.5)
+        return 'small';
+    if (absD < 0.8)
+        return 'medium';
+    return 'large';
+}
+function round(value, decimals = 2) {
+    const factor = 10 ** decimals;
+    return Math.round(value * factor) / factor;
+}
+//# sourceMappingURL=feedback-ab.js.map

package/dist/src/quality/feedback-collector.js

@@ -0,0 +1,176 @@
+/**
+ * Feedback Collector — structured feedback from validation/review cycles
+ *
+ * Collects feedback per agent, analyzes patterns, and proposes
+ * constraint updates for self-improving agent prompts.
+ *
+ * @module quality/feedback-collector
+ * @issue #146
+ */
+import { promises as fs } from 'fs';
+import path from 'path';
+// ============================================================================
+// Constants
+// ============================================================================
+const FEEDBACK_DIR = '.aiwg/feedback';
+// ============================================================================
+// FeedbackCollector
+// ============================================================================
+export class FeedbackCollector {
+    projectPath;
+    entries;
+    nextId;
+    constructor(projectPath) {
+        this.projectPath = projectPath;
+        this.entries = new Map();
+        this.nextId = 1;
+    }
+    async record(agent, feedbackType, description, context, severity = 'medium', source = 'auto') {
+        const entry = {
+            id: `fbc-${String(this.nextId++).padStart(5, '0')}`,
+            agent,
+            feedbackType,
+            description,
+            context,
+            severity,
+            timestamp: new Date().toISOString(),
+            source,
+        };
+        const agentEntries = this.entries.get(agent) || [];
+        agentEntries.push(entry);
+        this.entries.set(agent, agentEntries);
+        await this.persistEntry(agent, entry);
+        return entry;
+    }
+    getEntriesForAgent(agent) {
+        return this.entries.get(agent) || [];
+    }
+    getAllEntries() {
+        const all = [];
+        for (const entries of this.entries.values()) {
+            all.push(...entries);
+        }
+        return all.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    }
+    /**
+     * Analyze feedback for an agent and identify recurring patterns.
+     */
+    analyzePatterns(agent) {
+        const entries = this.getEntriesForAgent(agent);
+        if (entries.length === 0)
+            return [];
+        // Group by description similarity (simple keyword clustering)
+        const clusters = new Map();
+        for (const entry of entries) {
+            const key = extractPatternKey(entry.description);
+            const cluster = clusters.get(key) || [];
+            cluster.push(entry);
+            clusters.set(key, cluster);
+        }
+        const patterns = [];
+        let patternNum = 1;
+        for (const [key, cluster] of clusters) {
+            if (cluster.length < 2)
+                continue; // Only patterns with 2+ occurrences
+            const sorted = cluster.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+            const maxSeverity = cluster.reduce((max, e) => {
+                const order = { critical: 4, high: 3, medium: 2, low: 1 };
+                return order[e.severity] > order[max] ? e.severity : max;
+            }, 'low');
+            patterns.push({
+                patternId: `pat-${agent}-${String(patternNum++).padStart(3, '0')}`,
+                agent,
+                description: `Recurring: ${key} (${cluster.length} occurrences)`,
+                occurrences: cluster.length,
+                firstSeen: sorted[0].timestamp,
+                lastSeen: sorted[sorted.length - 1].timestamp,
+                severity: maxSeverity,
+                suggestedConstraint: generateConstraintSuggestion(key, cluster),
+                feedbackIds: cluster.map((e) => e.id),
+            });
+        }
+        return patterns.sort((a, b) => b.occurrences - a.occurrences);
+    }
+    /**
+     * Generate a constraint update proposal for an agent.
+     */
+    proposeConstraintUpdate(agent) {
+        const patterns = this.analyzePatterns(agent);
+        if (patterns.length === 0)
+            return null;
+        const additions = patterns
+            .filter((p) => p.occurrences >= 3 || p.severity === 'critical')
+            .map((p) => p.suggestedConstraint);
+        if (additions.length === 0)
+            return null;
+        return {
+            agent,
+            version: 1, // Would increment based on existing versions
+            timestamp: new Date().toISOString(),
+            additions,
+            modifications: [],
+            patterns,
+            status: 'proposed',
+        };
+    }
+    async load() {
+        try {
+            const feedbackDir = path.join(this.projectPath, FEEDBACK_DIR);
+            const agents = await fs.readdir(feedbackDir).catch(() => []);
+            for (const agentDir of agents) {
+                const agentPath = path.join(feedbackDir, agentDir);
+                const stat = await fs.stat(agentPath);
+                if (!stat.isDirectory() || agentDir === 'constraints')
+                    continue;
+                const files = await fs.readdir(agentPath);
+                const entries = [];
+                for (const file of files) {
+                    if (!file.endsWith('.json'))
+                        continue;
+                    const content = await fs.readFile(path.join(agentPath, file), 'utf-8');
+                    entries.push(JSON.parse(content));
+                }
+                if (entries.length > 0) {
+                    this.entries.set(agentDir, entries);
+                    this.nextId = Math.max(this.nextId, ...entries.map((e) => {
+                        const num = parseInt(e.id.replace('fbc-', ''), 10);
+                        return isNaN(num) ? 0 : num + 1;
+                    }));
+                }
+            }
+        }
+        catch {
+            // Start fresh
+        }
+    }
+    async persistEntry(agent, entry) {
+        try {
+            const agentDir = path.join(this.projectPath, FEEDBACK_DIR, agent);
+            await fs.mkdir(agentDir, { recursive: true });
+            await fs.writeFile(path.join(agentDir, `${entry.id}.json`), JSON.stringify(entry, null, 2), 'utf-8');
+        }
+        catch {
+            // Non-critical
+        }
+    }
+}
+// ============================================================================
+// Helpers
+// ============================================================================
+function extractPatternKey(description) {
+    return description
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, '')
+        .split(/\s+/)
+        .filter((w) => w.length > 3)
+        .slice(0, 5)
+        .join(' ');
+}
+function generateConstraintSuggestion(key, entries) {
+    const types = [...new Set(entries.map((e) => e.feedbackType))];
+    if (types.includes('error')) {
+        return `MUST NOT: ${key} — detected ${entries.length} times, most recently ${entries[entries.length - 1].timestamp}`;
+    }
+    return `SHOULD: Address "${key}" pattern — ${entries.length} occurrences across feedback`;
+}
+//# sourceMappingURL=feedback-collector.js.map