@ruvector/ruvllm 2.4.0 → 2.5.0

package/dist/cjs/intelligence.js

@@ -0,0 +1,162 @@
+"use strict";
+/**
+ * External Intelligence Providers for SONA Learning (ADR-043)
+ *
+ * TypeScript bindings for the IntelligenceProvider trait, enabling
+ * external systems to feed quality signals into RuvLLM's learning loops.
+ *
+ * @example
+ * ```typescript
+ * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';
+ *
+ * const loader = new IntelligenceLoader();
+ * loader.registerProvider(new FileSignalProvider('./signals.json'));
+ *
+ * const { signals, errors } = loader.loadAllSignals();
+ * console.log(`Loaded ${signals.length} signals`);
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IntelligenceLoader = exports.FileSignalProvider = void 0;
+/**
+ * Built-in file-based intelligence provider.
+ *
+ * Reads quality signals from a JSON file. This is the default provider
+ * for non-Rust integrations that write signal files.
+ */
+class FileSignalProvider {
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    name() {
+        return 'file-signals';
+    }
+    loadSignals() {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const fs = require('fs');
+            if (!fs.existsSync(this.filePath)) {
+                return [];
+            }
+            const raw = fs.readFileSync(this.filePath, 'utf-8');
+            const data = JSON.parse(raw);
+            if (!Array.isArray(data)) {
+                return [];
+            }
+            return data.map((item) => ({
+                id: String(item.id ?? ''),
+                taskDescription: String(item.task_description ?? item.taskDescription ?? ''),
+                outcome: String(item.outcome ?? 'failure'),
+                qualityScore: Number(item.quality_score ?? item.qualityScore ?? 0),
+                humanVerdict: item.human_verdict ?? item.humanVerdict
+                    ? String(item.human_verdict ?? item.humanVerdict)
+                    : undefined,
+                qualityFactors: (item.quality_factors || item.qualityFactors)
+                    ? mapQualityFactors((item.quality_factors ?? item.qualityFactors))
+                    : undefined,
+                completedAt: String(item.completed_at ?? item.completedAt ?? new Date().toISOString()),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    qualityWeights() {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const weightsPath = path.join(path.dirname(this.filePath), 'quality-weights.json');
+            if (!fs.existsSync(weightsPath))
+                return undefined;
+            const raw = fs.readFileSync(weightsPath, 'utf-8');
+            const data = JSON.parse(raw);
+            return {
+                taskCompletion: Number(data.task_completion ?? data.taskCompletion ?? 0.5),
+                codeQuality: Number(data.code_quality ?? data.codeQuality ?? 0.3),
+                process: Number(data.process ?? 0.2),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.FileSignalProvider = FileSignalProvider;
+function mapQualityFactors(raw) {
+    return {
+        acceptanceCriteriaMet: raw.acceptance_criteria_met,
+        testsPassing: raw.tests_passing,
+        noRegressions: raw.no_regressions,
+        lintClean: raw.lint_clean,
+        typeCheckClean: raw.type_check_clean,
+        followsPatterns: raw.follows_patterns,
+        contextRelevance: raw.context_relevance,
+        reasoningCoherence: raw.reasoning_coherence,
+        executionEfficiency: raw.execution_efficiency,
+    };
+}
+/**
+ * Aggregates quality signals from multiple registered providers.
+ *
+ * If no providers are registered, loadAllSignals returns empty arrays
+ * with zero overhead.
+ */
+class IntelligenceLoader {
+    constructor() {
+        this.providers = [];
+    }
+    /** Register an external intelligence provider */
+    registerProvider(provider) {
+        this.providers.push(provider);
+    }
+    /** Returns the number of registered providers */
+    get providerCount() {
+        return this.providers.length;
+    }
+    /** Returns the names of all registered providers */
+    get providerNames() {
+        return this.providers.map(p => p.name());
+    }
+    /**
+     * Load signals from all registered providers.
+     *
+     * Non-fatal: if a provider fails, its error is captured but
+     * other providers continue loading.
+     */
+    loadAllSignals() {
+        const signals = [];
+        const errors = [];
+        for (const provider of this.providers) {
+            try {
+                const providerSignals = provider.loadSignals();
+                signals.push(...providerSignals);
+            }
+            catch (e) {
+                errors.push({
+                    providerName: provider.name(),
+                    message: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        return { signals, errors };
+    }
+    /** Load signals grouped by provider with weight overrides */
+    loadGrouped() {
+        return this.providers.map(provider => {
+            let providerSignals = [];
+            try {
+                providerSignals = provider.loadSignals();
+            }
+            catch {
+                // Non-fatal
+            }
+            return {
+                providerName: provider.name(),
+                signals: providerSignals,
+                weights: provider.qualityWeights?.(),
+            };
+        });
+    }
+}
+exports.IntelligenceLoader = IntelligenceLoader;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intelligence.js","sourceRoot":"","sources":["../../src/intelligence.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * External Intelligence Providers for SONA Learning (ADR-043)\n *\n * TypeScript bindings for the IntelligenceProvider trait, enabling\n * external systems to feed quality signals into RuvLLM's learning loops.\n *\n * @example\n * ```typescript\n * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';\n *\n * const loader = new IntelligenceLoader();\n * loader.registerProvider(new FileSignalProvider('./signals.json'));\n *\n * const { signals, errors } = loader.loadAllSignals();\n * console.log(`Loaded ${signals.length} signals`);\n * ```\n */\n\n/**\n * A quality signal from an external system.\n *\n * Represents one completed task with quality assessment data\n * that can feed into SONA trajectories, the embedding classifier,\n * and model router calibration.\n */\nexport interface QualitySignal {\n  /** Unique identifier for this signal */\n  id: string;\n  /** Human-readable task description (used for embedding generation) */\n  taskDescription: string;\n  /** Execution outcome */\n  outcome: 'success' | 'partial_success' | 'failure';\n  /** Composite quality score (0.0 - 1.0) */\n  qualityScore: number;\n  /** Optional human verdict */\n  humanVerdict?: 'approved' | 'rejected';\n  /** Optional structured quality factors for detailed analysis */\n  qualityFactors?: QualityFactors;\n  /** ISO 8601 timestamp of task completion */\n  completedAt: string;\n}\n\n/**\n * Granular quality factor breakdown.\n *\n * Not all providers will have all factors. Undefined fields mean\n * \"not assessed\" (distinct from 0.0, which means \"assessed as zero\").\n */\nexport interface QualityFactors {\n  acceptanceCriteriaMet?: number;\n  testsPassing?: number;\n  noRegressions?: number;\n  lintClean?: number;\n  typeCheckClean?: number;\n  followsPatterns?: number;\n  contextRelevance?: number;\n  reasoningCoherence?: number;\n  executionEfficiency?: number;\n}\n\n/**\n * Quality weight overrides from a provider.\n *\n * Weights should sum to approximately 1.0.\n */\nexport interface ProviderQualityWeights {\n  taskCompletion: number;\n  codeQuality: number;\n  process: number;\n}\n\n/**\n * Error from a single provider during batch loading.\n */\nexport interface ProviderError {\n  providerName: string;\n  message: string;\n}\n\n/**\n * Result from a single provider during grouped loading.\n */\nexport interface ProviderResult {\n  providerName: string;\n  signals: QualitySignal[];\n  weights?: ProviderQualityWeights;\n}\n\n/**\n * Interface for external systems that supply quality signals to RuvLLM.\n *\n * Implement this interface and register with IntelligenceLoader.\n */\nexport interface IntelligenceProvider {\n  /** Human-readable name for this provider */\n  name(): string;\n  /** Load quality signals from this provider's data source */\n  loadSignals(): QualitySignal[];\n  /** Optional quality weight overrides */\n  qualityWeights?(): ProviderQualityWeights | undefined;\n}\n\n/**\n * Built-in file-based intelligence provider.\n *\n * Reads quality signals from a JSON file. This is the default provider\n * for non-Rust integrations that write signal files.\n */\nexport class FileSignalProvider implements IntelligenceProvider {\n  private readonly filePath: string;\n\n  constructor(filePath: string) {\n    this.filePath = filePath;\n  }\n\n  name(): string {\n    return 'file-signals';\n  }\n\n  loadSignals(): QualitySignal[] {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-var-requires\n      const fs = require('fs');\n      if (!fs.existsSync(this.filePath)) {\n        return [];\n      }\n      const raw = fs.readFileSync(this.filePath, 'utf-8');\n      const data = JSON.parse(raw);\n      if (!Array.isArray(data)) {\n        return [];\n      }\n      return data.map((item: Record<string, unknown>) => ({\n        id: String(item.id ?? ''),\n        taskDescription: String(item.task_description ?? item.taskDescription ?? ''),\n        outcome: String(item.outcome ?? 'failure') as QualitySignal['outcome'],\n        qualityScore: Number(item.quality_score ?? item.qualityScore ?? 0),\n        humanVerdict: item.human_verdict ?? item.humanVerdict\n          ? String(item.human_verdict ?? item.humanVerdict) as QualitySignal['humanVerdict']\n          : undefined,\n        qualityFactors: (item.quality_factors || item.qualityFactors)\n          ? mapQualityFactors((item.quality_factors ?? item.qualityFactors) as Record<string, unknown>)\n          : undefined,\n        completedAt: String(item.completed_at ?? item.completedAt ?? new Date().toISOString()),\n      }));\n    } catch {\n      return [];\n    }\n  }\n\n  qualityWeights(): ProviderQualityWeights | undefined {\n    try {\n      const fs = require('fs');\n      const path = require('path');\n      const weightsPath = path.join(path.dirname(this.filePath), 'quality-weights.json');\n      if (!fs.existsSync(weightsPath)) return undefined;\n      const raw = fs.readFileSync(weightsPath, 'utf-8');\n      const data = JSON.parse(raw);\n      return {\n        taskCompletion: Number(data.task_completion ?? data.taskCompletion ?? 0.5),\n        codeQuality: Number(data.code_quality ?? data.codeQuality ?? 0.3),\n        process: Number(data.process ?? 0.2),\n      };\n    } catch {\n      return undefined;\n    }\n  }\n}\n\nfunction mapQualityFactors(raw: Record<string, unknown>): QualityFactors {\n  return {\n    acceptanceCriteriaMet: raw.acceptance_criteria_met as number | undefined,\n    testsPassing: raw.tests_passing as number | undefined,\n    noRegressions: raw.no_regressions as number | undefined,\n    lintClean: raw.lint_clean as number | undefined,\n    typeCheckClean: raw.type_check_clean as number | undefined,\n    followsPatterns: raw.follows_patterns as number | undefined,\n    contextRelevance: raw.context_relevance as number | undefined,\n    reasoningCoherence: raw.reasoning_coherence as number | undefined,\n    executionEfficiency: raw.execution_efficiency as number | undefined,\n  };\n}\n\n/**\n * Aggregates quality signals from multiple registered providers.\n *\n * If no providers are registered, loadAllSignals returns empty arrays\n * with zero overhead.\n */\nexport class IntelligenceLoader {\n  private providers: IntelligenceProvider[] = [];\n\n  /** Register an external intelligence provider */\n  registerProvider(provider: IntelligenceProvider): void {\n    this.providers.push(provider);\n  }\n\n  /** Returns the number of registered providers */\n  get providerCount(): number {\n    return this.providers.length;\n  }\n\n  /** Returns the names of all registered providers */\n  get providerNames(): string[] {\n    return this.providers.map(p => p.name());\n  }\n\n  /**\n   * Load signals from all registered providers.\n   *\n   * Non-fatal: if a provider fails, its error is captured but\n   * other providers continue loading.\n   */\n  loadAllSignals(): { signals: QualitySignal[]; errors: ProviderError[] } {\n    const signals: QualitySignal[] = [];\n    const errors: ProviderError[] = [];\n\n    for (const provider of this.providers) {\n      try {\n        const providerSignals = provider.loadSignals();\n        signals.push(...providerSignals);\n      } catch (e) {\n        errors.push({\n          providerName: provider.name(),\n          message: e instanceof Error ? e.message : String(e),\n        });\n      }\n    }\n\n    return { signals, errors };\n  }\n\n  /** Load signals grouped by provider with weight overrides */\n  loadGrouped(): ProviderResult[] {\n    return this.providers.map(provider => {\n      let providerSignals: QualitySignal[] = [];\n      try {\n        providerSignals = provider.loadSignals();\n      } catch {\n        // Non-fatal\n      }\n      return {\n        providerName: provider.name(),\n        signals: providerSignals,\n        weights: provider.qualityWeights?.(),\n      };\n    });\n  }\n}\n"]}

package/dist/esm/index.d.ts

@@ -62,7 +62,7 @@ export * from './training';
 export * from './contrastive';
 export * from './models';
 export * from './benchmarks';
-export * from './rlm';
+export * from './intelligence';
 export { version, hasSimdSupport } from './native';
 export { RuvLLM as default } from './engine';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAGH,cAAc,SAAS,CAAC;AAGxB,cAAc,UAAU,CAAC;AAGzB,cAAc,QAAQ,CAAC;AAGvB,cAAc,WAAW,CAAC;AAG1B,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,UAAU,CAAC;AAGzB,cAAc,YAAY,CAAC;AAG3B,cAAc,eAAe,CAAC;AAG9B,cAAc,UAAU,CAAC;AAGzB,cAAc,cAAc,CAAC;AAG7B,cAAc,OAAO,CAAC;AAGtB,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAGnD,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAGH,cAAc,SAAS,CAAC;AAGxB,cAAc,UAAU,CAAC;AAGzB,cAAc,QAAQ,CAAC;AAGvB,cAAc,WAAW,CAAC;AAG1B,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,aAAa,CAAC;AAG5B,cAAc,QAAQ,CAAC;AAGvB,cAAc,UAAU,CAAC;AAGzB,cAAc,YAAY,CAAC;AAG3B,cAAc,eAAe,CAAC;AAG9B,cAAc,UAAU,CAAC;AAGzB,cAAc,cAAc,CAAC;AAG7B,cAAc,gBAAgB,CAAC;AAG/B,OAAO,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAGnD,OAAO,EAAE,MAAM,IAAI,OAAO,EAAE,MAAM,UAAU,CAAC"}

package/dist/esm/index.js

@@ -75,10 +75,10 @@ export * from './contrastive';
 export * from './models';
 // Benchmarks for Claude Code use cases
 export * from './benchmarks';
-// RLM - Retrieval Language Model
-export * from './rlm';
+// External Intelligence Providers (ADR-043)
+export * from './intelligence';
 // Native bindings utilities
 export { version, hasSimdSupport } from './native';
 // Default export
 export { RuvLLM as default } from './engine';
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm/intelligence.d.ts

@@ -0,0 +1,136 @@
+/**
+ * External Intelligence Providers for SONA Learning (ADR-043)
+ *
+ * TypeScript bindings for the IntelligenceProvider trait, enabling
+ * external systems to feed quality signals into RuvLLM's learning loops.
+ *
+ * @example
+ * ```typescript
+ * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';
+ *
+ * const loader = new IntelligenceLoader();
+ * loader.registerProvider(new FileSignalProvider('./signals.json'));
+ *
+ * const { signals, errors } = loader.loadAllSignals();
+ * console.log(`Loaded ${signals.length} signals`);
+ * ```
+ */
+/**
+ * A quality signal from an external system.
+ *
+ * Represents one completed task with quality assessment data
+ * that can feed into SONA trajectories, the embedding classifier,
+ * and model router calibration.
+ */
+export interface QualitySignal {
+    /** Unique identifier for this signal */
+    id: string;
+    /** Human-readable task description (used for embedding generation) */
+    taskDescription: string;
+    /** Execution outcome */
+    outcome: 'success' | 'partial_success' | 'failure';
+    /** Composite quality score (0.0 - 1.0) */
+    qualityScore: number;
+    /** Optional human verdict */
+    humanVerdict?: 'approved' | 'rejected';
+    /** Optional structured quality factors for detailed analysis */
+    qualityFactors?: QualityFactors;
+    /** ISO 8601 timestamp of task completion */
+    completedAt: string;
+}
+/**
+ * Granular quality factor breakdown.
+ *
+ * Not all providers will have all factors. Undefined fields mean
+ * "not assessed" (distinct from 0.0, which means "assessed as zero").
+ */
+export interface QualityFactors {
+    acceptanceCriteriaMet?: number;
+    testsPassing?: number;
+    noRegressions?: number;
+    lintClean?: number;
+    typeCheckClean?: number;
+    followsPatterns?: number;
+    contextRelevance?: number;
+    reasoningCoherence?: number;
+    executionEfficiency?: number;
+}
+/**
+ * Quality weight overrides from a provider.
+ *
+ * Weights should sum to approximately 1.0.
+ */
+export interface ProviderQualityWeights {
+    taskCompletion: number;
+    codeQuality: number;
+    process: number;
+}
+/**
+ * Error from a single provider during batch loading.
+ */
+export interface ProviderError {
+    providerName: string;
+    message: string;
+}
+/**
+ * Result from a single provider during grouped loading.
+ */
+export interface ProviderResult {
+    providerName: string;
+    signals: QualitySignal[];
+    weights?: ProviderQualityWeights;
+}
+/**
+ * Interface for external systems that supply quality signals to RuvLLM.
+ *
+ * Implement this interface and register with IntelligenceLoader.
+ */
+export interface IntelligenceProvider {
+    /** Human-readable name for this provider */
+    name(): string;
+    /** Load quality signals from this provider's data source */
+    loadSignals(): QualitySignal[];
+    /** Optional quality weight overrides */
+    qualityWeights?(): ProviderQualityWeights | undefined;
+}
+/**
+ * Built-in file-based intelligence provider.
+ *
+ * Reads quality signals from a JSON file. This is the default provider
+ * for non-Rust integrations that write signal files.
+ */
+export declare class FileSignalProvider implements IntelligenceProvider {
+    private readonly filePath;
+    constructor(filePath: string);
+    name(): string;
+    loadSignals(): QualitySignal[];
+    qualityWeights(): ProviderQualityWeights | undefined;
+}
+/**
+ * Aggregates quality signals from multiple registered providers.
+ *
+ * If no providers are registered, loadAllSignals returns empty arrays
+ * with zero overhead.
+ */
+export declare class IntelligenceLoader {
+    private providers;
+    /** Register an external intelligence provider */
+    registerProvider(provider: IntelligenceProvider): void;
+    /** Returns the number of registered providers */
+    get providerCount(): number;
+    /** Returns the names of all registered providers */
+    get providerNames(): string[];
+    /**
+     * Load signals from all registered providers.
+     *
+     * Non-fatal: if a provider fails, its error is captured but
+     * other providers continue loading.
+     */
+    loadAllSignals(): {
+        signals: QualitySignal[];
+        errors: ProviderError[];
+    };
+    /** Load signals grouped by provider with weight overrides */
+    loadGrouped(): ProviderResult[];
+}
+//# sourceMappingURL=intelligence.d.ts.map

package/dist/esm/intelligence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"intelligence.d.ts","sourceRoot":"","sources":["../../src/intelligence.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,wCAAwC;IACxC,EAAE,EAAE,MAAM,CAAC;IACX,sEAAsE;IACtE,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB;IACxB,OAAO,EAAE,SAAS,GAAG,iBAAiB,GAAG,SAAS,CAAC;IACnD,0CAA0C;IAC1C,YAAY,EAAE,MAAM,CAAC;IACrB,6BAA6B;IAC7B,YAAY,CAAC,EAAE,UAAU,GAAG,UAAU,CAAC;IACvC,gEAAgE;IAChE,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,qBAAqB,CAAC,EAAE,MAAM,CAAC;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;GAIG;AACH,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,YAAY,EAAE,MAAM,CAAC;IACrB,OAAO,EAAE,aAAa,EAAE,CAAC;IACzB,OAAO,CAAC,EAAE,sBAAsB,CAAC;CAClC;AAED;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,4CAA4C;IAC5C,IAAI,IAAI,MAAM,CAAC;IACf,4DAA4D;IAC5D,WAAW,IAAI,aAAa,EAAE,CAAC;IAC/B,wCAAwC;IACxC,cAAc,CAAC,IAAI,sBAAsB,GAAG,SAAS,CAAC;CACvD;AAED;;;;;GAKG;AACH,qBAAa,kBAAmB,YAAW,oBAAoB;IAC7D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;gBAEtB,QAAQ,EAAE,MAAM;IAI5B,IAAI,IAAI,MAAM;IAId,WAAW,IAAI,aAAa,EAAE;IA8B9B,cAAc,IAAI,sBAAsB,GAAG,SAAS;CAiBrD;AAgBD;;;;;GAKG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,SAAS,CAA8B;IAE/C,iDAAiD;IACjD,gBAAgB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,IAAI;IAItD,iDAAiD;IACjD,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,oDAAoD;IACpD,IAAI,aAAa,IAAI,MAAM,EAAE,CAE5B;IAED;;;;;OAKG;IACH,cAAc,IAAI;QAAE,OAAO,EAAE,aAAa,EAAE,CAAC;QAAC,MAAM,EAAE,aAAa,EAAE,CAAA;KAAE;IAmBvE,6DAA6D;IAC7D,WAAW,IAAI,cAAc,EAAE;CAehC"}

package/dist/esm/intelligence.js

@@ -0,0 +1,157 @@
+/**
+ * External Intelligence Providers for SONA Learning (ADR-043)
+ *
+ * TypeScript bindings for the IntelligenceProvider trait, enabling
+ * external systems to feed quality signals into RuvLLM's learning loops.
+ *
+ * @example
+ * ```typescript
+ * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';
+ *
+ * const loader = new IntelligenceLoader();
+ * loader.registerProvider(new FileSignalProvider('./signals.json'));
+ *
+ * const { signals, errors } = loader.loadAllSignals();
+ * console.log(`Loaded ${signals.length} signals`);
+ * ```
+ */
+/**
+ * Built-in file-based intelligence provider.
+ *
+ * Reads quality signals from a JSON file. This is the default provider
+ * for non-Rust integrations that write signal files.
+ */
+export class FileSignalProvider {
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    name() {
+        return 'file-signals';
+    }
+    loadSignals() {
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const fs = require('fs');
+            if (!fs.existsSync(this.filePath)) {
+                return [];
+            }
+            const raw = fs.readFileSync(this.filePath, 'utf-8');
+            const data = JSON.parse(raw);
+            if (!Array.isArray(data)) {
+                return [];
+            }
+            return data.map((item) => ({
+                id: String(item.id ?? ''),
+                taskDescription: String(item.task_description ?? item.taskDescription ?? ''),
+                outcome: String(item.outcome ?? 'failure'),
+                qualityScore: Number(item.quality_score ?? item.qualityScore ?? 0),
+                humanVerdict: item.human_verdict ?? item.humanVerdict
+                    ? String(item.human_verdict ?? item.humanVerdict)
+                    : undefined,
+                qualityFactors: (item.quality_factors || item.qualityFactors)
+                    ? mapQualityFactors((item.quality_factors ?? item.qualityFactors))
+                    : undefined,
+                completedAt: String(item.completed_at ?? item.completedAt ?? new Date().toISOString()),
+            }));
+        }
+        catch {
+            return [];
+        }
+    }
+    qualityWeights() {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const weightsPath = path.join(path.dirname(this.filePath), 'quality-weights.json');
+            if (!fs.existsSync(weightsPath))
+                return undefined;
+            const raw = fs.readFileSync(weightsPath, 'utf-8');
+            const data = JSON.parse(raw);
+            return {
+                taskCompletion: Number(data.task_completion ?? data.taskCompletion ?? 0.5),
+                codeQuality: Number(data.code_quality ?? data.codeQuality ?? 0.3),
+                process: Number(data.process ?? 0.2),
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function mapQualityFactors(raw) {
+    return {
+        acceptanceCriteriaMet: raw.acceptance_criteria_met,
+        testsPassing: raw.tests_passing,
+        noRegressions: raw.no_regressions,
+        lintClean: raw.lint_clean,
+        typeCheckClean: raw.type_check_clean,
+        followsPatterns: raw.follows_patterns,
+        contextRelevance: raw.context_relevance,
+        reasoningCoherence: raw.reasoning_coherence,
+        executionEfficiency: raw.execution_efficiency,
+    };
+}
+/**
+ * Aggregates quality signals from multiple registered providers.
+ *
+ * If no providers are registered, loadAllSignals returns empty arrays
+ * with zero overhead.
+ */
+export class IntelligenceLoader {
+    constructor() {
+        this.providers = [];
+    }
+    /** Register an external intelligence provider */
+    registerProvider(provider) {
+        this.providers.push(provider);
+    }
+    /** Returns the number of registered providers */
+    get providerCount() {
+        return this.providers.length;
+    }
+    /** Returns the names of all registered providers */
+    get providerNames() {
+        return this.providers.map(p => p.name());
+    }
+    /**
+     * Load signals from all registered providers.
+     *
+     * Non-fatal: if a provider fails, its error is captured but
+     * other providers continue loading.
+     */
+    loadAllSignals() {
+        const signals = [];
+        const errors = [];
+        for (const provider of this.providers) {
+            try {
+                const providerSignals = provider.loadSignals();
+                signals.push(...providerSignals);
+            }
+            catch (e) {
+                errors.push({
+                    providerName: provider.name(),
+                    message: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        return { signals, errors };
+    }
+    /** Load signals grouped by provider with weight overrides */
+    loadGrouped() {
+        return this.providers.map(provider => {
+            let providerSignals = [];
+            try {
+                providerSignals = provider.loadSignals();
+            }
+            catch {
+                // Non-fatal
+            }
+            return {
+                providerName: provider.name(),
+                signals: providerSignals,
+                weights: provider.qualityWeights?.(),
+            };
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"intelligence.js","sourceRoot":"","sources":["../../src/intelligence.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * External Intelligence Providers for SONA Learning (ADR-043)\n *\n * TypeScript bindings for the IntelligenceProvider trait, enabling\n * external systems to feed quality signals into RuvLLM's learning loops.\n *\n * @example\n * ```typescript\n * import { IntelligenceLoader, FileSignalProvider, QualitySignal } from '@ruvector/ruvllm';\n *\n * const loader = new IntelligenceLoader();\n * loader.registerProvider(new FileSignalProvider('./signals.json'));\n *\n * const { signals, errors } = loader.loadAllSignals();\n * console.log(`Loaded ${signals.length} signals`);\n * ```\n */\n\n/**\n * A quality signal from an external system.\n *\n * Represents one completed task with quality assessment data\n * that can feed into SONA trajectories, the embedding classifier,\n * and model router calibration.\n */\nexport interface QualitySignal {\n  /** Unique identifier for this signal */\n  id: string;\n  /** Human-readable task description (used for embedding generation) */\n  taskDescription: string;\n  /** Execution outcome */\n  outcome: 'success' | 'partial_success' | 'failure';\n  /** Composite quality score (0.0 - 1.0) */\n  qualityScore: number;\n  /** Optional human verdict */\n  humanVerdict?: 'approved' | 'rejected';\n  /** Optional structured quality factors for detailed analysis */\n  qualityFactors?: QualityFactors;\n  /** ISO 8601 timestamp of task completion */\n  completedAt: string;\n}\n\n/**\n * Granular quality factor breakdown.\n *\n * Not all providers will have all factors. Undefined fields mean\n * \"not assessed\" (distinct from 0.0, which means \"assessed as zero\").\n */\nexport interface QualityFactors {\n  acceptanceCriteriaMet?: number;\n  testsPassing?: number;\n  noRegressions?: number;\n  lintClean?: number;\n  typeCheckClean?: number;\n  followsPatterns?: number;\n  contextRelevance?: number;\n  reasoningCoherence?: number;\n  executionEfficiency?: number;\n}\n\n/**\n * Quality weight overrides from a provider.\n *\n * Weights should sum to approximately 1.0.\n */\nexport interface ProviderQualityWeights {\n  taskCompletion: number;\n  codeQuality: number;\n  process: number;\n}\n\n/**\n * Error from a single provider during batch loading.\n */\nexport interface ProviderError {\n  providerName: string;\n  message: string;\n}\n\n/**\n * Result from a single provider during grouped loading.\n */\nexport interface ProviderResult {\n  providerName: string;\n  signals: QualitySignal[];\n  weights?: ProviderQualityWeights;\n}\n\n/**\n * Interface for external systems that supply quality signals to RuvLLM.\n *\n * Implement this interface and register with IntelligenceLoader.\n */\nexport interface IntelligenceProvider {\n  /** Human-readable name for this provider */\n  name(): string;\n  /** Load quality signals from this provider's data source */\n  loadSignals(): QualitySignal[];\n  /** Optional quality weight overrides */\n  qualityWeights?(): ProviderQualityWeights | undefined;\n}\n\n/**\n * Built-in file-based intelligence provider.\n *\n * Reads quality signals from a JSON file. This is the default provider\n * for non-Rust integrations that write signal files.\n */\nexport class FileSignalProvider implements IntelligenceProvider {\n  private readonly filePath: string;\n\n  constructor(filePath: string) {\n    this.filePath = filePath;\n  }\n\n  name(): string {\n    return 'file-signals';\n  }\n\n  loadSignals(): QualitySignal[] {\n    try {\n      // eslint-disable-next-line @typescript-eslint/no-var-requires\n      const fs = require('fs');\n      if (!fs.existsSync(this.filePath)) {\n        return [];\n      }\n      const raw = fs.readFileSync(this.filePath, 'utf-8');\n      const data = JSON.parse(raw);\n      if (!Array.isArray(data)) {\n        return [];\n      }\n      return data.map((item: Record<string, unknown>) => ({\n        id: String(item.id ?? ''),\n        taskDescription: String(item.task_description ?? item.taskDescription ?? ''),\n        outcome: String(item.outcome ?? 'failure') as QualitySignal['outcome'],\n        qualityScore: Number(item.quality_score ?? item.qualityScore ?? 0),\n        humanVerdict: item.human_verdict ?? item.humanVerdict\n          ? String(item.human_verdict ?? item.humanVerdict) as QualitySignal['humanVerdict']\n          : undefined,\n        qualityFactors: (item.quality_factors || item.qualityFactors)\n          ? mapQualityFactors((item.quality_factors ?? item.qualityFactors) as Record<string, unknown>)\n          : undefined,\n        completedAt: String(item.completed_at ?? item.completedAt ?? new Date().toISOString()),\n      }));\n    } catch {\n      return [];\n    }\n  }\n\n  qualityWeights(): ProviderQualityWeights | undefined {\n    try {\n      const fs = require('fs');\n      const path = require('path');\n      const weightsPath = path.join(path.dirname(this.filePath), 'quality-weights.json');\n      if (!fs.existsSync(weightsPath)) return undefined;\n      const raw = fs.readFileSync(weightsPath, 'utf-8');\n      const data = JSON.parse(raw);\n      return {\n        taskCompletion: Number(data.task_completion ?? data.taskCompletion ?? 0.5),\n        codeQuality: Number(data.code_quality ?? data.codeQuality ?? 0.3),\n        process: Number(data.process ?? 0.2),\n      };\n    } catch {\n      return undefined;\n    }\n  }\n}\n\nfunction mapQualityFactors(raw: Record<string, unknown>): QualityFactors {\n  return {\n    acceptanceCriteriaMet: raw.acceptance_criteria_met as number | undefined,\n    testsPassing: raw.tests_passing as number | undefined,\n    noRegressions: raw.no_regressions as number | undefined,\n    lintClean: raw.lint_clean as number | undefined,\n    typeCheckClean: raw.type_check_clean as number | undefined,\n    followsPatterns: raw.follows_patterns as number | undefined,\n    contextRelevance: raw.context_relevance as number | undefined,\n    reasoningCoherence: raw.reasoning_coherence as number | undefined,\n    executionEfficiency: raw.execution_efficiency as number | undefined,\n  };\n}\n\n/**\n * Aggregates quality signals from multiple registered providers.\n *\n * If no providers are registered, loadAllSignals returns empty arrays\n * with zero overhead.\n */\nexport class IntelligenceLoader {\n  private providers: IntelligenceProvider[] = [];\n\n  /** Register an external intelligence provider */\n  registerProvider(provider: IntelligenceProvider): void {\n    this.providers.push(provider);\n  }\n\n  /** Returns the number of registered providers */\n  get providerCount(): number {\n    return this.providers.length;\n  }\n\n  /** Returns the names of all registered providers */\n  get providerNames(): string[] {\n    return this.providers.map(p => p.name());\n  }\n\n  /**\n   * Load signals from all registered providers.\n   *\n   * Non-fatal: if a provider fails, its error is captured but\n   * other providers continue loading.\n   */\n  loadAllSignals(): { signals: QualitySignal[]; errors: ProviderError[] } {\n    const signals: QualitySignal[] = [];\n    const errors: ProviderError[] = [];\n\n    for (const provider of this.providers) {\n      try {\n        const providerSignals = provider.loadSignals();\n        signals.push(...providerSignals);\n      } catch (e) {\n        errors.push({\n          providerName: provider.name(),\n          message: e instanceof Error ? e.message : String(e),\n        });\n      }\n    }\n\n    return { signals, errors };\n  }\n\n  /** Load signals grouped by provider with weight overrides */\n  loadGrouped(): ProviderResult[] {\n    return this.providers.map(provider => {\n      let providerSignals: QualitySignal[] = [];\n      try {\n        providerSignals = provider.loadSignals();\n      } catch {\n        // Non-fatal\n      }\n      return {\n        providerName: provider.name(),\n        signals: providerSignals,\n        weights: provider.qualityWeights?.(),\n      };\n    });\n  }\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@ruvector/ruvllm",
-  "version": "2.4.0",
-  "description": "Self-learning LLM orchestration with SONA adaptive learning, HNSW memory, RLM recursive retrieval, FastGRNN routing, and SIMD inference",
+  "version": "2.5.0",
+  "description": "Self-learning LLM orchestration with SONA adaptive learning, HNSW memory, FastGRNN routing, and SIMD inference",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
   "types": "dist/cjs/index.d.ts",
@@ -74,8 +74,6 @@
   "keywords": [
     "ruvllm",
     "llm",
-    "rlm",
-    "retrieval-language-model",
     "self-learning",
     "adaptive-learning",
     "sona",
@@ -94,9 +92,7 @@
     "deep-learning",
     "napi",
     "rust",
-    "ruvector",
-    "rag",
-    "contrastive-learning"
+    "ruvector"
   ],
   "author": "rUv Team <team@ruv.io>",
   "license": "MIT OR Apache-2.0",

package/scripts/training/validation-results.json

@@ -1,5 +1,5 @@
 {
-  "timestamp": "2026-01-21T14:48:06.797Z",
+  "timestamp": "2026-01-21T00:21:04.044Z",
   "totalAccuracy": 100,
   "results": {
     "claude-flow": {