Big News: Socket raises $60M Series C at a $1B valuation to secure software supply chains for AI-driven development.Announcement →
Sign In

@ruvector/ruvllm

Package Overview
Dependencies
Maintainers
1
Versions
13
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@ruvector/ruvllm - npm Package Compare versions

Comparing version
2.4.1
 to
2.5.0
+136
dist/cjs/intelligence.d.ts
/**
* 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
+1
dist/cjs/intelligence.d.ts.map
{"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"}
+162
dist/cjs/intelligence.js
"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"]}
+136
dist/esm/intelligence.d.ts
/**
* 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
+1
dist/esm/intelligence.d.ts.map
{"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"}
+157
dist/esm/intelligence.js
/**
* 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"]}
+1
-1
dist/cjs/index.d.ts

@@ -65,5 +65,5 @@ /**

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
+1
-1
dist/cjs/index.d.ts.map

@@ -1,1 +0,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"}
+3
-3
dist/cjs/index.js

@@ -95,4 +95,4 @@ "use strict";

__exportStar(require("./benchmarks"), exports);
// RLM - Retrieval Language Model
__exportStar(require("./rlm"), exports);
// External Intelligence Providers (ADR-043)
__exportStar(require("./intelligence"), exports);
// Native bindings utilities

@@ -105,2 +105,2 @@ var native_1 = require("./native");

Object.defineProperty(exports, "default", { enumerable: true, get: function () { return engine_1.RuvLLM; } });
//# sourceMappingURL=data:application/json;base64,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
//# sourceMappingURL=data:application/json;base64,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
+1
-1
dist/esm/index.d.ts

@@ -65,5 +65,5 @@ /**

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
+1
-1
dist/esm/index.d.ts.map

@@ -1,1 +0,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"}
+3
-3
dist/esm/index.js

@@ -78,4 +78,4 @@ /**

export * from './benchmarks';
// RLM - Retrieval Language Model
export * from './rlm';
// External Intelligence Providers (ADR-043)
export * from './intelligence';
// Native bindings utilities

@@ -85,2 +85,2 @@ export { version, hasSimdSupport } from './native';

export { RuvLLM as default } from './engine';
//# sourceMappingURL=data:application/json;base64,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
//# sourceMappingURL=data:application/json;base64,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
+3
-7
package.json
{
"name": "@ruvector/ruvllm",
"version": "2.4.1",
"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",

@@ -77,4 +77,2 @@ "module": "dist/esm/index.js",

"llm",
"rlm",
"retrieval-language-model",
"self-learning",

@@ -98,5 +96,3 @@ "adaptive-learning",

"rust",
"ruvector",
"rag",
"contrastive-learning"
"ruvector"
],

@@ -103,0 +99,0 @@ "author": "rUv Team <team@ruv.io>",

+154
-394
README.md

@@ -1,41 +0,5 @@

<div align="center">
# @ruvector/ruvllm v2.3
# @ruvector/ruvllm
Self-learning LLM orchestration with SONA adaptive learning, HNSW memory, and SIMD inference for Node.js.
### The First Purpose-Built LLM Runtime for Claude Code Agent Orchestration
**100% Routing Accuracy | Sub-Millisecond Inference | Self-Learning**
[![npm](https://img.shields.io/npm/v/@ruvector/ruvllm)](https://www.npmjs.com/package/@ruvector/ruvllm)
[![Downloads](https://img.shields.io/npm/dm/@ruvector/ruvllm)](https://www.npmjs.com/package/@ruvector/ruvllm)
[![License](https://img.shields.io/badge/license-MIT%2FApache--2.0-blue)](LICENSE)
[![Tests](https://img.shields.io/badge/tests-145%20passing-brightgreen)](./test)
[Quick Start](#quick-start) | [RLM](#rlm-recursive-language-model) | [Training](#training) | [Models](#models) | [API](#api-reference)
</div>
---
## What is @ruvector/ruvllm?
**@ruvector/ruvllm** is a TypeScript/JavaScript SDK for intelligent LLM orchestration, specifically designed for **Claude Code** and multi-agent systems. It provides:
- **RLM (Recursive Language Model)** - Break complex queries into sub-queries, synthesize coherent answers
- **100% Routing Accuracy** - Hybrid keyword + embedding strategy for perfect agent selection
- **SONA Self-Learning** - Model improves with every successful interaction
- **SIMD Acceleration** - AVX2/NEON optimized inference
### Why @ruvector/ruvllm?
| Challenge | Traditional Approach | @ruvector/ruvllm Solution |
|-----------|---------------------|---------------------------|
| Agent selection | Manual or keyword-based | Semantic + keyword hybrid = **100%** |
| Complex queries | Single-shot RAG | Recursive decomposition + synthesis |
| Response latency | 2-5 seconds | **<1ms** cache, 50-200ms full |
| Learning | Static models | **Self-improving** (SONA) |
| Cost per route | $0.01+ (API call) | **$0** (local inference) |
---
## Installation

@@ -50,405 +14,214 @@

```typescript
import { RuvLLM, RlmController } from '@ruvector/ruvllm';
import { RuvLLM, RuvLLMConfig } from '@ruvector/ruvllm';
// Simple LLM inference
// Initialize with default configuration
const llm = new RuvLLM();
// Or with custom configuration
const llm = new RuvLLM({
modelPath: '~/.ruvllm/models/ruvltra-claude-code-0.5b-q4_k_m.gguf',
modelPath: './models/ruvltra-small-q4km.gguf',
sonaEnabled: true,
flashAttention: true,
maxTokens: 256,
});
// Generate text
const response = await llm.query('Explain quantum computing');
console.log(response.text);
// Recursive Language Model for complex queries
const rlm = new RlmController({ maxDepth: 5 });
const answer = await rlm.query('What are the causes AND solutions for slow API responses?');
// Automatically decomposes into sub-queries, retrieves context, synthesizes answer
// Stream generation
for await (const token of llm.stream('Write a haiku about Rust')) {
process.stdout.write(token);
}
```
---
## What's New in v2.3
## Core Features
| Feature | Description |
|---------|-------------|
| **RuvLTRA Models** | Purpose-built 0.5B & 3B models for Claude Flow |
| **Task-Specific LoRA** | 5 pre-trained adapters (coder, researcher, security, architect, reviewer) |
| **HuggingFace Hub** | Download/upload models directly |
| **Adapter Merging** | TIES, DARE, SLERP strategies |
| **HNSW Routing** | 150x faster semantic matching |
| **Evaluation Harness** | SWE-Bench testing with 5 ablation modes |
| **Auto-Dimension** | HNSW auto-detects model embedding size |
| **mistral-rs Backend** | Production serving with PagedAttention, X-LoRA, ISQ (5-10x concurrent users) |
### 1. Claude Code Native Routing
## CLI Usage
Built **by** Claude Code, **for** Claude Code. Routes tasks to 60+ agent types:
```bash
# Query a model
ruvllm query "What is machine learning?"
```typescript
import { RuvLLM } from '@ruvector/ruvllm';
# Stream output
ruvllm query --stream "Write a poem"
const llm = new RuvLLM({ model: 'ruv/ruvltra' });
# Download a model
ruvllm download ruvector/ruvltra-small-q4km
// Intelligent routing
const route = await llm.route('implement OAuth2 authentication');
console.log(route.agent); // 'security-architect'
console.log(route.confidence); // 0.98
console.log(route.tier); // 2 (Haiku-level complexity)
# Benchmark
ruvllm bench ./models/model.gguf
// Multi-agent teams for complex tasks
const team = await llm.routeComplex('build full-stack app with auth');
// Returns: [system-architect, backend-dev, coder, security-architect, tester]
# Run evaluation (SWE-Bench)
ruvllm eval --model ./models/model.gguf --subset lite --max-tasks 50
```
### 2. 3-Tier Intelligent Routing
## API Reference
```
┌─────────────────────────────────────────────────────────┐
│ User Request │
└─────────────────────┬───────────────────────────────────┘
↓
[RuvLTRA Routing]
↓
┌─────────────┼─────────────┐
↓ ↓ ↓
┌───────────┐ ┌───────────┐ ┌───────────┐
│ Tier 1 │ │ Tier 2 │ │ Tier 3 │
│ Booster │ │ Haiku │ │ Opus │
│ <1ms │ │ ~500ms │ │ 2-5s │
│ $0 │ │ $0.0002 │ │ $0.015 │
└───────────┘ └───────────┘ └───────────┘
```
### RuvLLM Class
### 3. Self-Learning (SONA)
Every successful interaction improves the model:
```typescript
// First routing: Full inference
llm.route('implement OAuth2') → security-architect (97%)
class RuvLLM {
constructor(config?: RuvLLMConfig);
// Later: Pattern hit in <25μs (learned from success)
llm.route('add OAuth2 flow') → security-architect (99%, cached pattern)
```
// Generate text
query(prompt: string, params?: GenerateParams): Promise<Response>;
---
// Stream generation
stream(prompt: string, params?: GenerateParams): AsyncIterable<string>;
## RLM (Recursive Language Model)
// Load a model
loadModel(path: string): Promise<void>;
RLM provides **recursive query decomposition** - unlike traditional RAG that retrieves once, RLM breaks complex questions into sub-queries and synthesizes coherent answers.
// Get SONA learning stats
sonaStats(): SonaStats | null;
### How It Works
// Adapt on feedback
adapt(input: Float32Array, quality: number): void;
}
```
Query: "What are the causes AND solutions for slow API responses?"
↓
[Decomposition]
/ \
"Causes of slow API?" "Solutions for slow API?"
↓ ↓
[Sub-answers] [Sub-answers]
\ /
[Synthesis]
↓
Coherent combined answer with sources
```
### Basic Usage
### Configuration
```typescript
import { RlmController } from '@ruvector/ruvllm';
const rlm = new RlmController({
maxDepth: 5,
retrievalTopK: 10,
enableCache: true,
});
// Add knowledge to memory
await rlm.addMemory('TypeScript adds static typing to JavaScript.');
await rlm.addMemory('React is a library for building user interfaces.');
// Query with recursive retrieval
const answer = await rlm.query('What are causes and solutions for type errors in React?');
console.log(answer.text); // Comprehensive synthesized answer
console.log(answer.sources); // Source attributions
console.log(answer.qualityScore); // 0.0-1.0
console.log(answer.confidence); // Routing confidence
```
### Streaming
```typescript
for await (const event of rlm.queryStream('Explain machine learning')) {
if (event.type === 'token') {
process.stdout.write(event.text);
} else {
console.log('\n\nQuality:', event.answer.qualityScore);
}
interface RuvLLMConfig {
modelPath?: string; // Path to GGUF model
sonaEnabled?: boolean; // Enable SONA learning (default: true)
flashAttention?: boolean; // Use Flash Attention 2 (default: true)
maxTokens?: number; // Max generation tokens (default: 256)
temperature?: number; // Sampling temperature (default: 0.7)
topP?: number; // Top-p sampling (default: 0.9)
}
```
### With Self-Reflection
### Generate Parameters
```typescript
const rlm = new RlmController({
enableReflection: true,
maxReflectionIterations: 2,
minQualityScore: 0.8,
});
// Answers are iteratively refined until quality >= 0.8
const answer = await rlm.query('Complex multi-part technical question...');
```
### RLM Configuration
```typescript
interface RlmConfig {
maxDepth?: number; // Max recursion depth (default: 3)
maxSubQueries?: number; // Max sub-queries per level (default: 5)
tokenBudget?: number; // Token budget (default: 4096)
enableCache?: boolean; // Enable caching (default: true)
cacheTtl?: number; // Cache TTL in ms (default: 300000)
retrievalTopK?: number; // Memory spans to retrieve (default: 10)
minQualityScore?: number; // Min quality threshold (default: 0.7)
enableReflection?: boolean; // Enable self-reflection (default: false)
maxReflectionIterations?: number; // Max reflection loops (default: 2)
interface GenerateParams {
maxTokens?: number;
temperature?: number;
topP?: number;
topK?: number;
repetitionPenalty?: number;
stopSequences?: string[];
}
```
---
## SIMD Module
## Unique Capabilities
For direct access to optimized SIMD kernels:
### 1. Memory-Augmented Routing
Every successful routing is stored in HNSW-indexed memory for instant recall:
```typescript
// First time: Full inference (~50ms)
route("implement OAuth2") → security-architect (97% confidence)
// Later: Memory hit (<25μs)
route("add OAuth2 flow") → security-architect (99% confidence, cached)
```
### 2. Confidence-Aware Escalation
```typescript
// Low confidence automatically escalates
Confidence > 0.9 → Use recommended agent
Confidence 0.7-0.9 → Use with human confirmation
Confidence < 0.7 → Escalate to higher tier
```
### 3. Batch SIMD Operations
```typescript
import { simd } from '@ruvector/ruvllm/simd';
// 4x faster vector operations with AVX2/NEON
const similarity = simd.batchCosineSimilarity(query, targets);
const attended = simd.flashAttention(q, k, v, scale);
```
// Dot product
const result = simd.dotProduct(vecA, vecB);
### 4. Zero-Copy Caching
// Matrix multiplication
const output = simd.matmul(matrix, vector);
Arc-based string interning for 100-1000x faster cache hits on large responses.
// Flash Attention
const attended = simd.flashAttention(query, key, value, scale);
---
## Performance
### Benchmarks (M4 Pro)
| Operation | Latency | Throughput |
|-----------|---------|------------|
| Query decomposition | 340 ns | 2.9M/s |
| Cache lookup | 23.5 ns | 42.5M/s |
| Embedding (384d) | 293 ns | 3.4M/s |
| Memory search (10k) | 0.4 ms | 2.5K/s |
| End-to-end routing | <1 ms | 1K+/s |
| Full RLM query | 50-200 ms | 5-20/s |
### Routing Accuracy
| Strategy | RuvLTRA | Qwen Base | OpenAI |
|----------|---------|-----------|--------|
| Embedding Only | 45% | 40% | 52% |
| Keyword Only | 78% | 78% | N/A |
| **Hybrid** | **100%** | 95% | N/A |
### Test Results
// RMS Normalization
simd.rmsNorm(hidden, weights, epsilon);
```
145 tests passing
- RLM Controller: 24 tests
- Routing Accuracy: 18 tests
- Contrastive Training: 15 tests
- SIMD Operations: 22 tests
- SONA Learning: 19 tests
- Memory/HNSW: 21 tests
- Benchmarks: 26 tests
```
---
## Performance (M4 Pro)
## Models
| Operation | Performance |
|-----------|-------------|
| Inference | 88-135 tok/s |
| Flash Attention | 320µs (seq=2048) |
| HNSW Search | 17-62µs |
| SONA Adapt | <1ms |
| Evaluation | 5 ablation modes |
### HuggingFace Repository
## Evaluation Harness
**URL**: [https://huggingface.co/ruv/ruvltra](https://huggingface.co/ruv/ruvltra)
Run model evaluations with SWE-Bench integration:
### Available Models
| Model | Size | Purpose | Accuracy |
|-------|------|---------|----------|
| **ruvltra-claude-code-0.5b-q4_k_m** | 398 MB | Agent routing | **100%** (hybrid) |
| ruvltra-small-0.5b-q4_k_m | ~400 MB | Embeddings | - |
| ruvltra-medium-1.1b-q4_k_m | ~1 GB | Full inference | - |
### Download Models
```typescript
// Programmatic
import { downloadModel } from '@ruvector/ruvllm';
await downloadModel('ruv/ruvltra', { quantization: 'q4_k_m' });
import { RuvLLM, EvaluationHarness, AblationMode } from '@ruvector/ruvllm';
// CLI
ruvllm download ruv/ruvltra
```
### Auto-Download
Models are automatically downloaded on first use:
```typescript
const llm = new RuvLLM({ model: 'ruv/ruvltra' });
// Downloads to ~/.ruvllm/models/ if not present
```
---
## Training
### Generate Routing Dataset
```bash
node scripts/training/routing-dataset.js
# Output: 381 examples, 793 contrastive pairs, 156 hard negatives
```
### Contrastive Fine-tuning
```typescript
import { ContrastiveTrainer } from '@ruvector/ruvllm';
const trainer = new ContrastiveTrainer({
modelPath: './models/base.gguf',
loraRank: 8,
loraAlpha: 16,
learningRate: 1e-4,
const harness = new EvaluationHarness({
modelPath: './models/model.gguf',
enableHnsw: true,
enableSona: true,
});
const pairs = [
{ anchor: 'Fix auth bug', positive: 'coder', negative: 'researcher' },
// ... more pairs
];
// Run single evaluation
const result = await harness.evaluate(
'Fix the null pointer exception',
'def process(data): return data.split()',
AblationMode.Full
);
await trainer.train(pairs, { epochs: 10 });
await trainer.save('./adapters/routing-lora');
```
console.log(`Success: ${result.success}, Quality: ${result.qualityScore}`);
### Training Scripts
| Script | Description |
|--------|-------------|
| `routing-dataset.js` | Generate 381 routing examples |
| `claude-code-synth.js` | Synthetic data generation |
| `contrastive-finetune.js` | LoRA fine-tuning pipeline |
| `rlm-dataset.js` | RLM training data (500 examples) |
---
## API Reference
### RuvLLM Class
```typescript
class RuvLLM {
constructor(config?: RuvLLMConfig);
query(prompt: string, params?: GenerateParams): Promise<Response>;
stream(prompt: string, params?: GenerateParams): AsyncIterable<string>;
route(task: string): Promise<RoutingResult>;
routeComplex(task: string): Promise<AgentTeam[]>;
loadModel(path: string): Promise<void>;
addMemory(text: string, metadata?: object): number;
searchMemory(query: string, topK?: number): MemoryResult[];
sonaStats(): SonaStats | null;
adapt(input: Float32Array, quality: number): void;
// Run ablation study (Baseline, RetrievalOnly, AdaptersOnly, R+A, Full)
const report = await harness.runAblationStudy(tasks);
for (const [mode, metrics] of Object.entries(report.modeMetrics)) {
console.log(`${mode}: ${metrics.successRate * 100}% success`);
}
```
### RlmController Class
## mistral-rs Backend (Production Serving)
```typescript
class RlmController {
constructor(config?: RlmConfig, engine?: RuvLLM);
For production deployments with 10-100+ concurrent users, use the mistral-rs backend:
query(input: string): Promise<RlmAnswer>;
queryStream(input: string): AsyncGenerator<StreamToken>;
addMemory(text: string, metadata?: object): Promise<string>;
searchMemory(query: string, topK?: number): Promise<MemorySpan[]>;
clearCache(): void;
getCacheStats(): { size: number; entries: number };
updateConfig(config: Partial<RlmConfig>): void;
getConfig(): Required<RlmConfig>;
}
```
### All Exports
```typescript
import {
// Core
RuvLLM, RuvLLMConfig,
import { RuvLLM, MistralBackend, PagedAttentionConfig } from '@ruvector/ruvllm';
// RLM
RlmController, RlmConfig, RlmAnswer, MemorySpan, StreamToken,
// Configure for production serving
const backend = new MistralBackend({
// PagedAttention: 5-10x more concurrent users
pagedAttention: {
blockSize: 16,
maxBlocks: 4096,
gpuMemoryFraction: 0.9,
prefixCaching: true,
},
// X-LoRA: Per-token adapter routing
xlora: {
adapters: ['./adapters/coder', './adapters/researcher'],
topK: 2,
},
// ISQ: Runtime quantization
isq: {
bits: 4,
method: 'awq',
},
});
// Training
RlmTrainer, ContrastiveTrainer, createRlmTrainer,
DEFAULT_RLM_CONFIG, FAST_RLM_CONFIG, THOROUGH_RLM_CONFIG,
const llm = new RuvLLM({ backend });
await llm.loadModel('mistralai/Mistral-7B-Instruct-v0.2');
// SONA Learning
SonaCoordinator, TrajectoryBuilder,
// LoRA
LoraAdapter, LoraManager,
// Benchmarks
ModelComparisonBenchmark, RoutingBenchmark, EmbeddingBenchmark,
} from '@ruvector/ruvllm';
// Serve multiple concurrent requests
const response = await llm.query('Write production code');
```
---
> **Note**: mistral-rs features require the Rust backend with `mistral-rs` feature enabled. Native bindings will use mistral-rs when available.
## CLI
## Supported Models
```bash
# Route a task
ruvllm route "add unit tests for auth module"
# → Agent: tester | Confidence: 0.96 | Tier: 2
- **RuvLTRA-Small** (494M) - Q4K, Q5K, Q8
- **RuvLTRA-Medium** (3B) - Q4K, Q5K, Q8
- **Qwen 2.5** (0.5B-72B)
- **Llama 3.x** (8B-70B)
- **Mistral** (7B-22B)
- **Phi-3** (3.8B-14B)
- **Gemma-2** (2B-27B)
# Query with streaming
ruvllm query --stream "Explain machine learning"
# Download models
ruvllm download ruv/ruvltra
# Run benchmarks
ruvllm bench ./models/model.gguf
# Evaluate (SWE-Bench)
ruvllm eval --model ./models/model.gguf --subset lite
```
---
## Platform Support

@@ -458,35 +231,22 @@

|----------|--------------|--------|
| macOS | arm64 (M1-M4) | Full support |
| macOS | x64 | Supported |
| Linux | x64 | Supported |
| Linux | arm64 | Supported |
| Windows | x64 | Supported |
| macOS | arm64 (M1-M4) | ✅ Full support |
| macOS | x64 | ✅ Supported |
| Linux | x64 | ✅ Supported |
| Linux | arm64 | ✅ Supported |
| Windows | x64 | ✅ Supported |
---
## Related Packages
- [@ruvector/core](https://www.npmjs.com/package/@ruvector/core) - Vector operations
- [@ruvector/sona](https://www.npmjs.com/package/@ruvector/sona) - SONA learning engine
- [@ruvector/ruvector](https://www.npmjs.com/package/@ruvector/ruvector) - Full Ruvector SDK
## Links
| Resource | URL |
|----------|-----|
| **npm** | [npmjs.com/package/@ruvector/ruvllm](https://www.npmjs.com/package/@ruvector/ruvllm) |
| **HuggingFace** | [huggingface.co/ruv/ruvltra](https://huggingface.co/ruv/ruvltra) |
| **Crate (Rust)** | [crates.io/crates/ruvllm](https://crates.io/crates/ruvllm) |
| **Documentation** | [docs.rs/ruvllm](https://docs.rs/ruvllm) |
| **GitHub** | [github.com/ruvnet/ruvector](https://github.com/ruvnet/ruvector) |
| **Claude Flow** | [github.com/ruvnet/claude-flow](https://github.com/ruvnet/claude-flow) |
- [GitHub Repository](https://github.com/ruvnet/ruvector)
- [API Documentation](https://docs.rs/ruvllm)
- [Crate (Rust)](https://crates.io/crates/ruvllm)
---
## License
MIT OR Apache-2.0
---
<div align="center">
**Built for Claude Code. Optimized for agents. Designed for speed.**
[Get Started](#quick-start) | [View on GitHub](https://github.com/ruvnet/ruvector)
</div>
+1
-1
scripts/training/validation-results.json
{
"timestamp": "2026-01-21T14:48:06.797Z",
"timestamp": "2026-01-21T00:21:04.044Z",
"totalAccuracy": 100,

@@ -4,0 +4,0 @@ "results": {

-245
dist/cjs/rlm/controller.d.ts
/**
* RLM Controller - Recursive Retrieval Language Model
*
* Implements a recursive retrieval-augmented generation system that:
* 1. Breaks down complex queries into sub-queries
* 2. Retrieves relevant memory spans for each query
* 3. Synthesizes coherent answers from retrieved context
* 4. Optionally reflects on and refines answers
*
* @example Basic Usage
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* maxDepth: 3,
* retrievalTopK: 10,
* enableCache: true,
* });
*
* // Add knowledge to memory
* await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');
* await rlm.addMemory('Deep learning uses neural networks with many layers.');
*
* // Query with recursive retrieval
* const answer = await rlm.query('Explain the relationship between ML and deep learning');
* console.log(answer.text);
* console.log('Sources:', answer.sources.length);
* console.log('Confidence:', answer.confidence);
* ```
*
* @example Streaming
* ```typescript
* const rlm = new RlmController();
*
* for await (const event of rlm.queryStream('What is AI?')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nDone! Quality:', event.answer.qualityScore);
* }
* }
* ```
*
* @example With Reflection
* ```typescript
* const rlm = new RlmController({
* enableReflection: true,
* maxReflectionIterations: 2,
* minQualityScore: 0.8,
* });
*
* const answer = await rlm.query('Complex multi-part question...');
* // Answer will be iteratively refined until quality >= 0.8
* ```
*/
import { RlmConfig, RlmAnswer, MemorySpan, StreamToken } from './types';
import { RuvLLM } from '../engine';
/**
* RlmController - Recursive Retrieval Language Model Controller
*
* Orchestrates retrieval-augmented generation with recursive sub-query
* decomposition, memory search, and optional self-reflection.
*/
export declare class RlmController {
private config;
private cache;
private engine;
private memoryIdCounter;
/**
* Create a new RLM controller
*
* @param config - Configuration options
* @param engine - Optional RuvLLM engine instance (creates new if not provided)
*
* @example
* ```typescript
* // With default config
* const rlm = new RlmController();
*
* // With custom config
* const rlm = new RlmController({
* maxDepth: 5,
* enableReflection: true,
* });
*
* // With existing engine
* const engine = new RuvLLM({ learningEnabled: true });
* const rlm = new RlmController({}, engine);
* ```
*/
constructor(config?: RlmConfig, engine?: RuvLLM);
/**
* Query the RLM with recursive retrieval
*
* @param input - The query string
* @returns Promise resolving to the answer with sources and metadata
*
* @example
* ```typescript
* const answer = await rlm.query('What is the capital of France?');
* console.log(answer.text); // "The capital of France is Paris..."
* console.log(answer.confidence); // 0.95
* console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]
* ```
*/
query(input: string): Promise<RlmAnswer>;
/**
* Query with streaming response
*
* @param input - The query string
* @yields StreamToken events (either partial tokens or final answer)
*
* @example
* ```typescript
* for await (const event of rlm.queryStream('Explain quantum computing')) {
* if (event.type === 'token') {
* // Partial token received
* process.stdout.write(event.text);
* } else {
* // Generation complete
* console.log('\n\nSources:', event.answer.sources.length);
* }
* }
* ```
*/
queryStream(input: string): AsyncGenerator<StreamToken>;
/**
* Add content to memory for retrieval
*
* @param text - The text content to store
* @param metadata - Optional metadata to associate with the memory
* @returns Promise resolving to the memory span ID
*
* @example
* ```typescript
* const id1 = await rlm.addMemory(
* 'TypeScript is a typed superset of JavaScript.',
* { source: 'documentation', category: 'programming' }
* );
*
* const id2 = await rlm.addMemory(
* 'React is a JavaScript library for building UIs.'
* );
* ```
*/
addMemory(text: string, metadata?: Record<string, unknown>): Promise<string>;
/**
* Search memory for relevant spans
*
* @param query - The search query
* @param topK - Number of results to return (default: config.retrievalTopK)
* @returns Promise resolving to array of memory spans
*
* @example
* ```typescript
* const spans = await rlm.searchMemory('JavaScript frameworks', 5);
* for (const span of spans) {
* console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);
* }
* ```
*/
searchMemory(query: string, topK?: number): Promise<MemorySpan[]>;
/**
* Clear the response cache
*
* @example
* ```typescript
* rlm.clearCache();
* console.log('Cache cleared');
* ```
*/
clearCache(): void;
/**
* Get current cache statistics
*
* @returns Object with cache size and hit rate info
*/
getCacheStats(): {
size: number;
entries: number;
};
/**
* Update configuration at runtime
*
* @param config - Partial configuration to merge
*/
updateConfig(config: Partial<RlmConfig>): void;
/**
* Get current configuration
*/
getConfig(): Required<RlmConfig>;
/**
* Generate sub-queries for complex questions
*/
private generateSubQueries;
/**
* Decompose a complex query into simpler parts
*/
private decomposeQuery;
/**
* Build context string from sources and sub-queries
*/
private buildContext;
/**
* Build the full prompt with context
*/
private buildPrompt;
/**
* Get generation config based on RLM settings
*/
private getGenerationConfig;
/**
* Estimate token usage
*/
private estimateTokenUsage;
/**
* Calculate quality score based on sources and confidence
*/
private calculateQualityScore;
/**
* Apply self-reflection to improve answer
*/
private applyReflection;
/**
* Get cached answer if valid
*/
private getCached;
/**
* Set cache entry
*/
private setCache;
/**
* Simple hash function for cache keys
*/
private hashQuery;
/**
* Prune expired cache entries
*/
private pruneCache;
/**
* Utility delay function for streaming simulation
*/
private delay;
}
//# sourceMappingURL=controller.d.ts.map
-1
dist/cjs/rlm/controller.d.ts.map
{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/rlm/controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EACL,SAAS,EACT,SAAS,EACT,UAAU,EAGV,WAAW,EAGZ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAkBnC;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,eAAe,CAAS;IAEhC;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM;IAO/C;;;;;;;;;;;;;OAaG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAsD9C;;;;;;;;;;;;;;;;;;OAkBG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,WAAW,CAAC;IA2D9D;;;;;;;;;;;;;;;;;;OAkBG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAMlF;;;;;;;;;;;;;;OAcG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAavE;;;;;;;;OAQG;IACH,UAAU,IAAI,IAAI;IAIlB;;;;OAIG;IACH,aAAa,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAOlD;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAI9C;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,SAAS,CAAC;IAQhC;;OAEG;YACW,kBAAkB;IAkChC;;OAEG;IACH,OAAO,CAAC,cAAc;IAyBtB;;OAEG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAY7B;;OAEG;YACW,eAAe;IA0D7B;;OAEG;IACH,OAAO,CAAC,SAAS;IAiBjB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAchB;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;IACH,OAAO,CAAC,UAAU;IA0BlB;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}
-554
dist/cjs/rlm/controller.js
"use strict";
/**
* RLM Controller - Recursive Retrieval Language Model
*
* Implements a recursive retrieval-augmented generation system that:
* 1. Breaks down complex queries into sub-queries
* 2. Retrieves relevant memory spans for each query
* 3. Synthesizes coherent answers from retrieved context
* 4. Optionally reflects on and refines answers
*
* @example Basic Usage
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* maxDepth: 3,
* retrievalTopK: 10,
* enableCache: true,
* });
*
* // Add knowledge to memory
* await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');
* await rlm.addMemory('Deep learning uses neural networks with many layers.');
*
* // Query with recursive retrieval
* const answer = await rlm.query('Explain the relationship between ML and deep learning');
* console.log(answer.text);
* console.log('Sources:', answer.sources.length);
* console.log('Confidence:', answer.confidence);
* ```
*
* @example Streaming
* ```typescript
* const rlm = new RlmController();
*
* for await (const event of rlm.queryStream('What is AI?')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nDone! Quality:', event.answer.qualityScore);
* }
* }
* ```
*
* @example With Reflection
* ```typescript
* const rlm = new RlmController({
* enableReflection: true,
* maxReflectionIterations: 2,
* minQualityScore: 0.8,
* });
*
* const answer = await rlm.query('Complex multi-part question...');
* // Answer will be iteratively refined until quality >= 0.8
* ```
*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.RlmController = void 0;
const engine_1 = require("../engine");
/**
* Default configuration values
*/
const DEFAULT_CONFIG = {
maxDepth: 3,
maxSubQueries: 5,
tokenBudget: 4096,
enableCache: true,
cacheTtl: 300000, // 5 minutes
retrievalTopK: 10,
minQualityScore: 0.7,
enableReflection: false,
maxReflectionIterations: 2,
};
/**
* RlmController - Recursive Retrieval Language Model Controller
*
* Orchestrates retrieval-augmented generation with recursive sub-query
* decomposition, memory search, and optional self-reflection.
*/
class RlmController {
/**
* Create a new RLM controller
*
* @param config - Configuration options
* @param engine - Optional RuvLLM engine instance (creates new if not provided)
*
* @example
* ```typescript
* // With default config
* const rlm = new RlmController();
*
* // With custom config
* const rlm = new RlmController({
* maxDepth: 5,
* enableReflection: true,
* });
*
* // With existing engine
* const engine = new RuvLLM({ learningEnabled: true });
* const rlm = new RlmController({}, engine);
* ```
*/
constructor(config, engine) {
this.config = { ...DEFAULT_CONFIG, ...config };
this.cache = new Map();
this.engine = engine ?? new engine_1.RuvLLM({ learningEnabled: true });
this.memoryIdCounter = 0;
}
/**
* Query the RLM with recursive retrieval
*
* @param input - The query string
* @returns Promise resolving to the answer with sources and metadata
*
* @example
* ```typescript
* const answer = await rlm.query('What is the capital of France?');
* console.log(answer.text); // "The capital of France is Paris..."
* console.log(answer.confidence); // 0.95
* console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]
* ```
*/
async query(input) {
// Check cache first
if (this.config.enableCache) {
const cached = this.getCached(input);
if (cached) {
return { ...cached, cached: true };
}
}
// Retrieve relevant memory spans
const sources = await this.searchMemory(input, this.config.retrievalTopK);
// Generate sub-queries if needed and depth allows
const subQueries = await this.generateSubQueries(input, sources, 0);
// Build context from sources and sub-query answers
const context = this.buildContext(sources, subQueries);
// Generate the answer
const startTime = Date.now();
const response = this.engine.query(this.buildPrompt(input, context), this.getGenerationConfig());
// Calculate token usage (estimate if not provided by engine)
const tokenUsage = this.estimateTokenUsage(input, context, response.text);
// Calculate quality score
const qualityScore = this.calculateQualityScore(sources, response.confidence);
let answer = {
text: response.text,
confidence: response.confidence,
qualityScore,
sources,
subQueries: subQueries.length > 0 ? subQueries : undefined,
tokenUsage,
cached: false,
};
// Apply reflection if enabled and quality is below threshold
if (this.config.enableReflection && qualityScore < this.config.minQualityScore) {
answer = await this.applyReflection(input, answer);
}
// Cache the result
if (this.config.enableCache) {
this.setCache(input, answer);
}
return answer;
}
/**
* Query with streaming response
*
* @param input - The query string
* @yields StreamToken events (either partial tokens or final answer)
*
* @example
* ```typescript
* for await (const event of rlm.queryStream('Explain quantum computing')) {
* if (event.type === 'token') {
* // Partial token received
* process.stdout.write(event.text);
* } else {
* // Generation complete
* console.log('\n\nSources:', event.answer.sources.length);
* }
* }
* ```
*/
async *queryStream(input) {
// Check cache first
if (this.config.enableCache) {
const cached = this.getCached(input);
if (cached) {
// Simulate streaming for cached response
const words = cached.text.split(' ');
for (const word of words) {
yield { type: 'token', text: word + ' ', done: false };
await this.delay(10); // Small delay for realistic streaming
}
yield { type: 'done', answer: { ...cached, cached: true }, done: true };
return;
}
}
// Retrieve sources
const sources = await this.searchMemory(input, this.config.retrievalTopK);
const subQueries = await this.generateSubQueries(input, sources, 0);
const context = this.buildContext(sources, subQueries);
// Generate with simulated streaming
const prompt = this.buildPrompt(input, context);
const response = this.engine.query(prompt, this.getGenerationConfig());
// Stream the response word by word
const words = response.text.split(' ');
let streamedText = '';
for (let i = 0; i < words.length; i++) {
const word = words[i];
const text = i < words.length - 1 ? word + ' ' : word;
streamedText += text;
yield { type: 'token', text, done: false };
await this.delay(20); // Simulate generation latency
}
const tokenUsage = this.estimateTokenUsage(input, context, streamedText);
const qualityScore = this.calculateQualityScore(sources, response.confidence);
const answer = {
text: streamedText,
confidence: response.confidence,
qualityScore,
sources,
subQueries: subQueries.length > 0 ? subQueries : undefined,
tokenUsage,
cached: false,
};
// Cache the result
if (this.config.enableCache) {
this.setCache(input, answer);
}
yield { type: 'done', answer, done: true };
}
/**
* Add content to memory for retrieval
*
* @param text - The text content to store
* @param metadata - Optional metadata to associate with the memory
* @returns Promise resolving to the memory span ID
*
* @example
* ```typescript
* const id1 = await rlm.addMemory(
* 'TypeScript is a typed superset of JavaScript.',
* { source: 'documentation', category: 'programming' }
* );
*
* const id2 = await rlm.addMemory(
* 'React is a JavaScript library for building UIs.'
* );
* ```
*/
async addMemory(text, metadata) {
const nodeId = this.engine.addMemory(text, metadata);
const id = `rlm-mem-${this.memoryIdCounter++}-${nodeId}`;
return id;
}
/**
* Search memory for relevant spans
*
* @param query - The search query
* @param topK - Number of results to return (default: config.retrievalTopK)
* @returns Promise resolving to array of memory spans
*
* @example
* ```typescript
* const spans = await rlm.searchMemory('JavaScript frameworks', 5);
* for (const span of spans) {
* console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);
* }
* ```
*/
async searchMemory(query, topK) {
const k = topK ?? this.config.retrievalTopK;
const results = this.engine.searchMemory(query, k);
return results.map((result, index) => ({
id: `rlm-span-${result.id}-${index}`,
text: result.content,
similarityScore: result.score,
source: result.metadata?.source,
metadata: result.metadata,
}));
}
/**
* Clear the response cache
*
* @example
* ```typescript
* rlm.clearCache();
* console.log('Cache cleared');
* ```
*/
clearCache() {
this.cache.clear();
}
/**
* Get current cache statistics
*
* @returns Object with cache size and hit rate info
*/
getCacheStats() {
return {
size: this.cache.size,
entries: this.cache.size,
};
}
/**
* Update configuration at runtime
*
* @param config - Partial configuration to merge
*/
updateConfig(config) {
this.config = { ...this.config, ...config };
}
/**
* Get current configuration
*/
getConfig() {
return { ...this.config };
}
// ============================================
// Private Methods
// ============================================
/**
* Generate sub-queries for complex questions
*/
async generateSubQueries(query, sources, depth) {
if (depth >= this.config.maxDepth) {
return [];
}
// Simple heuristic: generate sub-queries for questions with multiple parts
const subQueries = [];
const parts = this.decomposeQuery(query);
for (const part of parts.slice(0, this.config.maxSubQueries)) {
if (part.trim().length < 10)
continue;
// Search for sub-query specific sources
const subSources = await this.searchMemory(part, Math.ceil(this.config.retrievalTopK / 2));
const context = this.buildContext(subSources, []);
const response = this.engine.query(this.buildPrompt(part, context), { ...this.getGenerationConfig(), maxTokens: 256 });
subQueries.push({
query: part,
answer: response.text,
depth: depth + 1,
});
}
return subQueries;
}
/**
* Decompose a complex query into simpler parts
*/
decomposeQuery(query) {
// Split on common conjunctions and question markers
const parts = [];
// Check for multi-part questions
const conjunctions = [' and ', ' or ', '. ', '? ', '; '];
let current = query;
for (const conj of conjunctions) {
if (current.includes(conj)) {
const split = current.split(conj);
parts.push(...split.filter(p => p.trim().length > 10));
current = '';
break;
}
}
// If no decomposition happened, return original
if (parts.length === 0) {
return [query];
}
return parts;
}
/**
* Build context string from sources and sub-queries
*/
buildContext(sources, subQueries) {
const parts = [];
// Add sources
if (sources.length > 0) {
parts.push('Relevant context:');
for (const source of sources) {
parts.push(`- ${source.text}`);
}
}
// Add sub-query answers
if (subQueries.length > 0) {
parts.push('\nRelated information:');
for (const sq of subQueries) {
parts.push(`Q: ${sq.query}`);
parts.push(`A: ${sq.answer}`);
}
}
return parts.join('\n');
}
/**
* Build the full prompt with context
*/
buildPrompt(query, context) {
if (context.trim().length === 0) {
return query;
}
return `${context}\n\nBased on the above context, answer the following question:\n${query}`;
}
/**
* Get generation config based on RLM settings
*/
getGenerationConfig() {
return {
maxTokens: Math.min(this.config.tokenBudget, 2048),
temperature: 0.7,
topP: 0.9,
};
}
/**
* Estimate token usage
*/
estimateTokenUsage(query, context, response) {
// Rough estimation: ~4 characters per token
const promptTokens = Math.ceil((query.length + context.length) / 4);
const completionTokens = Math.ceil(response.length / 4);
return {
prompt: promptTokens,
completion: completionTokens,
total: promptTokens + completionTokens,
};
}
/**
* Calculate quality score based on sources and confidence
*/
calculateQualityScore(sources, confidence) {
if (sources.length === 0) {
return confidence * 0.5; // Penalize answers without sources
}
// Average source similarity
const avgSimilarity = sources.reduce((sum, s) => sum + s.similarityScore, 0) / sources.length;
// Weighted combination
return confidence * 0.6 + avgSimilarity * 0.4;
}
/**
* Apply self-reflection to improve answer
*/
async applyReflection(query, answer) {
let currentAnswer = answer;
let iterations = 0;
while (iterations < this.config.maxReflectionIterations &&
currentAnswer.qualityScore < this.config.minQualityScore) {
iterations++;
// Generate critique
const critiquePrompt = `Evaluate this answer for accuracy and completeness:
Question: ${query}
Answer: ${currentAnswer.text}
Provide a brief critique and suggest improvements.`;
const critiqueResponse = this.engine.query(critiquePrompt, {
maxTokens: 256,
temperature: 0.5,
});
// Generate improved answer
const improvePrompt = `Based on this feedback: "${critiqueResponse.text}"
Improve this answer:
Question: ${query}
Original: ${currentAnswer.text}
Provide an improved answer:`;
const improvedResponse = this.engine.query(improvePrompt, this.getGenerationConfig());
// Update answer with reflection improvements
const newQualityScore = Math.min(1.0, currentAnswer.qualityScore + 0.1 * iterations);
currentAnswer = {
...currentAnswer,
text: improvedResponse.text,
confidence: Math.max(currentAnswer.confidence, improvedResponse.confidence),
qualityScore: newQualityScore,
tokenUsage: {
prompt: currentAnswer.tokenUsage.prompt + 100, // Approximate additional tokens
completion: currentAnswer.tokenUsage.completion + 100,
total: currentAnswer.tokenUsage.total + 200,
},
};
}
return currentAnswer;
}
/**
* Get cached answer if valid
*/
getCached(query) {
const hash = this.hashQuery(query);
const entry = this.cache.get(hash);
if (!entry) {
return null;
}
// Check TTL
if (Date.now() - entry.timestamp > this.config.cacheTtl) {
this.cache.delete(hash);
return null;
}
return entry.answer;
}
/**
* Set cache entry
*/
setCache(query, answer) {
const hash = this.hashQuery(query);
this.cache.set(hash, {
answer,
timestamp: Date.now(),
queryHash: hash,
});
// Prune old entries if cache gets too large
if (this.cache.size > 1000) {
this.pruneCache();
}
}
/**
* Simple hash function for cache keys
*/
hashQuery(query) {
let hash = 0;
for (let i = 0; i < query.length; i++) {
const char = query.charCodeAt(i);
hash = ((hash << 5) - hash) + char;
hash = hash & hash; // Convert to 32-bit integer
}
return `rlm-cache-${hash.toString(16)}`;
}
/**
* Prune expired cache entries
*/
pruneCache() {
const now = Date.now();
const toDelete = [];
for (const [key, entry] of this.cache.entries()) {
if (now - entry.timestamp > this.config.cacheTtl) {
toDelete.push(key);
}
}
// Delete oldest entries if still too large
if (this.cache.size - toDelete.length > 800) {
const entries = Array.from(this.cache.entries())
.sort((a, b) => a[1].timestamp - b[1].timestamp);
const deleteCount = entries.length - 500;
for (let i = 0; i < deleteCount; i++) {
toDelete.push(entries[i][0]);
}
}
for (const key of toDelete) {
this.cache.delete(key);
}
}
/**
* Utility delay function for streaming simulation
*/
delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
}
exports.RlmController = RlmController;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../src/rlm/controller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RLM Controller - Recursive Retrieval Language Model\n *\n * Implements a recursive retrieval-augmented generation system that:\n * 1. Breaks down complex queries into sub-queries\n * 2. Retrieves relevant memory spans for each query\n * 3. Synthesizes coherent answers from retrieved context\n * 4. Optionally reflects on and refines answers\n *\n * @example Basic Usage\n * ```typescript\n * import { RlmController } from '@ruvector/ruvllm';\n *\n * const rlm = new RlmController({\n *   maxDepth: 3,\n *   retrievalTopK: 10,\n *   enableCache: true,\n * });\n *\n * // Add knowledge to memory\n * await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');\n * await rlm.addMemory('Deep learning uses neural networks with many layers.');\n *\n * // Query with recursive retrieval\n * const answer = await rlm.query('Explain the relationship between ML and deep learning');\n * console.log(answer.text);\n * console.log('Sources:', answer.sources.length);\n * console.log('Confidence:', answer.confidence);\n * ```\n *\n * @example Streaming\n * ```typescript\n * const rlm = new RlmController();\n *\n * for await (const event of rlm.queryStream('What is AI?')) {\n *   if (event.type === 'token') {\n *     process.stdout.write(event.text);\n *   } else {\n *     console.log('\\n\\nDone! Quality:', event.answer.qualityScore);\n *   }\n * }\n * ```\n *\n * @example With Reflection\n * ```typescript\n * const rlm = new RlmController({\n *   enableReflection: true,\n *   maxReflectionIterations: 2,\n *   minQualityScore: 0.8,\n * });\n *\n * const answer = await rlm.query('Complex multi-part question...');\n * // Answer will be iteratively refined until quality >= 0.8\n * ```\n */\n\nimport {\n  RlmConfig,\n  RlmAnswer,\n  MemorySpan,\n  SubQuery,\n  TokenUsage,\n  StreamToken,\n  RlmCacheEntry,\n  ReflectionResult,\n} from './types';\n\nimport { RuvLLM } from '../engine';\nimport type { GenerationConfig, QueryResponse } from '../types';\n\n/**\n * Default configuration values\n */\nconst DEFAULT_CONFIG: Required<RlmConfig> = {\n  maxDepth: 3,\n  maxSubQueries: 5,\n  tokenBudget: 4096,\n  enableCache: true,\n  cacheTtl: 300000, // 5 minutes\n  retrievalTopK: 10,\n  minQualityScore: 0.7,\n  enableReflection: false,\n  maxReflectionIterations: 2,\n};\n\n/**\n * RlmController - Recursive Retrieval Language Model Controller\n *\n * Orchestrates retrieval-augmented generation with recursive sub-query\n * decomposition, memory search, and optional self-reflection.\n */\nexport class RlmController {\n  private config: Required<RlmConfig>;\n  private cache: Map<string, RlmCacheEntry>;\n  private engine: RuvLLM;\n  private memoryIdCounter: number;\n\n  /**\n   * Create a new RLM controller\n   *\n   * @param config - Configuration options\n   * @param engine - Optional RuvLLM engine instance (creates new if not provided)\n   *\n   * @example\n   * ```typescript\n   * // With default config\n   * const rlm = new RlmController();\n   *\n   * // With custom config\n   * const rlm = new RlmController({\n   *   maxDepth: 5,\n   *   enableReflection: true,\n   * });\n   *\n   * // With existing engine\n   * const engine = new RuvLLM({ learningEnabled: true });\n   * const rlm = new RlmController({}, engine);\n   * ```\n   */\n  constructor(config?: RlmConfig, engine?: RuvLLM) {\n    this.config = { ...DEFAULT_CONFIG, ...config };\n    this.cache = new Map();\n    this.engine = engine ?? new RuvLLM({ learningEnabled: true });\n    this.memoryIdCounter = 0;\n  }\n\n  /**\n   * Query the RLM with recursive retrieval\n   *\n   * @param input - The query string\n   * @returns Promise resolving to the answer with sources and metadata\n   *\n   * @example\n   * ```typescript\n   * const answer = await rlm.query('What is the capital of France?');\n   * console.log(answer.text); // \"The capital of France is Paris...\"\n   * console.log(answer.confidence); // 0.95\n   * console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]\n   * ```\n   */\n  async query(input: string): Promise<RlmAnswer> {\n    // Check cache first\n    if (this.config.enableCache) {\n      const cached = this.getCached(input);\n      if (cached) {\n        return { ...cached, cached: true };\n      }\n    }\n\n    // Retrieve relevant memory spans\n    const sources = await this.searchMemory(input, this.config.retrievalTopK);\n\n    // Generate sub-queries if needed and depth allows\n    const subQueries = await this.generateSubQueries(input, sources, 0);\n\n    // Build context from sources and sub-query answers\n    const context = this.buildContext(sources, subQueries);\n\n    // Generate the answer\n    const startTime = Date.now();\n    const response = this.engine.query(\n      this.buildPrompt(input, context),\n      this.getGenerationConfig()\n    );\n\n    // Calculate token usage (estimate if not provided by engine)\n    const tokenUsage = this.estimateTokenUsage(input, context, response.text);\n\n    // Calculate quality score\n    const qualityScore = this.calculateQualityScore(sources, response.confidence);\n\n    let answer: RlmAnswer = {\n      text: response.text,\n      confidence: response.confidence,\n      qualityScore,\n      sources,\n      subQueries: subQueries.length > 0 ? subQueries : undefined,\n      tokenUsage,\n      cached: false,\n    };\n\n    // Apply reflection if enabled and quality is below threshold\n    if (this.config.enableReflection && qualityScore < this.config.minQualityScore) {\n      answer = await this.applyReflection(input, answer);\n    }\n\n    // Cache the result\n    if (this.config.enableCache) {\n      this.setCache(input, answer);\n    }\n\n    return answer;\n  }\n\n  /**\n   * Query with streaming response\n   *\n   * @param input - The query string\n   * @yields StreamToken events (either partial tokens or final answer)\n   *\n   * @example\n   * ```typescript\n   * for await (const event of rlm.queryStream('Explain quantum computing')) {\n   *   if (event.type === 'token') {\n   *     // Partial token received\n   *     process.stdout.write(event.text);\n   *   } else {\n   *     // Generation complete\n   *     console.log('\\n\\nSources:', event.answer.sources.length);\n   *   }\n   * }\n   * ```\n   */\n  async *queryStream(input: string): AsyncGenerator<StreamToken> {\n    // Check cache first\n    if (this.config.enableCache) {\n      const cached = this.getCached(input);\n      if (cached) {\n        // Simulate streaming for cached response\n        const words = cached.text.split(' ');\n        for (const word of words) {\n          yield { type: 'token', text: word + ' ', done: false };\n          await this.delay(10); // Small delay for realistic streaming\n        }\n        yield { type: 'done', answer: { ...cached, cached: true }, done: true };\n        return;\n      }\n    }\n\n    // Retrieve sources\n    const sources = await this.searchMemory(input, this.config.retrievalTopK);\n    const subQueries = await this.generateSubQueries(input, sources, 0);\n    const context = this.buildContext(sources, subQueries);\n\n    // Generate with simulated streaming\n    const prompt = this.buildPrompt(input, context);\n    const response = this.engine.query(prompt, this.getGenerationConfig());\n\n    // Stream the response word by word\n    const words = response.text.split(' ');\n    let streamedText = '';\n\n    for (let i = 0; i < words.length; i++) {\n      const word = words[i];\n      const text = i < words.length - 1 ? word + ' ' : word;\n      streamedText += text;\n\n      yield { type: 'token', text, done: false };\n      await this.delay(20); // Simulate generation latency\n    }\n\n    const tokenUsage = this.estimateTokenUsage(input, context, streamedText);\n    const qualityScore = this.calculateQualityScore(sources, response.confidence);\n\n    const answer: RlmAnswer = {\n      text: streamedText,\n      confidence: response.confidence,\n      qualityScore,\n      sources,\n      subQueries: subQueries.length > 0 ? subQueries : undefined,\n      tokenUsage,\n      cached: false,\n    };\n\n    // Cache the result\n    if (this.config.enableCache) {\n      this.setCache(input, answer);\n    }\n\n    yield { type: 'done', answer, done: true };\n  }\n\n  /**\n   * Add content to memory for retrieval\n   *\n   * @param text - The text content to store\n   * @param metadata - Optional metadata to associate with the memory\n   * @returns Promise resolving to the memory span ID\n   *\n   * @example\n   * ```typescript\n   * const id1 = await rlm.addMemory(\n   *   'TypeScript is a typed superset of JavaScript.',\n   *   { source: 'documentation', category: 'programming' }\n   * );\n   *\n   * const id2 = await rlm.addMemory(\n   *   'React is a JavaScript library for building UIs.'\n   * );\n   * ```\n   */\n  async addMemory(text: string, metadata?: Record<string, unknown>): Promise<string> {\n    const nodeId = this.engine.addMemory(text, metadata);\n    const id = `rlm-mem-${this.memoryIdCounter++}-${nodeId}`;\n    return id;\n  }\n\n  /**\n   * Search memory for relevant spans\n   *\n   * @param query - The search query\n   * @param topK - Number of results to return (default: config.retrievalTopK)\n   * @returns Promise resolving to array of memory spans\n   *\n   * @example\n   * ```typescript\n   * const spans = await rlm.searchMemory('JavaScript frameworks', 5);\n   * for (const span of spans) {\n   *   console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);\n   * }\n   * ```\n   */\n  async searchMemory(query: string, topK?: number): Promise<MemorySpan[]> {\n    const k = topK ?? this.config.retrievalTopK;\n    const results = this.engine.searchMemory(query, k);\n\n    return results.map((result, index) => ({\n      id: `rlm-span-${result.id}-${index}`,\n      text: result.content,\n      similarityScore: result.score,\n      source: result.metadata?.source as string | undefined,\n      metadata: result.metadata,\n    }));\n  }\n\n  /**\n   * Clear the response cache\n   *\n   * @example\n   * ```typescript\n   * rlm.clearCache();\n   * console.log('Cache cleared');\n   * ```\n   */\n  clearCache(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Get current cache statistics\n   *\n   * @returns Object with cache size and hit rate info\n   */\n  getCacheStats(): { size: number; entries: number } {\n    return {\n      size: this.cache.size,\n      entries: this.cache.size,\n    };\n  }\n\n  /**\n   * Update configuration at runtime\n   *\n   * @param config - Partial configuration to merge\n   */\n  updateConfig(config: Partial<RlmConfig>): void {\n    this.config = { ...this.config, ...config };\n  }\n\n  /**\n   * Get current configuration\n   */\n  getConfig(): Required<RlmConfig> {\n    return { ...this.config };\n  }\n\n  // ============================================\n  // Private Methods\n  // ============================================\n\n  /**\n   * Generate sub-queries for complex questions\n   */\n  private async generateSubQueries(\n    query: string,\n    sources: MemorySpan[],\n    depth: number\n  ): Promise<SubQuery[]> {\n    if (depth >= this.config.maxDepth) {\n      return [];\n    }\n\n    // Simple heuristic: generate sub-queries for questions with multiple parts\n    const subQueries: SubQuery[] = [];\n    const parts = this.decomposeQuery(query);\n\n    for (const part of parts.slice(0, this.config.maxSubQueries)) {\n      if (part.trim().length < 10) continue;\n\n      // Search for sub-query specific sources\n      const subSources = await this.searchMemory(part, Math.ceil(this.config.retrievalTopK / 2));\n      const context = this.buildContext(subSources, []);\n      const response = this.engine.query(\n        this.buildPrompt(part, context),\n        { ...this.getGenerationConfig(), maxTokens: 256 }\n      );\n\n      subQueries.push({\n        query: part,\n        answer: response.text,\n        depth: depth + 1,\n      });\n    }\n\n    return subQueries;\n  }\n\n  /**\n   * Decompose a complex query into simpler parts\n   */\n  private decomposeQuery(query: string): string[] {\n    // Split on common conjunctions and question markers\n    const parts: string[] = [];\n\n    // Check for multi-part questions\n    const conjunctions = [' and ', ' or ', '. ', '? ', '; '];\n    let current = query;\n\n    for (const conj of conjunctions) {\n      if (current.includes(conj)) {\n        const split = current.split(conj);\n        parts.push(...split.filter(p => p.trim().length > 10));\n        current = '';\n        break;\n      }\n    }\n\n    // If no decomposition happened, return original\n    if (parts.length === 0) {\n      return [query];\n    }\n\n    return parts;\n  }\n\n  /**\n   * Build context string from sources and sub-queries\n   */\n  private buildContext(sources: MemorySpan[], subQueries: SubQuery[]): string {\n    const parts: string[] = [];\n\n    // Add sources\n    if (sources.length > 0) {\n      parts.push('Relevant context:');\n      for (const source of sources) {\n        parts.push(`- ${source.text}`);\n      }\n    }\n\n    // Add sub-query answers\n    if (subQueries.length > 0) {\n      parts.push('\\nRelated information:');\n      for (const sq of subQueries) {\n        parts.push(`Q: ${sq.query}`);\n        parts.push(`A: ${sq.answer}`);\n      }\n    }\n\n    return parts.join('\\n');\n  }\n\n  /**\n   * Build the full prompt with context\n   */\n  private buildPrompt(query: string, context: string): string {\n    if (context.trim().length === 0) {\n      return query;\n    }\n\n    return `${context}\\n\\nBased on the above context, answer the following question:\\n${query}`;\n  }\n\n  /**\n   * Get generation config based on RLM settings\n   */\n  private getGenerationConfig(): GenerationConfig {\n    return {\n      maxTokens: Math.min(this.config.tokenBudget, 2048),\n      temperature: 0.7,\n      topP: 0.9,\n    };\n  }\n\n  /**\n   * Estimate token usage\n   */\n  private estimateTokenUsage(query: string, context: string, response: string): TokenUsage {\n    // Rough estimation: ~4 characters per token\n    const promptTokens = Math.ceil((query.length + context.length) / 4);\n    const completionTokens = Math.ceil(response.length / 4);\n\n    return {\n      prompt: promptTokens,\n      completion: completionTokens,\n      total: promptTokens + completionTokens,\n    };\n  }\n\n  /**\n   * Calculate quality score based on sources and confidence\n   */\n  private calculateQualityScore(sources: MemorySpan[], confidence: number): number {\n    if (sources.length === 0) {\n      return confidence * 0.5; // Penalize answers without sources\n    }\n\n    // Average source similarity\n    const avgSimilarity = sources.reduce((sum, s) => sum + s.similarityScore, 0) / sources.length;\n\n    // Weighted combination\n    return confidence * 0.6 + avgSimilarity * 0.4;\n  }\n\n  /**\n   * Apply self-reflection to improve answer\n   */\n  private async applyReflection(\n    query: string,\n    answer: RlmAnswer\n  ): Promise<RlmAnswer> {\n    let currentAnswer = answer;\n    let iterations = 0;\n\n    while (\n      iterations < this.config.maxReflectionIterations &&\n      currentAnswer.qualityScore < this.config.minQualityScore\n    ) {\n      iterations++;\n\n      // Generate critique\n      const critiquePrompt = `Evaluate this answer for accuracy and completeness:\nQuestion: ${query}\nAnswer: ${currentAnswer.text}\n\nProvide a brief critique and suggest improvements.`;\n\n      const critiqueResponse = this.engine.query(critiquePrompt, {\n        maxTokens: 256,\n        temperature: 0.5,\n      });\n\n      // Generate improved answer\n      const improvePrompt = `Based on this feedback: \"${critiqueResponse.text}\"\n\nImprove this answer:\nQuestion: ${query}\nOriginal: ${currentAnswer.text}\n\nProvide an improved answer:`;\n\n      const improvedResponse = this.engine.query(improvePrompt, this.getGenerationConfig());\n\n      // Update answer with reflection improvements\n      const newQualityScore = Math.min(\n        1.0,\n        currentAnswer.qualityScore + 0.1 * iterations\n      );\n\n      currentAnswer = {\n        ...currentAnswer,\n        text: improvedResponse.text,\n        confidence: Math.max(currentAnswer.confidence, improvedResponse.confidence),\n        qualityScore: newQualityScore,\n        tokenUsage: {\n          prompt: currentAnswer.tokenUsage.prompt + 100, // Approximate additional tokens\n          completion: currentAnswer.tokenUsage.completion + 100,\n          total: currentAnswer.tokenUsage.total + 200,\n        },\n      };\n    }\n\n    return currentAnswer;\n  }\n\n  /**\n   * Get cached answer if valid\n   */\n  private getCached(query: string): RlmAnswer | null {\n    const hash = this.hashQuery(query);\n    const entry = this.cache.get(hash);\n\n    if (!entry) {\n      return null;\n    }\n\n    // Check TTL\n    if (Date.now() - entry.timestamp > this.config.cacheTtl) {\n      this.cache.delete(hash);\n      return null;\n    }\n\n    return entry.answer;\n  }\n\n  /**\n   * Set cache entry\n   */\n  private setCache(query: string, answer: RlmAnswer): void {\n    const hash = this.hashQuery(query);\n    this.cache.set(hash, {\n      answer,\n      timestamp: Date.now(),\n      queryHash: hash,\n    });\n\n    // Prune old entries if cache gets too large\n    if (this.cache.size > 1000) {\n      this.pruneCache();\n    }\n  }\n\n  /**\n   * Simple hash function for cache keys\n   */\n  private hashQuery(query: string): string {\n    let hash = 0;\n    for (let i = 0; i < query.length; i++) {\n      const char = query.charCodeAt(i);\n      hash = ((hash << 5) - hash) + char;\n      hash = hash & hash; // Convert to 32-bit integer\n    }\n    return `rlm-cache-${hash.toString(16)}`;\n  }\n\n  /**\n   * Prune expired cache entries\n   */\n  private pruneCache(): void {\n    const now = Date.now();\n    const toDelete: string[] = [];\n\n    for (const [key, entry] of this.cache.entries()) {\n      if (now - entry.timestamp > this.config.cacheTtl) {\n        toDelete.push(key);\n      }\n    }\n\n    // Delete oldest entries if still too large\n    if (this.cache.size - toDelete.length > 800) {\n      const entries = Array.from(this.cache.entries())\n        .sort((a, b) => a[1].timestamp - b[1].timestamp);\n\n      const deleteCount = entries.length - 500;\n      for (let i = 0; i < deleteCount; i++) {\n        toDelete.push(entries[i][0]);\n      }\n    }\n\n    for (const key of toDelete) {\n      this.cache.delete(key);\n    }\n  }\n\n  /**\n   * Utility delay function for streaming simulation\n   */\n  private delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n"]}
-62
dist/cjs/rlm/index.d.ts
/**
* RLM - Retrieval Language Model
*
* A recursive retrieval-augmented generation system that combines
* memory search with intelligent query decomposition and synthesis.
*
* @example Basic Usage
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* maxDepth: 3,
* enableCache: true,
* retrievalTopK: 10,
* });
*
* // Add knowledge
* await rlm.addMemory('TypeScript adds static typing to JavaScript.');
* await rlm.addMemory('React is a library for building user interfaces.');
*
* // Query with retrieval
* const answer = await rlm.query('Compare TypeScript and JavaScript');
* console.log(answer.text);
* console.log('Confidence:', answer.confidence);
* console.log('Sources:', answer.sources.length);
* ```
*
* @example Streaming
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController();
*
* for await (const event of rlm.queryStream('Explain machine learning')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nQuality:', event.answer.qualityScore);
* }
* }
* ```
*
* @example With Reflection
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* enableReflection: true,
* maxReflectionIterations: 2,
* minQualityScore: 0.8,
* });
*
* // Answers will be iteratively refined until quality >= 0.8
* const answer = await rlm.query('Complex technical question...');
* ```
*
* @module rlm
*/
export * from './types';
export { RlmController } from './controller';
export { type DecompositionStrategy, type SubQuery, type QueryDecomposition, type SubAnswer, type RlmTrajectoryMetadata, type RlmTrainingExample, type ContrastivePair, type RlmTrainingConfig, type TrainingResult as RlmTrainingResult, type EvaluationResult as RlmEvaluationResult, DEFAULT_RLM_CONFIG, FAST_RLM_CONFIG, THOROUGH_RLM_CONFIG, ROUTING_FOCUSED_CONFIG, AGENT_DEFINITIONS, HARD_NEGATIVE_PAIRS, RlmTrainer, createRlmTrainer, createEmptyExample, createSubQuery, createSubAnswer, } from './training';
//# sourceMappingURL=index.d.ts.map
-1
dist/cjs/rlm/index.d.ts.map
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rlm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAGH,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,cAAc,IAAI,iBAAiB,EACxC,KAAK,gBAAgB,IAAI,mBAAmB,EAG5C,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EAGnB,UAAU,EAGV,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAC"}
-97
dist/cjs/rlm/index.js
"use strict";
/**
* RLM - Retrieval Language Model
*
* A recursive retrieval-augmented generation system that combines
* memory search with intelligent query decomposition and synthesis.
*
* @example Basic Usage
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* maxDepth: 3,
* enableCache: true,
* retrievalTopK: 10,
* });
*
* // Add knowledge
* await rlm.addMemory('TypeScript adds static typing to JavaScript.');
* await rlm.addMemory('React is a library for building user interfaces.');
*
* // Query with retrieval
* const answer = await rlm.query('Compare TypeScript and JavaScript');
* console.log(answer.text);
* console.log('Confidence:', answer.confidence);
* console.log('Sources:', answer.sources.length);
* ```
*
* @example Streaming
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController();
*
* for await (const event of rlm.queryStream('Explain machine learning')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nQuality:', event.answer.qualityScore);
* }
* }
* ```
*
* @example With Reflection
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* enableReflection: true,
* maxReflectionIterations: 2,
* minQualityScore: 0.8,
* });
*
* // Answers will be iteratively refined until quality >= 0.8
* const answer = await rlm.query('Complex technical question...');
* ```
*
* @module rlm
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __exportStar = (this && this.__exportStar) || function(m, exports) {
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createSubAnswer = exports.createSubQuery = exports.createEmptyExample = exports.createRlmTrainer = exports.RlmTrainer = exports.HARD_NEGATIVE_PAIRS = exports.AGENT_DEFINITIONS = exports.ROUTING_FOCUSED_CONFIG = exports.THOROUGH_RLM_CONFIG = exports.FAST_RLM_CONFIG = exports.DEFAULT_RLM_CONFIG = exports.RlmController = void 0;
// Export all types
__exportStar(require("./types"), exports);
// Export the controller
var controller_1 = require("./controller");
Object.defineProperty(exports, "RlmController", { enumerable: true, get: function () { return controller_1.RlmController; } });
// Export training module
var training_1 = require("./training");
// Constants
Object.defineProperty(exports, "DEFAULT_RLM_CONFIG", { enumerable: true, get: function () { return training_1.DEFAULT_RLM_CONFIG; } });
Object.defineProperty(exports, "FAST_RLM_CONFIG", { enumerable: true, get: function () { return training_1.FAST_RLM_CONFIG; } });
Object.defineProperty(exports, "THOROUGH_RLM_CONFIG", { enumerable: true, get: function () { return training_1.THOROUGH_RLM_CONFIG; } });
Object.defineProperty(exports, "ROUTING_FOCUSED_CONFIG", { enumerable: true, get: function () { return training_1.ROUTING_FOCUSED_CONFIG; } });
Object.defineProperty(exports, "AGENT_DEFINITIONS", { enumerable: true, get: function () { return training_1.AGENT_DEFINITIONS; } });
Object.defineProperty(exports, "HARD_NEGATIVE_PAIRS", { enumerable: true, get: function () { return training_1.HARD_NEGATIVE_PAIRS; } });
// Classes
Object.defineProperty(exports, "RlmTrainer", { enumerable: true, get: function () { return training_1.RlmTrainer; } });
// Factory functions
Object.defineProperty(exports, "createRlmTrainer", { enumerable: true, get: function () { return training_1.createRlmTrainer; } });
Object.defineProperty(exports, "createEmptyExample", { enumerable: true, get: function () { return training_1.createEmptyExample; } });
Object.defineProperty(exports, "createSubQuery", { enumerable: true, get: function () { return training_1.createSubQuery; } });
Object.defineProperty(exports, "createSubAnswer", { enumerable: true, get: function () { return training_1.createSubAnswer; } });
//# sourceMappingURL=data:application/json;base64,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
-333
dist/cjs/rlm/training.d.ts
/**
* RLM (Recursive Learning Machine) Training Module
*
* Provides training capabilities for RuvLTRA models on RLM task routing
* and decomposition, including query decomposition, answer synthesis,
* and agent routing optimization.
*
* @module rlm/training
*/
/**
* Strategy for decomposing a complex query
*/
export type DecompositionStrategy = 'sequential' | 'parallel' | 'hierarchical' | 'dag-based' | 'iterative' | 'none';
/**
* A sub-query in the decomposition
*/
export interface SubQuery {
/** Unique identifier within the decomposition */
id: number;
/** The sub-query text */
query: string;
/** Expected output type (e.g., "code", "analysis", "data") */
expectedType: string;
/** Dependencies (IDs of sub-queries that must complete first) */
dependencies: number[];
/** Recommended agent type for this sub-query */
recommendedAgent?: string;
/** Estimated complexity (0.0-1.0) */
complexity: number;
/** Optional context from parent query */
context?: string;
}
/**
* Decomposition of a complex query into sub-queries
*/
export interface QueryDecomposition {
/** Sub-queries in execution order */
subQueries: SubQuery[];
/** Decomposition strategy used */
strategy: DecompositionStrategy;
/** Reasoning for this decomposition */
rationale: string;
/** Total estimated complexity */
totalComplexity: number;
/** Whether decomposition was successful */
success: boolean;
/** Error message if decomposition failed */
error?: string;
}
/**
* Answer to a sub-query
*/
export interface SubAnswer {
/** ID of the sub-query this answers */
subQueryId: number;
/** The answer content */
content: string;
/** Confidence in this answer (0.0-1.0) */
confidence: number;
/** Agent that produced this answer */
agent: string;
/** Latency in milliseconds */
latencyMs: number;
/** Quality score (0.0-1.0) */
quality: number;
/** Whether this answer was successful */
success: boolean;
/** Error message if failed */
error?: string;
/** Intermediate reasoning/chain-of-thought */
reasoning?: string;
}
/**
* Metadata about the RLM execution trajectory
*/
export interface RlmTrajectoryMetadata {
/** Session ID */
sessionId?: string;
/** User ID */
userId?: string;
/** Total latency in milliseconds */
totalLatencyMs: number;
/** Number of retries */
retries: number;
/** Maximum parallel branches executed */
maxParallelism: number;
/** Models used during execution */
modelsUsed: string[];
/** Agents invoked */
agentsInvoked: string[];
/** Tools used */
toolsUsed: string[];
/** Custom attributes */
attributes: Record<string, string>;
}
/**
* A complete RLM training example
*/
export interface RlmTrainingExample {
/** Unique identifier */
id: string;
/** Original complex query */
query: string;
/** Query embedding (optional) */
queryEmbedding?: number[];
/** How the query was decomposed */
decomposition: QueryDecomposition;
/** Answers to each sub-query */
subAnswers: SubAnswer[];
/** Final synthesized answer */
finalAnswer: string;
/** Final answer embedding (optional) */
finalEmbedding?: number[];
/** Overall quality score (0.0-1.0) */
qualityScore: number;
/** Execution trajectory metadata */
trajectory: RlmTrajectoryMetadata;
/** Whether this example was successful */
success: boolean;
/** Lessons learned from this example */
lessons: string[];
/** Source of this example */
source: string;
}
/**
* A contrastive pair for agent routing training
*/
export interface ContrastivePair {
/** Anchor query */
anchor: string;
/** Anchor embedding (optional) */
anchorEmbedding?: number[];
/** Positive agent (correct routing) */
positiveAgent: string;
/** Negative agent (incorrect routing) */
negativeAgent: string;
/** Whether this is a hard negative */
isHardNegative: boolean;
/** Quality score of the anchor example */
quality: number;
/** Source example ID */
sourceId: string;
}
/**
* Configuration for RLM training
*/
export interface RlmTrainingConfig {
/** Learning rate for decomposition training */
decompositionLr: number;
/** Learning rate for synthesis training */
synthesisLr: number;
/** Learning rate for contrastive fine-tuning */
contrastiveLr: number;
/** Batch size */
batchSize: number;
/** Number of epochs */
epochs: number;
/** Contrastive margin for triplet loss */
contrastiveMargin: number;
/** Temperature for InfoNCE loss */
infonceTemperature: number;
/** Weight for decomposition loss */
decompositionWeight: number;
/** Weight for synthesis loss */
synthesisWeight: number;
/** Weight for routing loss */
routingWeight: number;
/** Minimum quality for updates */
qualityThreshold: number;
/** Evaluation interval (epochs) */
evaluationInterval: number;
/** Warmup steps */
warmupSteps: number;
/** Early stopping patience */
earlyStoppingPatience: number;
/** Validation split ratio */
validationSplit: number;
/** Random seed */
seed: number;
}
/**
* Training result for a phase
*/
export interface TrainingResult {
/** Training phase name */
phase: string;
/** Epochs completed */
epochsCompleted: number;
/** Total steps */
totalSteps: number;
/** Final training loss */
finalLoss: number;
/** Best validation loss */
bestValLoss: number;
/** Best epoch */
bestEpoch: number;
/** Final accuracy (for classification tasks) */
accuracy: number;
/** Loss history per epoch */
lossHistory: number[];
/** Validation loss history */
valLossHistory: number[];
/** Training duration in milliseconds */
durationMs: number;
/** Whether early stopping was triggered */
earlyStopped: boolean;
}
/**
* Evaluation result for the trained model
*/
export interface EvaluationResult {
/** Decomposition accuracy */
decompositionAccuracy: number;
/** Synthesis quality */
synthesisQuality: number;
/** Routing accuracy */
routingAccuracy: number;
/** Hard negative accuracy */
hardNegativeAccuracy: number;
/** Average latency in ms */
avgLatencyMs: number;
/** Total examples evaluated */
totalExamples: number;
/** Per-agent accuracy */
perAgentAccuracy: Record<string, number>;
}
/**
* Default RLM training configuration
*/
export declare const DEFAULT_RLM_CONFIG: RlmTrainingConfig;
/**
* Fast training configuration
*/
export declare const FAST_RLM_CONFIG: RlmTrainingConfig;
/**
* Thorough training configuration
*/
export declare const THOROUGH_RLM_CONFIG: RlmTrainingConfig;
/**
* Routing-focused training configuration
*/
export declare const ROUTING_FOCUSED_CONFIG: RlmTrainingConfig;
/**
* Agent types with descriptions and keywords
*/
export declare const AGENT_DEFINITIONS: Record<string, {
description: string;
keywords: string[];
}>;
/**
* Hard negative pairs (confusable agent combinations)
*/
export declare const HARD_NEGATIVE_PAIRS: [string, string][];
/**
* RLM Trainer for RuvLTRA models
*
* Provides training capabilities for decomposition, synthesis, and routing tasks.
*/
export declare class RlmTrainer {
private config;
private currentEpoch;
private currentStep;
private bestValLoss;
private patienceCounter;
private lossHistory;
private valLossHistory;
/**
* Create a new RLM trainer
*/
constructor(config?: Partial<RlmTrainingConfig>);
/**
* Train on decomposition task
*
* Learns to break complex queries into manageable sub-queries.
*/
trainDecomposition(dataset: RlmTrainingExample[]): Promise<TrainingResult>;
/**
* Train on synthesis task
*
* Learns to combine sub-answers into coherent final responses.
*/
trainSynthesis(dataset: RlmTrainingExample[]): Promise<TrainingResult>;
/**
* Contrastive fine-tuning for agent routing
*
* Uses triplet loss and InfoNCE to improve routing accuracy.
*/
trainContrastive(pairs: ContrastivePair[]): Promise<TrainingResult>;
/**
* Evaluate trained model on test set
*/
evaluate(testSet: RlmTrainingExample[]): Promise<EvaluationResult>;
/**
* Generate contrastive pairs from dataset
*/
generateContrastivePairs(dataset: RlmTrainingExample[], hardNegativeRatio?: number): ContrastivePair[];
private resetState;
private splitDataset;
private splitPairs;
private createBatches;
private createPairBatches;
private shuffle;
private trainDecompositionBatch;
private trainSynthesisBatch;
private trainContrastiveBatch;
private validateDecomposition;
private validateSynthesis;
private validateContrastive;
private computeTripletLoss;
private computeInfoNCELoss;
private agentDistance;
private predictAgent;
private isHardNegative;
private findBestEpoch;
}
/**
* Create an RLM trainer with default configuration
*/
export declare function createRlmTrainer(config?: Partial<RlmTrainingConfig>): RlmTrainer;
/**
* Create an empty RLM training example
*/
export declare function createEmptyExample(query: string): RlmTrainingExample;
/**
* Create a sub-query
*/
export declare function createSubQuery(id: number, query: string, options?: Partial<SubQuery>): SubQuery;
/**
* Create a sub-answer
*/
export declare function createSubAnswer(subQueryId: number, content: string, agent: string, options?: Partial<SubAnswer>): SubAnswer;
export default RlmTrainer;
//# sourceMappingURL=training.d.ts.map
-1
dist/cjs/rlm/training.d.ts.map
{"version":3,"file":"training.d.ts","sourceRoot":"","sources":["../../../src/rlm/training.ts"],"names":[],"mappings":"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"}
dist/cjs/rlm/training.js

Sorry, the diff of this file is too big to display

-189
dist/cjs/rlm/types.d.ts
/**
* RLM (Retrieval Language Model) Type Definitions
*
* Types for the recursive retrieval-augmented generation system
* that breaks down complex queries into sub-queries and synthesizes
* answers from retrieved memory spans.
*/
/**
* Configuration for the RLM controller
*
* @example
* ```typescript
* const config: RlmConfig = {
* maxDepth: 3,
* maxSubQueries: 5,
* tokenBudget: 4096,
* enableCache: true,
* cacheTtl: 300000, // 5 minutes
* retrievalTopK: 10,
* minQualityScore: 0.7,
* enableReflection: true,
* maxReflectionIterations: 2,
* };
* ```
*/
export interface RlmConfig {
/** Maximum recursion depth for sub-queries (default: 3) */
maxDepth?: number;
/** Maximum number of sub-queries per level (default: 5) */
maxSubQueries?: number;
/** Token budget for generation (default: 4096) */
tokenBudget?: number;
/** Enable response caching (default: true) */
enableCache?: boolean;
/** Cache TTL in milliseconds (default: 300000 = 5 minutes) */
cacheTtl?: number;
/** Number of memory spans to retrieve (default: 10) */
retrievalTopK?: number;
/** Minimum quality score to accept answer (default: 0.7) */
minQualityScore?: number;
/** Enable self-reflection loop (default: false) */
enableReflection?: boolean;
/** Maximum reflection iterations (default: 2) */
maxReflectionIterations?: number;
}
/**
* Answer produced by the RLM controller
*
* @example
* ```typescript
* const answer: RlmAnswer = {
* text: 'Machine learning is a subset of artificial intelligence...',
* confidence: 0.92,
* qualityScore: 0.88,
* sources: [
* { id: 'mem-1', text: 'ML definition from textbook', similarityScore: 0.95, metadata: {} },
* ],
* subQueries: [
* { query: 'What is artificial intelligence?', answer: 'AI is...', depth: 1 },
* ],
* tokenUsage: { prompt: 512, completion: 256, total: 768 },
* cached: false,
* };
* ```
*/
export interface RlmAnswer {
/** The generated answer text */
text: string;
/** Overall confidence in the answer (0.0 - 1.0) */
confidence: number;
/** Quality score based on source coverage and coherence (0.0 - 1.0) */
qualityScore: number;
/** Memory spans used to generate the answer */
sources: MemorySpan[];
/** Sub-queries generated and answered (if recursive) */
subQueries?: SubQuery[];
/** Token usage statistics */
tokenUsage: TokenUsage;
/** Whether this answer was served from cache */
cached: boolean;
}
/**
* A span of memory retrieved for context
*
* @example
* ```typescript
* const span: MemorySpan = {
* id: 'mem-abc123',
* text: 'Relevant context from memory...',
* similarityScore: 0.89,
* source: 'documentation',
* metadata: { timestamp: Date.now(), category: 'technical' },
* };
* ```
*/
export interface MemorySpan {
/** Unique identifier for the memory span */
id: string;
/** The text content of the memory span */
text: string;
/** Cosine similarity score to the query (0.0 - 1.0) */
similarityScore: number;
/** Optional source identifier (e.g., document name, URL) */
source?: string;
/** Additional metadata associated with this span */
metadata: Record<string, unknown>;
}
/**
* A sub-query generated during recursive retrieval
*/
export interface SubQuery {
/** The generated sub-query text */
query: string;
/** The answer to the sub-query */
answer: string;
/** Recursion depth at which this sub-query was generated */
depth: number;
}
/**
* Token usage statistics for a query
*/
export interface TokenUsage {
/** Tokens used in the prompt (including context) */
prompt: number;
/** Tokens generated in the completion */
completion: number;
/** Total tokens used (prompt + completion) */
total: number;
}
/**
* Streaming token event
*
* Discriminated union for streaming responses:
* - `type: 'token'` - A partial token was generated
* - `type: 'done'` - Generation complete with final answer
*
* @example
* ```typescript
* for await (const event of controller.queryStream('What is AI?')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nFinal answer:', event.answer.text);
* }
* }
* ```
*/
export type StreamToken = {
/** Token event type */
type: 'token';
/** The partial text token */
text: string;
/** Always false for token events */
done: false;
} | {
/** Done event type */
type: 'done';
/** The complete answer */
answer: RlmAnswer;
/** Always true for done events */
done: true;
};
/**
* Internal cache entry for RLM answers
*/
export interface RlmCacheEntry {
/** The cached answer */
answer: RlmAnswer;
/** Timestamp when the entry was cached */
timestamp: number;
/** Query hash for cache key */
queryHash: string;
}
/**
* Reflection result from self-evaluation loop
*/
export interface ReflectionResult {
/** Whether the answer passed reflection criteria */
passed: boolean;
/** Critique of the current answer */
critique?: string;
/** Suggested improvements */
suggestions?: string[];
/** Updated quality score after reflection */
updatedScore: number;
/** Number of reflection iterations performed */
iterations: number;
}
//# sourceMappingURL=types.d.ts.map
-1
dist/cjs/rlm/types.d.ts.map
{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/rlm/types.ts"],"names":[],"mappings":"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"}
-10
dist/cjs/rlm/types.js
"use strict";
/**
* RLM (Retrieval Language Model) Type Definitions
*
* Types for the recursive retrieval-augmented generation system
* that breaks down complex queries into sub-queries and synthesizes
* answers from retrieved memory spans.
*/
Object.defineProperty(exports, "__esModule", { value: true });
//# sourceMappingURL=data:application/json;base64,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
-245
dist/esm/rlm/controller.d.ts
/**
* RLM Controller - Recursive Retrieval Language Model
*
* Implements a recursive retrieval-augmented generation system that:
* 1. Breaks down complex queries into sub-queries
* 2. Retrieves relevant memory spans for each query
* 3. Synthesizes coherent answers from retrieved context
* 4. Optionally reflects on and refines answers
*
* @example Basic Usage
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* maxDepth: 3,
* retrievalTopK: 10,
* enableCache: true,
* });
*
* // Add knowledge to memory
* await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');
* await rlm.addMemory('Deep learning uses neural networks with many layers.');
*
* // Query with recursive retrieval
* const answer = await rlm.query('Explain the relationship between ML and deep learning');
* console.log(answer.text);
* console.log('Sources:', answer.sources.length);
* console.log('Confidence:', answer.confidence);
* ```
*
* @example Streaming
* ```typescript
* const rlm = new RlmController();
*
* for await (const event of rlm.queryStream('What is AI?')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nDone! Quality:', event.answer.qualityScore);
* }
* }
* ```
*
* @example With Reflection
* ```typescript
* const rlm = new RlmController({
* enableReflection: true,
* maxReflectionIterations: 2,
* minQualityScore: 0.8,
* });
*
* const answer = await rlm.query('Complex multi-part question...');
* // Answer will be iteratively refined until quality >= 0.8
* ```
*/
import { RlmConfig, RlmAnswer, MemorySpan, StreamToken } from './types';
import { RuvLLM } from '../engine';
/**
* RlmController - Recursive Retrieval Language Model Controller
*
* Orchestrates retrieval-augmented generation with recursive sub-query
* decomposition, memory search, and optional self-reflection.
*/
export declare class RlmController {
private config;
private cache;
private engine;
private memoryIdCounter;
/**
* Create a new RLM controller
*
* @param config - Configuration options
* @param engine - Optional RuvLLM engine instance (creates new if not provided)
*
* @example
* ```typescript
* // With default config
* const rlm = new RlmController();
*
* // With custom config
* const rlm = new RlmController({
* maxDepth: 5,
* enableReflection: true,
* });
*
* // With existing engine
* const engine = new RuvLLM({ learningEnabled: true });
* const rlm = new RlmController({}, engine);
* ```
*/
constructor(config?: RlmConfig, engine?: RuvLLM);
/**
* Query the RLM with recursive retrieval
*
* @param input - The query string
* @returns Promise resolving to the answer with sources and metadata
*
* @example
* ```typescript
* const answer = await rlm.query('What is the capital of France?');
* console.log(answer.text); // "The capital of France is Paris..."
* console.log(answer.confidence); // 0.95
* console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]
* ```
*/
query(input: string): Promise<RlmAnswer>;
/**
* Query with streaming response
*
* @param input - The query string
* @yields StreamToken events (either partial tokens or final answer)
*
* @example
* ```typescript
* for await (const event of rlm.queryStream('Explain quantum computing')) {
* if (event.type === 'token') {
* // Partial token received
* process.stdout.write(event.text);
* } else {
* // Generation complete
* console.log('\n\nSources:', event.answer.sources.length);
* }
* }
* ```
*/
queryStream(input: string): AsyncGenerator<StreamToken>;
/**
* Add content to memory for retrieval
*
* @param text - The text content to store
* @param metadata - Optional metadata to associate with the memory
* @returns Promise resolving to the memory span ID
*
* @example
* ```typescript
* const id1 = await rlm.addMemory(
* 'TypeScript is a typed superset of JavaScript.',
* { source: 'documentation', category: 'programming' }
* );
*
* const id2 = await rlm.addMemory(
* 'React is a JavaScript library for building UIs.'
* );
* ```
*/
addMemory(text: string, metadata?: Record<string, unknown>): Promise<string>;
/**
* Search memory for relevant spans
*
* @param query - The search query
* @param topK - Number of results to return (default: config.retrievalTopK)
* @returns Promise resolving to array of memory spans
*
* @example
* ```typescript
* const spans = await rlm.searchMemory('JavaScript frameworks', 5);
* for (const span of spans) {
* console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);
* }
* ```
*/
searchMemory(query: string, topK?: number): Promise<MemorySpan[]>;
/**
* Clear the response cache
*
* @example
* ```typescript
* rlm.clearCache();
* console.log('Cache cleared');
* ```
*/
clearCache(): void;
/**
* Get current cache statistics
*
* @returns Object with cache size and hit rate info
*/
getCacheStats(): {
size: number;
entries: number;
};
/**
* Update configuration at runtime
*
* @param config - Partial configuration to merge
*/
updateConfig(config: Partial<RlmConfig>): void;
/**
* Get current configuration
*/
getConfig(): Required<RlmConfig>;
/**
* Generate sub-queries for complex questions
*/
private generateSubQueries;
/**
* Decompose a complex query into simpler parts
*/
private decomposeQuery;
/**
* Build context string from sources and sub-queries
*/
private buildContext;
/**
* Build the full prompt with context
*/
private buildPrompt;
/**
* Get generation config based on RLM settings
*/
private getGenerationConfig;
/**
* Estimate token usage
*/
private estimateTokenUsage;
/**
* Calculate quality score based on sources and confidence
*/
private calculateQualityScore;
/**
* Apply self-reflection to improve answer
*/
private applyReflection;
/**
* Get cached answer if valid
*/
private getCached;
/**
* Set cache entry
*/
private setCache;
/**
* Simple hash function for cache keys
*/
private hashQuery;
/**
* Prune expired cache entries
*/
private pruneCache;
/**
* Utility delay function for streaming simulation
*/
private delay;
}
//# sourceMappingURL=controller.d.ts.map
-1
dist/esm/rlm/controller.d.ts.map
{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/rlm/controller.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AAEH,OAAO,EACL,SAAS,EACT,SAAS,EACT,UAAU,EAGV,WAAW,EAGZ,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAkBnC;;;;;GAKG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,KAAK,CAA6B;IAC1C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,eAAe,CAAS;IAEhC;;;;;;;;;;;;;;;;;;;;;OAqBG;gBACS,MAAM,CAAC,EAAE,SAAS,EAAE,MAAM,CAAC,EAAE,MAAM;IAO/C;;;;;;;;;;;;;OAaG;IACG,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,CAAC;IAsD9C;;;;;;;;;;;;;;;;;;OAkBG;IACI,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAAC,WAAW,CAAC;IA2D9D;;;;;;;;;;;;;;;;;;OAkBG;IACG,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAMlF;;;;;;;;;;;;;;OAcG;IACG,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC;IAavE;;;;;;;;OAQG;IACH,UAAU,IAAI,IAAI;IAIlB;;;;OAIG;IACH,aAAa,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE;IAOlD;;;;OAIG;IACH,YAAY,CAAC,MAAM,EAAE,OAAO,CAAC,SAAS,CAAC,GAAG,IAAI;IAI9C;;OAEG;IACH,SAAS,IAAI,QAAQ,CAAC,SAAS,CAAC;IAQhC;;OAEG;YACW,kBAAkB;IAkChC;;OAEG;IACH,OAAO,CAAC,cAAc;IAyBtB;;OAEG;IACH,OAAO,CAAC,YAAY;IAuBpB;;OAEG;IACH,OAAO,CAAC,WAAW;IAQnB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAQ3B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAY1B;;OAEG;IACH,OAAO,CAAC,qBAAqB;IAY7B;;OAEG;YACW,eAAe;IA0D7B;;OAEG;IACH,OAAO,CAAC,SAAS;IAiBjB;;OAEG;IACH,OAAO,CAAC,QAAQ;IAchB;;OAEG;IACH,OAAO,CAAC,SAAS;IAUjB;;OAEG;IACH,OAAO,CAAC,UAAU;IA0BlB;;OAEG;IACH,OAAO,CAAC,KAAK;CAGd"}
-550
dist/esm/rlm/controller.js
/**
* RLM Controller - Recursive Retrieval Language Model
*
* Implements a recursive retrieval-augmented generation system that:
* 1. Breaks down complex queries into sub-queries
* 2. Retrieves relevant memory spans for each query
* 3. Synthesizes coherent answers from retrieved context
* 4. Optionally reflects on and refines answers
*
* @example Basic Usage
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* maxDepth: 3,
* retrievalTopK: 10,
* enableCache: true,
* });
*
* // Add knowledge to memory
* await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');
* await rlm.addMemory('Deep learning uses neural networks with many layers.');
*
* // Query with recursive retrieval
* const answer = await rlm.query('Explain the relationship between ML and deep learning');
* console.log(answer.text);
* console.log('Sources:', answer.sources.length);
* console.log('Confidence:', answer.confidence);
* ```
*
* @example Streaming
* ```typescript
* const rlm = new RlmController();
*
* for await (const event of rlm.queryStream('What is AI?')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nDone! Quality:', event.answer.qualityScore);
* }
* }
* ```
*
* @example With Reflection
* ```typescript
* const rlm = new RlmController({
* enableReflection: true,
* maxReflectionIterations: 2,
* minQualityScore: 0.8,
* });
*
* const answer = await rlm.query('Complex multi-part question...');
* // Answer will be iteratively refined until quality >= 0.8
* ```
*/
import { RuvLLM } from '../engine';
/**
* Default configuration values
*/
const DEFAULT_CONFIG = {
maxDepth: 3,
maxSubQueries: 5,
tokenBudget: 4096,
enableCache: true,
cacheTtl: 300000, // 5 minutes
retrievalTopK: 10,
minQualityScore: 0.7,
enableReflection: false,
maxReflectionIterations: 2,
};
/**
* RlmController - Recursive Retrieval Language Model Controller
*
* Orchestrates retrieval-augmented generation with recursive sub-query
* decomposition, memory search, and optional self-reflection.
*/
export class RlmController {
/**
* Create a new RLM controller
*
* @param config - Configuration options
* @param engine - Optional RuvLLM engine instance (creates new if not provided)
*
* @example
* ```typescript
* // With default config
* const rlm = new RlmController();
*
* // With custom config
* const rlm = new RlmController({
* maxDepth: 5,
* enableReflection: true,
* });
*
* // With existing engine
* const engine = new RuvLLM({ learningEnabled: true });
* const rlm = new RlmController({}, engine);
* ```
*/
constructor(config, engine) {
this.config = { ...DEFAULT_CONFIG, ...config };
this.cache = new Map();
this.engine = engine ?? new RuvLLM({ learningEnabled: true });
this.memoryIdCounter = 0;
}
/**
* Query the RLM with recursive retrieval
*
* @param input - The query string
* @returns Promise resolving to the answer with sources and metadata
*
* @example
* ```typescript
* const answer = await rlm.query('What is the capital of France?');
* console.log(answer.text); // "The capital of France is Paris..."
* console.log(answer.confidence); // 0.95
* console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]
* ```
*/
async query(input) {
// Check cache first
if (this.config.enableCache) {
const cached = this.getCached(input);
if (cached) {
return { ...cached, cached: true };
}
}
// Retrieve relevant memory spans
const sources = await this.searchMemory(input, this.config.retrievalTopK);
// Generate sub-queries if needed and depth allows
const subQueries = await this.generateSubQueries(input, sources, 0);
// Build context from sources and sub-query answers
const context = this.buildContext(sources, subQueries);
// Generate the answer
const startTime = Date.now();
const response = this.engine.query(this.buildPrompt(input, context), this.getGenerationConfig());
// Calculate token usage (estimate if not provided by engine)
const tokenUsage = this.estimateTokenUsage(input, context, response.text);
// Calculate quality score
const qualityScore = this.calculateQualityScore(sources, response.confidence);
let answer = {
text: response.text,
confidence: response.confidence,
qualityScore,
sources,
subQueries: subQueries.length > 0 ? subQueries : undefined,
tokenUsage,
cached: false,
};
// Apply reflection if enabled and quality is below threshold
if (this.config.enableReflection && qualityScore < this.config.minQualityScore) {
answer = await this.applyReflection(input, answer);
}
// Cache the result
if (this.config.enableCache) {
this.setCache(input, answer);
}
return answer;
}
/**
* Query with streaming response
*
* @param input - The query string
* @yields StreamToken events (either partial tokens or final answer)
*
* @example
* ```typescript
* for await (const event of rlm.queryStream('Explain quantum computing')) {
* if (event.type === 'token') {
* // Partial token received
* process.stdout.write(event.text);
* } else {
* // Generation complete
* console.log('\n\nSources:', event.answer.sources.length);
* }
* }
* ```
*/
async *queryStream(input) {
// Check cache first
if (this.config.enableCache) {
const cached = this.getCached(input);
if (cached) {
// Simulate streaming for cached response
const words = cached.text.split(' ');
for (const word of words) {
yield { type: 'token', text: word + ' ', done: false };
await this.delay(10); // Small delay for realistic streaming
}
yield { type: 'done', answer: { ...cached, cached: true }, done: true };
return;
}
}
// Retrieve sources
const sources = await this.searchMemory(input, this.config.retrievalTopK);
const subQueries = await this.generateSubQueries(input, sources, 0);
const context = this.buildContext(sources, subQueries);
// Generate with simulated streaming
const prompt = this.buildPrompt(input, context);
const response = this.engine.query(prompt, this.getGenerationConfig());
// Stream the response word by word
const words = response.text.split(' ');
let streamedText = '';
for (let i = 0; i < words.length; i++) {
const word = words[i];
const text = i < words.length - 1 ? word + ' ' : word;
streamedText += text;
yield { type: 'token', text, done: false };
await this.delay(20); // Simulate generation latency
}
const tokenUsage = this.estimateTokenUsage(input, context, streamedText);
const qualityScore = this.calculateQualityScore(sources, response.confidence);
const answer = {
text: streamedText,
confidence: response.confidence,
qualityScore,
sources,
subQueries: subQueries.length > 0 ? subQueries : undefined,
tokenUsage,
cached: false,
};
// Cache the result
if (this.config.enableCache) {
this.setCache(input, answer);
}
yield { type: 'done', answer, done: true };
}
/**
* Add content to memory for retrieval
*
* @param text - The text content to store
* @param metadata - Optional metadata to associate with the memory
* @returns Promise resolving to the memory span ID
*
* @example
* ```typescript
* const id1 = await rlm.addMemory(
* 'TypeScript is a typed superset of JavaScript.',
* { source: 'documentation', category: 'programming' }
* );
*
* const id2 = await rlm.addMemory(
* 'React is a JavaScript library for building UIs.'
* );
* ```
*/
async addMemory(text, metadata) {
const nodeId = this.engine.addMemory(text, metadata);
const id = `rlm-mem-${this.memoryIdCounter++}-${nodeId}`;
return id;
}
/**
* Search memory for relevant spans
*
* @param query - The search query
* @param topK - Number of results to return (default: config.retrievalTopK)
* @returns Promise resolving to array of memory spans
*
* @example
* ```typescript
* const spans = await rlm.searchMemory('JavaScript frameworks', 5);
* for (const span of spans) {
* console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);
* }
* ```
*/
async searchMemory(query, topK) {
const k = topK ?? this.config.retrievalTopK;
const results = this.engine.searchMemory(query, k);
return results.map((result, index) => ({
id: `rlm-span-${result.id}-${index}`,
text: result.content,
similarityScore: result.score,
source: result.metadata?.source,
metadata: result.metadata,
}));
}
/**
* Clear the response cache
*
* @example
* ```typescript
* rlm.clearCache();
* console.log('Cache cleared');
* ```
*/
clearCache() {
this.cache.clear();
}
/**
* Get current cache statistics
*
* @returns Object with cache size and hit rate info
*/
getCacheStats() {
return {
size: this.cache.size,
entries: this.cache.size,
};
}
/**
* Update configuration at runtime
*
* @param config - Partial configuration to merge
*/
updateConfig(config) {
this.config = { ...this.config, ...config };
}
/**
* Get current configuration
*/
getConfig() {
return { ...this.config };
}
// ============================================
// Private Methods
// ============================================
/**
* Generate sub-queries for complex questions
*/
async generateSubQueries(query, sources, depth) {
if (depth >= this.config.maxDepth) {
return [];
}
// Simple heuristic: generate sub-queries for questions with multiple parts
const subQueries = [];
const parts = this.decomposeQuery(query);
for (const part of parts.slice(0, this.config.maxSubQueries)) {
if (part.trim().length < 10)
continue;
// Search for sub-query specific sources
const subSources = await this.searchMemory(part, Math.ceil(this.config.retrievalTopK / 2));
const context = this.buildContext(subSources, []);
const response = this.engine.query(this.buildPrompt(part, context), { ...this.getGenerationConfig(), maxTokens: 256 });
subQueries.push({
query: part,
answer: response.text,
depth: depth + 1,
});
}
return subQueries;
}
/**
* Decompose a complex query into simpler parts
*/
decomposeQuery(query) {
// Split on common conjunctions and question markers
const parts = [];
// Check for multi-part questions
const conjunctions = [' and ', ' or ', '. ', '? ', '; '];
let current = query;
for (const conj of conjunctions) {
if (current.includes(conj)) {
const split = current.split(conj);
parts.push(...split.filter(p => p.trim().length > 10));
current = '';
break;
}
}
// If no decomposition happened, return original
if (parts.length === 0) {
return [query];
}
return parts;
}
/**
* Build context string from sources and sub-queries
*/
buildContext(sources, subQueries) {
const parts = [];
// Add sources
if (sources.length > 0) {
parts.push('Relevant context:');
for (const source of sources) {
parts.push(`- ${source.text}`);
}
}
// Add sub-query answers
if (subQueries.length > 0) {
parts.push('\nRelated information:');
for (const sq of subQueries) {
parts.push(`Q: ${sq.query}`);
parts.push(`A: ${sq.answer}`);
}
}
return parts.join('\n');
}
/**
* Build the full prompt with context
*/
buildPrompt(query, context) {
if (context.trim().length === 0) {
return query;
}
return `${context}\n\nBased on the above context, answer the following question:\n${query}`;
}
/**
* Get generation config based on RLM settings
*/
getGenerationConfig() {
return {
maxTokens: Math.min(this.config.tokenBudget, 2048),
temperature: 0.7,
topP: 0.9,
};
}
/**
* Estimate token usage
*/
estimateTokenUsage(query, context, response) {
// Rough estimation: ~4 characters per token
const promptTokens = Math.ceil((query.length + context.length) / 4);
const completionTokens = Math.ceil(response.length / 4);
return {
prompt: promptTokens,
completion: completionTokens,
total: promptTokens + completionTokens,
};
}
/**
* Calculate quality score based on sources and confidence
*/
calculateQualityScore(sources, confidence) {
if (sources.length === 0) {
return confidence * 0.5; // Penalize answers without sources
}
// Average source similarity
const avgSimilarity = sources.reduce((sum, s) => sum + s.similarityScore, 0) / sources.length;
// Weighted combination
return confidence * 0.6 + avgSimilarity * 0.4;
}
/**
* Apply self-reflection to improve answer
*/
async applyReflection(query, answer) {
let currentAnswer = answer;
let iterations = 0;
while (iterations < this.config.maxReflectionIterations &&
currentAnswer.qualityScore < this.config.minQualityScore) {
iterations++;
// Generate critique
const critiquePrompt = `Evaluate this answer for accuracy and completeness:
Question: ${query}
Answer: ${currentAnswer.text}
Provide a brief critique and suggest improvements.`;
const critiqueResponse = this.engine.query(critiquePrompt, {
maxTokens: 256,
temperature: 0.5,
});
// Generate improved answer
const improvePrompt = `Based on this feedback: "${critiqueResponse.text}"
Improve this answer:
Question: ${query}
Original: ${currentAnswer.text}
Provide an improved answer:`;
const improvedResponse = this.engine.query(improvePrompt, this.getGenerationConfig());
// Update answer with reflection improvements
const newQualityScore = Math.min(1.0, currentAnswer.qualityScore + 0.1 * iterations);
currentAnswer = {
...currentAnswer,
text: improvedResponse.text,
confidence: Math.max(currentAnswer.confidence, improvedResponse.confidence),
qualityScore: newQualityScore,
tokenUsage: {
prompt: currentAnswer.tokenUsage.prompt + 100, // Approximate additional tokens
completion: currentAnswer.tokenUsage.completion + 100,
total: currentAnswer.tokenUsage.total + 200,
},
};
}
return currentAnswer;
}
/**
* Get cached answer if valid
*/
getCached(query) {
const hash = this.hashQuery(query);
const entry = this.cache.get(hash);
if (!entry) {
return null;
}
// Check TTL
if (Date.now() - entry.timestamp > this.config.cacheTtl) {
this.cache.delete(hash);
return null;
}
return entry.answer;
}
/**
* Set cache entry
*/
setCache(query, answer) {
const hash = this.hashQuery(query);
this.cache.set(hash, {
answer,
timestamp: Date.now(),
queryHash: hash,
});
// Prune old entries if cache gets too large
if (this.cache.size > 1000) {
this.pruneCache();
}
}
/**
* Simple hash function for cache keys
*/
hashQuery(query) {
let hash = 0;
for (let i = 0; i < query.length; i++) {
const char = query.charCodeAt(i);
hash = ((hash << 5) - hash) + char;
hash = hash & hash; // Convert to 32-bit integer
}
return `rlm-cache-${hash.toString(16)}`;
}
/**
* Prune expired cache entries
*/
pruneCache() {
const now = Date.now();
const toDelete = [];
for (const [key, entry] of this.cache.entries()) {
if (now - entry.timestamp > this.config.cacheTtl) {
toDelete.push(key);
}
}
// Delete oldest entries if still too large
if (this.cache.size - toDelete.length > 800) {
const entries = Array.from(this.cache.entries())
.sort((a, b) => a[1].timestamp - b[1].timestamp);
const deleteCount = entries.length - 500;
for (let i = 0; i < deleteCount; i++) {
toDelete.push(entries[i][0]);
}
}
for (const key of toDelete) {
this.cache.delete(key);
}
}
/**
* Utility delay function for streaming simulation
*/
delay(ms) {
return new Promise(resolve => setTimeout(resolve, ms));
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"controller.js","sourceRoot":"","sources":["../../../src/rlm/controller.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RLM Controller - Recursive Retrieval Language Model\n *\n * Implements a recursive retrieval-augmented generation system that:\n * 1. Breaks down complex queries into sub-queries\n * 2. Retrieves relevant memory spans for each query\n * 3. Synthesizes coherent answers from retrieved context\n * 4. Optionally reflects on and refines answers\n *\n * @example Basic Usage\n * ```typescript\n * import { RlmController } from '@ruvector/ruvllm';\n *\n * const rlm = new RlmController({\n *   maxDepth: 3,\n *   retrievalTopK: 10,\n *   enableCache: true,\n * });\n *\n * // Add knowledge to memory\n * await rlm.addMemory('Machine learning is a subset of AI that enables systems to learn from data.');\n * await rlm.addMemory('Deep learning uses neural networks with many layers.');\n *\n * // Query with recursive retrieval\n * const answer = await rlm.query('Explain the relationship between ML and deep learning');\n * console.log(answer.text);\n * console.log('Sources:', answer.sources.length);\n * console.log('Confidence:', answer.confidence);\n * ```\n *\n * @example Streaming\n * ```typescript\n * const rlm = new RlmController();\n *\n * for await (const event of rlm.queryStream('What is AI?')) {\n *   if (event.type === 'token') {\n *     process.stdout.write(event.text);\n *   } else {\n *     console.log('\\n\\nDone! Quality:', event.answer.qualityScore);\n *   }\n * }\n * ```\n *\n * @example With Reflection\n * ```typescript\n * const rlm = new RlmController({\n *   enableReflection: true,\n *   maxReflectionIterations: 2,\n *   minQualityScore: 0.8,\n * });\n *\n * const answer = await rlm.query('Complex multi-part question...');\n * // Answer will be iteratively refined until quality >= 0.8\n * ```\n */\n\nimport {\n  RlmConfig,\n  RlmAnswer,\n  MemorySpan,\n  SubQuery,\n  TokenUsage,\n  StreamToken,\n  RlmCacheEntry,\n  ReflectionResult,\n} from './types';\n\nimport { RuvLLM } from '../engine';\nimport type { GenerationConfig, QueryResponse } from '../types';\n\n/**\n * Default configuration values\n */\nconst DEFAULT_CONFIG: Required<RlmConfig> = {\n  maxDepth: 3,\n  maxSubQueries: 5,\n  tokenBudget: 4096,\n  enableCache: true,\n  cacheTtl: 300000, // 5 minutes\n  retrievalTopK: 10,\n  minQualityScore: 0.7,\n  enableReflection: false,\n  maxReflectionIterations: 2,\n};\n\n/**\n * RlmController - Recursive Retrieval Language Model Controller\n *\n * Orchestrates retrieval-augmented generation with recursive sub-query\n * decomposition, memory search, and optional self-reflection.\n */\nexport class RlmController {\n  private config: Required<RlmConfig>;\n  private cache: Map<string, RlmCacheEntry>;\n  private engine: RuvLLM;\n  private memoryIdCounter: number;\n\n  /**\n   * Create a new RLM controller\n   *\n   * @param config - Configuration options\n   * @param engine - Optional RuvLLM engine instance (creates new if not provided)\n   *\n   * @example\n   * ```typescript\n   * // With default config\n   * const rlm = new RlmController();\n   *\n   * // With custom config\n   * const rlm = new RlmController({\n   *   maxDepth: 5,\n   *   enableReflection: true,\n   * });\n   *\n   * // With existing engine\n   * const engine = new RuvLLM({ learningEnabled: true });\n   * const rlm = new RlmController({}, engine);\n   * ```\n   */\n  constructor(config?: RlmConfig, engine?: RuvLLM) {\n    this.config = { ...DEFAULT_CONFIG, ...config };\n    this.cache = new Map();\n    this.engine = engine ?? new RuvLLM({ learningEnabled: true });\n    this.memoryIdCounter = 0;\n  }\n\n  /**\n   * Query the RLM with recursive retrieval\n   *\n   * @param input - The query string\n   * @returns Promise resolving to the answer with sources and metadata\n   *\n   * @example\n   * ```typescript\n   * const answer = await rlm.query('What is the capital of France?');\n   * console.log(answer.text); // \"The capital of France is Paris...\"\n   * console.log(answer.confidence); // 0.95\n   * console.log(answer.sources); // [{ id: '...', text: '...', similarityScore: 0.92 }]\n   * ```\n   */\n  async query(input: string): Promise<RlmAnswer> {\n    // Check cache first\n    if (this.config.enableCache) {\n      const cached = this.getCached(input);\n      if (cached) {\n        return { ...cached, cached: true };\n      }\n    }\n\n    // Retrieve relevant memory spans\n    const sources = await this.searchMemory(input, this.config.retrievalTopK);\n\n    // Generate sub-queries if needed and depth allows\n    const subQueries = await this.generateSubQueries(input, sources, 0);\n\n    // Build context from sources and sub-query answers\n    const context = this.buildContext(sources, subQueries);\n\n    // Generate the answer\n    const startTime = Date.now();\n    const response = this.engine.query(\n      this.buildPrompt(input, context),\n      this.getGenerationConfig()\n    );\n\n    // Calculate token usage (estimate if not provided by engine)\n    const tokenUsage = this.estimateTokenUsage(input, context, response.text);\n\n    // Calculate quality score\n    const qualityScore = this.calculateQualityScore(sources, response.confidence);\n\n    let answer: RlmAnswer = {\n      text: response.text,\n      confidence: response.confidence,\n      qualityScore,\n      sources,\n      subQueries: subQueries.length > 0 ? subQueries : undefined,\n      tokenUsage,\n      cached: false,\n    };\n\n    // Apply reflection if enabled and quality is below threshold\n    if (this.config.enableReflection && qualityScore < this.config.minQualityScore) {\n      answer = await this.applyReflection(input, answer);\n    }\n\n    // Cache the result\n    if (this.config.enableCache) {\n      this.setCache(input, answer);\n    }\n\n    return answer;\n  }\n\n  /**\n   * Query with streaming response\n   *\n   * @param input - The query string\n   * @yields StreamToken events (either partial tokens or final answer)\n   *\n   * @example\n   * ```typescript\n   * for await (const event of rlm.queryStream('Explain quantum computing')) {\n   *   if (event.type === 'token') {\n   *     // Partial token received\n   *     process.stdout.write(event.text);\n   *   } else {\n   *     // Generation complete\n   *     console.log('\\n\\nSources:', event.answer.sources.length);\n   *   }\n   * }\n   * ```\n   */\n  async *queryStream(input: string): AsyncGenerator<StreamToken> {\n    // Check cache first\n    if (this.config.enableCache) {\n      const cached = this.getCached(input);\n      if (cached) {\n        // Simulate streaming for cached response\n        const words = cached.text.split(' ');\n        for (const word of words) {\n          yield { type: 'token', text: word + ' ', done: false };\n          await this.delay(10); // Small delay for realistic streaming\n        }\n        yield { type: 'done', answer: { ...cached, cached: true }, done: true };\n        return;\n      }\n    }\n\n    // Retrieve sources\n    const sources = await this.searchMemory(input, this.config.retrievalTopK);\n    const subQueries = await this.generateSubQueries(input, sources, 0);\n    const context = this.buildContext(sources, subQueries);\n\n    // Generate with simulated streaming\n    const prompt = this.buildPrompt(input, context);\n    const response = this.engine.query(prompt, this.getGenerationConfig());\n\n    // Stream the response word by word\n    const words = response.text.split(' ');\n    let streamedText = '';\n\n    for (let i = 0; i < words.length; i++) {\n      const word = words[i];\n      const text = i < words.length - 1 ? word + ' ' : word;\n      streamedText += text;\n\n      yield { type: 'token', text, done: false };\n      await this.delay(20); // Simulate generation latency\n    }\n\n    const tokenUsage = this.estimateTokenUsage(input, context, streamedText);\n    const qualityScore = this.calculateQualityScore(sources, response.confidence);\n\n    const answer: RlmAnswer = {\n      text: streamedText,\n      confidence: response.confidence,\n      qualityScore,\n      sources,\n      subQueries: subQueries.length > 0 ? subQueries : undefined,\n      tokenUsage,\n      cached: false,\n    };\n\n    // Cache the result\n    if (this.config.enableCache) {\n      this.setCache(input, answer);\n    }\n\n    yield { type: 'done', answer, done: true };\n  }\n\n  /**\n   * Add content to memory for retrieval\n   *\n   * @param text - The text content to store\n   * @param metadata - Optional metadata to associate with the memory\n   * @returns Promise resolving to the memory span ID\n   *\n   * @example\n   * ```typescript\n   * const id1 = await rlm.addMemory(\n   *   'TypeScript is a typed superset of JavaScript.',\n   *   { source: 'documentation', category: 'programming' }\n   * );\n   *\n   * const id2 = await rlm.addMemory(\n   *   'React is a JavaScript library for building UIs.'\n   * );\n   * ```\n   */\n  async addMemory(text: string, metadata?: Record<string, unknown>): Promise<string> {\n    const nodeId = this.engine.addMemory(text, metadata);\n    const id = `rlm-mem-${this.memoryIdCounter++}-${nodeId}`;\n    return id;\n  }\n\n  /**\n   * Search memory for relevant spans\n   *\n   * @param query - The search query\n   * @param topK - Number of results to return (default: config.retrievalTopK)\n   * @returns Promise resolving to array of memory spans\n   *\n   * @example\n   * ```typescript\n   * const spans = await rlm.searchMemory('JavaScript frameworks', 5);\n   * for (const span of spans) {\n   *   console.log(`[${span.similarityScore.toFixed(2)}] ${span.text}`);\n   * }\n   * ```\n   */\n  async searchMemory(query: string, topK?: number): Promise<MemorySpan[]> {\n    const k = topK ?? this.config.retrievalTopK;\n    const results = this.engine.searchMemory(query, k);\n\n    return results.map((result, index) => ({\n      id: `rlm-span-${result.id}-${index}`,\n      text: result.content,\n      similarityScore: result.score,\n      source: result.metadata?.source as string | undefined,\n      metadata: result.metadata,\n    }));\n  }\n\n  /**\n   * Clear the response cache\n   *\n   * @example\n   * ```typescript\n   * rlm.clearCache();\n   * console.log('Cache cleared');\n   * ```\n   */\n  clearCache(): void {\n    this.cache.clear();\n  }\n\n  /**\n   * Get current cache statistics\n   *\n   * @returns Object with cache size and hit rate info\n   */\n  getCacheStats(): { size: number; entries: number } {\n    return {\n      size: this.cache.size,\n      entries: this.cache.size,\n    };\n  }\n\n  /**\n   * Update configuration at runtime\n   *\n   * @param config - Partial configuration to merge\n   */\n  updateConfig(config: Partial<RlmConfig>): void {\n    this.config = { ...this.config, ...config };\n  }\n\n  /**\n   * Get current configuration\n   */\n  getConfig(): Required<RlmConfig> {\n    return { ...this.config };\n  }\n\n  // ============================================\n  // Private Methods\n  // ============================================\n\n  /**\n   * Generate sub-queries for complex questions\n   */\n  private async generateSubQueries(\n    query: string,\n    sources: MemorySpan[],\n    depth: number\n  ): Promise<SubQuery[]> {\n    if (depth >= this.config.maxDepth) {\n      return [];\n    }\n\n    // Simple heuristic: generate sub-queries for questions with multiple parts\n    const subQueries: SubQuery[] = [];\n    const parts = this.decomposeQuery(query);\n\n    for (const part of parts.slice(0, this.config.maxSubQueries)) {\n      if (part.trim().length < 10) continue;\n\n      // Search for sub-query specific sources\n      const subSources = await this.searchMemory(part, Math.ceil(this.config.retrievalTopK / 2));\n      const context = this.buildContext(subSources, []);\n      const response = this.engine.query(\n        this.buildPrompt(part, context),\n        { ...this.getGenerationConfig(), maxTokens: 256 }\n      );\n\n      subQueries.push({\n        query: part,\n        answer: response.text,\n        depth: depth + 1,\n      });\n    }\n\n    return subQueries;\n  }\n\n  /**\n   * Decompose a complex query into simpler parts\n   */\n  private decomposeQuery(query: string): string[] {\n    // Split on common conjunctions and question markers\n    const parts: string[] = [];\n\n    // Check for multi-part questions\n    const conjunctions = [' and ', ' or ', '. ', '? ', '; '];\n    let current = query;\n\n    for (const conj of conjunctions) {\n      if (current.includes(conj)) {\n        const split = current.split(conj);\n        parts.push(...split.filter(p => p.trim().length > 10));\n        current = '';\n        break;\n      }\n    }\n\n    // If no decomposition happened, return original\n    if (parts.length === 0) {\n      return [query];\n    }\n\n    return parts;\n  }\n\n  /**\n   * Build context string from sources and sub-queries\n   */\n  private buildContext(sources: MemorySpan[], subQueries: SubQuery[]): string {\n    const parts: string[] = [];\n\n    // Add sources\n    if (sources.length > 0) {\n      parts.push('Relevant context:');\n      for (const source of sources) {\n        parts.push(`- ${source.text}`);\n      }\n    }\n\n    // Add sub-query answers\n    if (subQueries.length > 0) {\n      parts.push('\\nRelated information:');\n      for (const sq of subQueries) {\n        parts.push(`Q: ${sq.query}`);\n        parts.push(`A: ${sq.answer}`);\n      }\n    }\n\n    return parts.join('\\n');\n  }\n\n  /**\n   * Build the full prompt with context\n   */\n  private buildPrompt(query: string, context: string): string {\n    if (context.trim().length === 0) {\n      return query;\n    }\n\n    return `${context}\\n\\nBased on the above context, answer the following question:\\n${query}`;\n  }\n\n  /**\n   * Get generation config based on RLM settings\n   */\n  private getGenerationConfig(): GenerationConfig {\n    return {\n      maxTokens: Math.min(this.config.tokenBudget, 2048),\n      temperature: 0.7,\n      topP: 0.9,\n    };\n  }\n\n  /**\n   * Estimate token usage\n   */\n  private estimateTokenUsage(query: string, context: string, response: string): TokenUsage {\n    // Rough estimation: ~4 characters per token\n    const promptTokens = Math.ceil((query.length + context.length) / 4);\n    const completionTokens = Math.ceil(response.length / 4);\n\n    return {\n      prompt: promptTokens,\n      completion: completionTokens,\n      total: promptTokens + completionTokens,\n    };\n  }\n\n  /**\n   * Calculate quality score based on sources and confidence\n   */\n  private calculateQualityScore(sources: MemorySpan[], confidence: number): number {\n    if (sources.length === 0) {\n      return confidence * 0.5; // Penalize answers without sources\n    }\n\n    // Average source similarity\n    const avgSimilarity = sources.reduce((sum, s) => sum + s.similarityScore, 0) / sources.length;\n\n    // Weighted combination\n    return confidence * 0.6 + avgSimilarity * 0.4;\n  }\n\n  /**\n   * Apply self-reflection to improve answer\n   */\n  private async applyReflection(\n    query: string,\n    answer: RlmAnswer\n  ): Promise<RlmAnswer> {\n    let currentAnswer = answer;\n    let iterations = 0;\n\n    while (\n      iterations < this.config.maxReflectionIterations &&\n      currentAnswer.qualityScore < this.config.minQualityScore\n    ) {\n      iterations++;\n\n      // Generate critique\n      const critiquePrompt = `Evaluate this answer for accuracy and completeness:\nQuestion: ${query}\nAnswer: ${currentAnswer.text}\n\nProvide a brief critique and suggest improvements.`;\n\n      const critiqueResponse = this.engine.query(critiquePrompt, {\n        maxTokens: 256,\n        temperature: 0.5,\n      });\n\n      // Generate improved answer\n      const improvePrompt = `Based on this feedback: \"${critiqueResponse.text}\"\n\nImprove this answer:\nQuestion: ${query}\nOriginal: ${currentAnswer.text}\n\nProvide an improved answer:`;\n\n      const improvedResponse = this.engine.query(improvePrompt, this.getGenerationConfig());\n\n      // Update answer with reflection improvements\n      const newQualityScore = Math.min(\n        1.0,\n        currentAnswer.qualityScore + 0.1 * iterations\n      );\n\n      currentAnswer = {\n        ...currentAnswer,\n        text: improvedResponse.text,\n        confidence: Math.max(currentAnswer.confidence, improvedResponse.confidence),\n        qualityScore: newQualityScore,\n        tokenUsage: {\n          prompt: currentAnswer.tokenUsage.prompt + 100, // Approximate additional tokens\n          completion: currentAnswer.tokenUsage.completion + 100,\n          total: currentAnswer.tokenUsage.total + 200,\n        },\n      };\n    }\n\n    return currentAnswer;\n  }\n\n  /**\n   * Get cached answer if valid\n   */\n  private getCached(query: string): RlmAnswer | null {\n    const hash = this.hashQuery(query);\n    const entry = this.cache.get(hash);\n\n    if (!entry) {\n      return null;\n    }\n\n    // Check TTL\n    if (Date.now() - entry.timestamp > this.config.cacheTtl) {\n      this.cache.delete(hash);\n      return null;\n    }\n\n    return entry.answer;\n  }\n\n  /**\n   * Set cache entry\n   */\n  private setCache(query: string, answer: RlmAnswer): void {\n    const hash = this.hashQuery(query);\n    this.cache.set(hash, {\n      answer,\n      timestamp: Date.now(),\n      queryHash: hash,\n    });\n\n    // Prune old entries if cache gets too large\n    if (this.cache.size > 1000) {\n      this.pruneCache();\n    }\n  }\n\n  /**\n   * Simple hash function for cache keys\n   */\n  private hashQuery(query: string): string {\n    let hash = 0;\n    for (let i = 0; i < query.length; i++) {\n      const char = query.charCodeAt(i);\n      hash = ((hash << 5) - hash) + char;\n      hash = hash & hash; // Convert to 32-bit integer\n    }\n    return `rlm-cache-${hash.toString(16)}`;\n  }\n\n  /**\n   * Prune expired cache entries\n   */\n  private pruneCache(): void {\n    const now = Date.now();\n    const toDelete: string[] = [];\n\n    for (const [key, entry] of this.cache.entries()) {\n      if (now - entry.timestamp > this.config.cacheTtl) {\n        toDelete.push(key);\n      }\n    }\n\n    // Delete oldest entries if still too large\n    if (this.cache.size - toDelete.length > 800) {\n      const entries = Array.from(this.cache.entries())\n        .sort((a, b) => a[1].timestamp - b[1].timestamp);\n\n      const deleteCount = entries.length - 500;\n      for (let i = 0; i < deleteCount; i++) {\n        toDelete.push(entries[i][0]);\n      }\n    }\n\n    for (const key of toDelete) {\n      this.cache.delete(key);\n    }\n  }\n\n  /**\n   * Utility delay function for streaming simulation\n   */\n  private delay(ms: number): Promise<void> {\n    return new Promise(resolve => setTimeout(resolve, ms));\n  }\n}\n"]}
-62
dist/esm/rlm/index.d.ts
/**
* RLM - Retrieval Language Model
*
* A recursive retrieval-augmented generation system that combines
* memory search with intelligent query decomposition and synthesis.
*
* @example Basic Usage
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* maxDepth: 3,
* enableCache: true,
* retrievalTopK: 10,
* });
*
* // Add knowledge
* await rlm.addMemory('TypeScript adds static typing to JavaScript.');
* await rlm.addMemory('React is a library for building user interfaces.');
*
* // Query with retrieval
* const answer = await rlm.query('Compare TypeScript and JavaScript');
* console.log(answer.text);
* console.log('Confidence:', answer.confidence);
* console.log('Sources:', answer.sources.length);
* ```
*
* @example Streaming
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController();
*
* for await (const event of rlm.queryStream('Explain machine learning')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nQuality:', event.answer.qualityScore);
* }
* }
* ```
*
* @example With Reflection
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* enableReflection: true,
* maxReflectionIterations: 2,
* minQualityScore: 0.8,
* });
*
* // Answers will be iteratively refined until quality >= 0.8
* const answer = await rlm.query('Complex technical question...');
* ```
*
* @module rlm
*/
export * from './types';
export { RlmController } from './controller';
export { type DecompositionStrategy, type SubQuery, type QueryDecomposition, type SubAnswer, type RlmTrajectoryMetadata, type RlmTrainingExample, type ContrastivePair, type RlmTrainingConfig, type TrainingResult as RlmTrainingResult, type EvaluationResult as RlmEvaluationResult, DEFAULT_RLM_CONFIG, FAST_RLM_CONFIG, THOROUGH_RLM_CONFIG, ROUTING_FOCUSED_CONFIG, AGENT_DEFINITIONS, HARD_NEGATIVE_PAIRS, RlmTrainer, createRlmTrainer, createEmptyExample, createSubQuery, createSubAnswer, } from './training';
//# sourceMappingURL=index.d.ts.map
-1
dist/esm/rlm/index.d.ts.map
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/rlm/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AAGH,cAAc,SAAS,CAAC;AAGxB,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAG7C,OAAO,EAEL,KAAK,qBAAqB,EAC1B,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACvB,KAAK,SAAS,EACd,KAAK,qBAAqB,EAC1B,KAAK,kBAAkB,EACvB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,cAAc,IAAI,iBAAiB,EACxC,KAAK,gBAAgB,IAAI,mBAAmB,EAG5C,kBAAkB,EAClB,eAAe,EACf,mBAAmB,EACnB,sBAAsB,EACtB,iBAAiB,EACjB,mBAAmB,EAGnB,UAAU,EAGV,gBAAgB,EAChB,kBAAkB,EAClB,cAAc,EACd,eAAe,GAChB,MAAM,YAAY,CAAC"}
-71
dist/esm/rlm/index.js
/**
* RLM - Retrieval Language Model
*
* A recursive retrieval-augmented generation system that combines
* memory search with intelligent query decomposition and synthesis.
*
* @example Basic Usage
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* maxDepth: 3,
* enableCache: true,
* retrievalTopK: 10,
* });
*
* // Add knowledge
* await rlm.addMemory('TypeScript adds static typing to JavaScript.');
* await rlm.addMemory('React is a library for building user interfaces.');
*
* // Query with retrieval
* const answer = await rlm.query('Compare TypeScript and JavaScript');
* console.log(answer.text);
* console.log('Confidence:', answer.confidence);
* console.log('Sources:', answer.sources.length);
* ```
*
* @example Streaming
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController();
*
* for await (const event of rlm.queryStream('Explain machine learning')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nQuality:', event.answer.qualityScore);
* }
* }
* ```
*
* @example With Reflection
* ```typescript
* import { RlmController } from '@ruvector/ruvllm';
*
* const rlm = new RlmController({
* enableReflection: true,
* maxReflectionIterations: 2,
* minQualityScore: 0.8,
* });
*
* // Answers will be iteratively refined until quality >= 0.8
* const answer = await rlm.query('Complex technical question...');
* ```
*
* @module rlm
*/
// Export all types
export * from './types';
// Export the controller
export { RlmController } from './controller';
// Export training module
export {
// Constants
DEFAULT_RLM_CONFIG, FAST_RLM_CONFIG, THOROUGH_RLM_CONFIG, ROUTING_FOCUSED_CONFIG, AGENT_DEFINITIONS, HARD_NEGATIVE_PAIRS,
// Classes
RlmTrainer,
// Factory functions
createRlmTrainer, createEmptyExample, createSubQuery, createSubAnswer, } from './training';
//# sourceMappingURL=data:application/json;base64,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
-333
dist/esm/rlm/training.d.ts
/**
* RLM (Recursive Learning Machine) Training Module
*
* Provides training capabilities for RuvLTRA models on RLM task routing
* and decomposition, including query decomposition, answer synthesis,
* and agent routing optimization.
*
* @module rlm/training
*/
/**
* Strategy for decomposing a complex query
*/
export type DecompositionStrategy = 'sequential' | 'parallel' | 'hierarchical' | 'dag-based' | 'iterative' | 'none';
/**
* A sub-query in the decomposition
*/
export interface SubQuery {
/** Unique identifier within the decomposition */
id: number;
/** The sub-query text */
query: string;
/** Expected output type (e.g., "code", "analysis", "data") */
expectedType: string;
/** Dependencies (IDs of sub-queries that must complete first) */
dependencies: number[];
/** Recommended agent type for this sub-query */
recommendedAgent?: string;
/** Estimated complexity (0.0-1.0) */
complexity: number;
/** Optional context from parent query */
context?: string;
}
/**
* Decomposition of a complex query into sub-queries
*/
export interface QueryDecomposition {
/** Sub-queries in execution order */
subQueries: SubQuery[];
/** Decomposition strategy used */
strategy: DecompositionStrategy;
/** Reasoning for this decomposition */
rationale: string;
/** Total estimated complexity */
totalComplexity: number;
/** Whether decomposition was successful */
success: boolean;
/** Error message if decomposition failed */
error?: string;
}
/**
* Answer to a sub-query
*/
export interface SubAnswer {
/** ID of the sub-query this answers */
subQueryId: number;
/** The answer content */
content: string;
/** Confidence in this answer (0.0-1.0) */
confidence: number;
/** Agent that produced this answer */
agent: string;
/** Latency in milliseconds */
latencyMs: number;
/** Quality score (0.0-1.0) */
quality: number;
/** Whether this answer was successful */
success: boolean;
/** Error message if failed */
error?: string;
/** Intermediate reasoning/chain-of-thought */
reasoning?: string;
}
/**
* Metadata about the RLM execution trajectory
*/
export interface RlmTrajectoryMetadata {
/** Session ID */
sessionId?: string;
/** User ID */
userId?: string;
/** Total latency in milliseconds */
totalLatencyMs: number;
/** Number of retries */
retries: number;
/** Maximum parallel branches executed */
maxParallelism: number;
/** Models used during execution */
modelsUsed: string[];
/** Agents invoked */
agentsInvoked: string[];
/** Tools used */
toolsUsed: string[];
/** Custom attributes */
attributes: Record<string, string>;
}
/**
* A complete RLM training example
*/
export interface RlmTrainingExample {
/** Unique identifier */
id: string;
/** Original complex query */
query: string;
/** Query embedding (optional) */
queryEmbedding?: number[];
/** How the query was decomposed */
decomposition: QueryDecomposition;
/** Answers to each sub-query */
subAnswers: SubAnswer[];
/** Final synthesized answer */
finalAnswer: string;
/** Final answer embedding (optional) */
finalEmbedding?: number[];
/** Overall quality score (0.0-1.0) */
qualityScore: number;
/** Execution trajectory metadata */
trajectory: RlmTrajectoryMetadata;
/** Whether this example was successful */
success: boolean;
/** Lessons learned from this example */
lessons: string[];
/** Source of this example */
source: string;
}
/**
* A contrastive pair for agent routing training
*/
export interface ContrastivePair {
/** Anchor query */
anchor: string;
/** Anchor embedding (optional) */
anchorEmbedding?: number[];
/** Positive agent (correct routing) */
positiveAgent: string;
/** Negative agent (incorrect routing) */
negativeAgent: string;
/** Whether this is a hard negative */
isHardNegative: boolean;
/** Quality score of the anchor example */
quality: number;
/** Source example ID */
sourceId: string;
}
/**
* Configuration for RLM training
*/
export interface RlmTrainingConfig {
/** Learning rate for decomposition training */
decompositionLr: number;
/** Learning rate for synthesis training */
synthesisLr: number;
/** Learning rate for contrastive fine-tuning */
contrastiveLr: number;
/** Batch size */
batchSize: number;
/** Number of epochs */
epochs: number;
/** Contrastive margin for triplet loss */
contrastiveMargin: number;
/** Temperature for InfoNCE loss */
infonceTemperature: number;
/** Weight for decomposition loss */
decompositionWeight: number;
/** Weight for synthesis loss */
synthesisWeight: number;
/** Weight for routing loss */
routingWeight: number;
/** Minimum quality for updates */
qualityThreshold: number;
/** Evaluation interval (epochs) */
evaluationInterval: number;
/** Warmup steps */
warmupSteps: number;
/** Early stopping patience */
earlyStoppingPatience: number;
/** Validation split ratio */
validationSplit: number;
/** Random seed */
seed: number;
}
/**
* Training result for a phase
*/
export interface TrainingResult {
/** Training phase name */
phase: string;
/** Epochs completed */
epochsCompleted: number;
/** Total steps */
totalSteps: number;
/** Final training loss */
finalLoss: number;
/** Best validation loss */
bestValLoss: number;
/** Best epoch */
bestEpoch: number;
/** Final accuracy (for classification tasks) */
accuracy: number;
/** Loss history per epoch */
lossHistory: number[];
/** Validation loss history */
valLossHistory: number[];
/** Training duration in milliseconds */
durationMs: number;
/** Whether early stopping was triggered */
earlyStopped: boolean;
}
/**
* Evaluation result for the trained model
*/
export interface EvaluationResult {
/** Decomposition accuracy */
decompositionAccuracy: number;
/** Synthesis quality */
synthesisQuality: number;
/** Routing accuracy */
routingAccuracy: number;
/** Hard negative accuracy */
hardNegativeAccuracy: number;
/** Average latency in ms */
avgLatencyMs: number;
/** Total examples evaluated */
totalExamples: number;
/** Per-agent accuracy */
perAgentAccuracy: Record<string, number>;
}
/**
* Default RLM training configuration
*/
export declare const DEFAULT_RLM_CONFIG: RlmTrainingConfig;
/**
* Fast training configuration
*/
export declare const FAST_RLM_CONFIG: RlmTrainingConfig;
/**
* Thorough training configuration
*/
export declare const THOROUGH_RLM_CONFIG: RlmTrainingConfig;
/**
* Routing-focused training configuration
*/
export declare const ROUTING_FOCUSED_CONFIG: RlmTrainingConfig;
/**
* Agent types with descriptions and keywords
*/
export declare const AGENT_DEFINITIONS: Record<string, {
description: string;
keywords: string[];
}>;
/**
* Hard negative pairs (confusable agent combinations)
*/
export declare const HARD_NEGATIVE_PAIRS: [string, string][];
/**
* RLM Trainer for RuvLTRA models
*
* Provides training capabilities for decomposition, synthesis, and routing tasks.
*/
export declare class RlmTrainer {
private config;
private currentEpoch;
private currentStep;
private bestValLoss;
private patienceCounter;
private lossHistory;
private valLossHistory;
/**
* Create a new RLM trainer
*/
constructor(config?: Partial<RlmTrainingConfig>);
/**
* Train on decomposition task
*
* Learns to break complex queries into manageable sub-queries.
*/
trainDecomposition(dataset: RlmTrainingExample[]): Promise<TrainingResult>;
/**
* Train on synthesis task
*
* Learns to combine sub-answers into coherent final responses.
*/
trainSynthesis(dataset: RlmTrainingExample[]): Promise<TrainingResult>;
/**
* Contrastive fine-tuning for agent routing
*
* Uses triplet loss and InfoNCE to improve routing accuracy.
*/
trainContrastive(pairs: ContrastivePair[]): Promise<TrainingResult>;
/**
* Evaluate trained model on test set
*/
evaluate(testSet: RlmTrainingExample[]): Promise<EvaluationResult>;
/**
* Generate contrastive pairs from dataset
*/
generateContrastivePairs(dataset: RlmTrainingExample[], hardNegativeRatio?: number): ContrastivePair[];
private resetState;
private splitDataset;
private splitPairs;
private createBatches;
private createPairBatches;
private shuffle;
private trainDecompositionBatch;
private trainSynthesisBatch;
private trainContrastiveBatch;
private validateDecomposition;
private validateSynthesis;
private validateContrastive;
private computeTripletLoss;
private computeInfoNCELoss;
private agentDistance;
private predictAgent;
private isHardNegative;
private findBestEpoch;
}
/**
* Create an RLM trainer with default configuration
*/
export declare function createRlmTrainer(config?: Partial<RlmTrainingConfig>): RlmTrainer;
/**
* Create an empty RLM training example
*/
export declare function createEmptyExample(query: string): RlmTrainingExample;
/**
* Create a sub-query
*/
export declare function createSubQuery(id: number, query: string, options?: Partial<SubQuery>): SubQuery;
/**
* Create a sub-answer
*/
export declare function createSubAnswer(subQueryId: number, content: string, agent: string, options?: Partial<SubAnswer>): SubAnswer;
export default RlmTrainer;
//# sourceMappingURL=training.d.ts.map
-1
dist/esm/rlm/training.d.ts.map
{"version":3,"file":"training.d.ts","sourceRoot":"","sources":["../../../src/rlm/training.ts"],"names":[],"mappings":"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"}
dist/esm/rlm/training.js

Sorry, the diff of this file is too big to display

-189
dist/esm/rlm/types.d.ts
/**
* RLM (Retrieval Language Model) Type Definitions
*
* Types for the recursive retrieval-augmented generation system
* that breaks down complex queries into sub-queries and synthesizes
* answers from retrieved memory spans.
*/
/**
* Configuration for the RLM controller
*
* @example
* ```typescript
* const config: RlmConfig = {
* maxDepth: 3,
* maxSubQueries: 5,
* tokenBudget: 4096,
* enableCache: true,
* cacheTtl: 300000, // 5 minutes
* retrievalTopK: 10,
* minQualityScore: 0.7,
* enableReflection: true,
* maxReflectionIterations: 2,
* };
* ```
*/
export interface RlmConfig {
/** Maximum recursion depth for sub-queries (default: 3) */
maxDepth?: number;
/** Maximum number of sub-queries per level (default: 5) */
maxSubQueries?: number;
/** Token budget for generation (default: 4096) */
tokenBudget?: number;
/** Enable response caching (default: true) */
enableCache?: boolean;
/** Cache TTL in milliseconds (default: 300000 = 5 minutes) */
cacheTtl?: number;
/** Number of memory spans to retrieve (default: 10) */
retrievalTopK?: number;
/** Minimum quality score to accept answer (default: 0.7) */
minQualityScore?: number;
/** Enable self-reflection loop (default: false) */
enableReflection?: boolean;
/** Maximum reflection iterations (default: 2) */
maxReflectionIterations?: number;
}
/**
* Answer produced by the RLM controller
*
* @example
* ```typescript
* const answer: RlmAnswer = {
* text: 'Machine learning is a subset of artificial intelligence...',
* confidence: 0.92,
* qualityScore: 0.88,
* sources: [
* { id: 'mem-1', text: 'ML definition from textbook', similarityScore: 0.95, metadata: {} },
* ],
* subQueries: [
* { query: 'What is artificial intelligence?', answer: 'AI is...', depth: 1 },
* ],
* tokenUsage: { prompt: 512, completion: 256, total: 768 },
* cached: false,
* };
* ```
*/
export interface RlmAnswer {
/** The generated answer text */
text: string;
/** Overall confidence in the answer (0.0 - 1.0) */
confidence: number;
/** Quality score based on source coverage and coherence (0.0 - 1.0) */
qualityScore: number;
/** Memory spans used to generate the answer */
sources: MemorySpan[];
/** Sub-queries generated and answered (if recursive) */
subQueries?: SubQuery[];
/** Token usage statistics */
tokenUsage: TokenUsage;
/** Whether this answer was served from cache */
cached: boolean;
}
/**
* A span of memory retrieved for context
*
* @example
* ```typescript
* const span: MemorySpan = {
* id: 'mem-abc123',
* text: 'Relevant context from memory...',
* similarityScore: 0.89,
* source: 'documentation',
* metadata: { timestamp: Date.now(), category: 'technical' },
* };
* ```
*/
export interface MemorySpan {
/** Unique identifier for the memory span */
id: string;
/** The text content of the memory span */
text: string;
/** Cosine similarity score to the query (0.0 - 1.0) */
similarityScore: number;
/** Optional source identifier (e.g., document name, URL) */
source?: string;
/** Additional metadata associated with this span */
metadata: Record<string, unknown>;
}
/**
* A sub-query generated during recursive retrieval
*/
export interface SubQuery {
/** The generated sub-query text */
query: string;
/** The answer to the sub-query */
answer: string;
/** Recursion depth at which this sub-query was generated */
depth: number;
}
/**
* Token usage statistics for a query
*/
export interface TokenUsage {
/** Tokens used in the prompt (including context) */
prompt: number;
/** Tokens generated in the completion */
completion: number;
/** Total tokens used (prompt + completion) */
total: number;
}
/**
* Streaming token event
*
* Discriminated union for streaming responses:
* - `type: 'token'` - A partial token was generated
* - `type: 'done'` - Generation complete with final answer
*
* @example
* ```typescript
* for await (const event of controller.queryStream('What is AI?')) {
* if (event.type === 'token') {
* process.stdout.write(event.text);
* } else {
* console.log('\n\nFinal answer:', event.answer.text);
* }
* }
* ```
*/
export type StreamToken = {
/** Token event type */
type: 'token';
/** The partial text token */
text: string;
/** Always false for token events */
done: false;
} | {
/** Done event type */
type: 'done';
/** The complete answer */
answer: RlmAnswer;
/** Always true for done events */
done: true;
};
/**
* Internal cache entry for RLM answers
*/
export interface RlmCacheEntry {
/** The cached answer */
answer: RlmAnswer;
/** Timestamp when the entry was cached */
timestamp: number;
/** Query hash for cache key */
queryHash: string;
}
/**
* Reflection result from self-evaluation loop
*/
export interface ReflectionResult {
/** Whether the answer passed reflection criteria */
passed: boolean;
/** Critique of the current answer */
critique?: string;
/** Suggested improvements */
suggestions?: string[];
/** Updated quality score after reflection */
updatedScore: number;
/** Number of reflection iterations performed */
iterations: number;
}
//# sourceMappingURL=types.d.ts.map
-1
dist/esm/rlm/types.d.ts.map
{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/rlm/types.ts"],"names":[],"mappings":"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"}
-9
dist/esm/rlm/types.js
/**
* RLM (Retrieval Language Model) Type Definitions
*
* Types for the recursive retrieval-augmented generation system
* that breaks down complex queries into sub-queries and synthesizes
* answers from retrieved memory spans.
*/
export {};
//# sourceMappingURL=data:application/json;base64,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
-671
scripts/training/rlm-dataset.js
#!/usr/bin/env node
/**
* RLM Training Dataset Generator
*
* Generates synthetic RLM training examples for task decomposition,
* answer synthesis, and agent routing. Integrates with ReasoningBank
* patterns for realistic training data.
*
* Usage:
* node rlm-dataset.js [--output <file>] [--count <n>] [--quality <min>]
*
* Example:
* node rlm-dataset.js --output rlm-training.json --count 1000 --quality 0.7
*/
const fs = require('fs');
const path = require('path');
const crypto = require('crypto');
// Import routing dataset for agent definitions
const { AGENT_TRAINING_DATA, getDatasetStats } = require('./routing-dataset');
// =============================================================================
// Configuration
// =============================================================================
const DEFAULT_CONFIG = {
outputFile: 'rlm-training-dataset.json',
exampleCount: 500,
minQuality: 0.6,
hardNegativeRatio: 0.3,
maxDecompositionDepth: 5,
embeddingDim: 768,
seed: 42,
};
// =============================================================================
// Decomposition Strategy Definitions
// =============================================================================
const DECOMPOSITION_STRATEGIES = {
sequential: {
name: 'sequential',
description: 'Steps executed in order, each depending on the previous',
complexityWeight: 1.5,
},
parallel: {
name: 'parallel',
description: 'Independent sub-queries that can run concurrently',
complexityWeight: 1.5,
},
hierarchical: {
name: 'hierarchical',
description: 'Tree structure with parent-child dependencies',
complexityWeight: 2.0,
},
'dag-based': {
name: 'dag-based',
description: 'Complex DAG with arbitrary dependencies',
complexityWeight: 3.0,
},
iterative: {
name: 'iterative',
description: 'Query -> result -> refined query cycles',
complexityWeight: 2.5,
},
none: {
name: 'none',
description: 'Simple query needing no decomposition',
complexityWeight: 1.0,
},
};
// =============================================================================
// Complex Query Templates
// =============================================================================
const COMPLEX_QUERY_TEMPLATES = [
// Multi-step development tasks
{
template: 'Build a {feature} for the {system} that includes {requirement1} and {requirement2}',
decomposition: ['research', 'design', 'implement', 'test', 'document'],
strategy: 'sequential',
agents: ['researcher', 'architect', 'coder', 'tester', 'documenter'],
quality: 0.9,
},
{
template: 'Refactor the {component} to use {pattern} while maintaining backward compatibility',
decomposition: ['analyze', 'design_refactor', 'implement_changes', 'write_tests', 'review'],
strategy: 'sequential',
agents: ['researcher', 'architect', 'coder', 'tester', 'reviewer'],
quality: 0.85,
},
{
template: 'Add {feature} support to the application with proper error handling and logging',
decomposition: ['requirements', 'implementation', 'error_handling', 'logging', 'testing'],
strategy: 'parallel',
agents: ['researcher', 'coder', 'coder', 'coder', 'tester'],
quality: 0.88,
},
{
template: 'Investigate and fix the performance issue in {component} causing {symptom}',
decomposition: ['investigate', 'identify_cause', 'design_fix', 'implement_fix', 'verify'],
strategy: 'sequential',
agents: ['researcher', 'debugger', 'architect', 'coder', 'tester'],
quality: 0.82,
},
{
template: 'Create a comprehensive API for {domain} with authentication, rate limiting, and documentation',
decomposition: ['design_api', 'implement_endpoints', 'add_auth', 'add_rate_limiting', 'write_docs'],
strategy: 'hierarchical',
agents: ['architect', 'coder', 'security-architect', 'coder', 'api-docs'],
quality: 0.9,
},
{
template: 'Migrate the {system} from {old_tech} to {new_tech} with minimal downtime',
decomposition: ['plan_migration', 'prepare_infrastructure', 'migrate_data', 'switch_traffic', 'cleanup'],
strategy: 'sequential',
agents: ['planner', 'devops', 'coder', 'devops', 'devops'],
quality: 0.87,
},
{
template: 'Implement a {algorithm} for {use_case} optimized for {constraint}',
decomposition: ['research_approaches', 'design_algorithm', 'implement', 'optimize', 'benchmark'],
strategy: 'sequential',
agents: ['researcher', 'architect', 'coder', 'optimizer', 'tester'],
quality: 0.85,
},
{
template: 'Set up CI/CD pipeline for {project} with automated testing, security scanning, and deployment',
decomposition: ['design_pipeline', 'setup_tests', 'add_security', 'configure_deployment', 'document'],
strategy: 'dag-based',
agents: ['devops', 'tester', 'security-architect', 'devops', 'documenter'],
quality: 0.88,
},
{
template: 'Review and improve the security of {component} following OWASP guidelines',
decomposition: ['audit_current', 'identify_vulnerabilities', 'plan_fixes', 'implement_fixes', 'verify'],
strategy: 'sequential',
agents: ['security-architect', 'security-architect', 'architect', 'coder', 'security-architect'],
quality: 0.9,
},
{
template: 'Design and implement a {data_structure} optimized for {operation} operations',
decomposition: ['research_options', 'design_structure', 'implement', 'write_tests', 'benchmark'],
strategy: 'sequential',
agents: ['researcher', 'architect', 'coder', 'tester', 'optimizer'],
quality: 0.85,
},
];
// Fill-in values for templates
const TEMPLATE_VALUES = {
feature: ['dark mode', 'real-time sync', 'offline support', 'multi-language', 'analytics dashboard', 'notification system', 'file upload', 'export functionality'],
system: ['web application', 'mobile app', 'backend service', 'CLI tool', 'browser extension', 'desktop app'],
requirement1: ['user authentication', 'data validation', 'error handling', 'caching', 'pagination', 'search'],
requirement2: ['logging', 'metrics', 'accessibility', 'responsive design', 'keyboard shortcuts', 'undo/redo'],
component: ['authentication module', 'payment service', 'user profile', 'notification system', 'search engine', 'data pipeline'],
pattern: ['async/await', 'event sourcing', 'CQRS', 'microservices', 'domain-driven design', 'hexagonal architecture'],
symptom: ['slow response times', 'high memory usage', 'database connection leaks', 'timeout errors', 'intermittent failures'],
domain: ['user management', 'inventory', 'payments', 'analytics', 'content management', 'scheduling'],
old_tech: ['MongoDB', 'Express.js', 'JavaScript', 'REST API', 'monolith', 'SQL Server'],
new_tech: ['PostgreSQL', 'NestJS', 'TypeScript', 'GraphQL', 'microservices', 'MongoDB'],
algorithm: ['search algorithm', 'sorting algorithm', 'caching strategy', 'load balancing', 'rate limiting', 'data compression'],
use_case: ['real-time search', 'batch processing', 'stream processing', 'recommendation engine', 'fraud detection'],
constraint: ['memory efficiency', 'low latency', 'high throughput', 'horizontal scaling', 'minimal dependencies'],
project: ['Node.js application', 'React frontend', 'Python service', 'Rust library', 'Go microservice'],
data_structure: ['priority queue', 'LRU cache', 'trie', 'bloom filter', 'skip list', 'B-tree'],
operation: ['insert', 'search', 'delete', 'range query', 'bulk update'],
};
// =============================================================================
// Hard Negative Pairs (Confusable Agent Combinations)
// =============================================================================
const HARD_NEGATIVE_PAIRS = [
['coder', 'debugger'],
['coder', 'refactorer'],
['researcher', 'reviewer'],
['tester', 'reviewer'],
['architect', 'planner'],
['documenter', 'api-docs'],
['optimizer', 'debugger'],
['devops', 'architect'],
['security-architect', 'reviewer'],
];
// =============================================================================
// Utility Functions
// =============================================================================
function generateUUID() {
if (crypto.randomUUID) {
return crypto.randomUUID();
}
// Fallback for older Node versions
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
const r = Math.random() * 16 | 0;
const v = c === 'x' ? r : (r & 0x3 | 0x8);
return v.toString(16);
});
}
function seededRandom(seed) {
let state = seed;
return function() {
state = (state * 1103515245 + 12345) & 0x7fffffff;
return state / 0x7fffffff;
};
}
function shuffle(array, rng) {
const shuffled = [...array];
for (let i = shuffled.length - 1; i > 0; i--) {
const j = Math.floor(rng() * (i + 1));
[shuffled[i], shuffled[j]] = [shuffled[j], shuffled[i]];
}
return shuffled;
}
function pickRandom(array, rng) {
return array[Math.floor(rng() * array.length)];
}
function generateEmbedding(dim, rng) {
const embedding = [];
for (let i = 0; i < dim; i++) {
embedding.push(rng() * 2 - 1);
}
// Normalize
const norm = Math.sqrt(embedding.reduce((sum, v) => sum + v * v, 0));
return embedding.map(v => v / norm);
}
function isHardNegative(agent1, agent2) {
return HARD_NEGATIVE_PAIRS.some(
([a, b]) => (agent1 === a && agent2 === b) || (agent1 === b && agent2 === a)
);
}
// =============================================================================
// Dataset Generation Functions
// =============================================================================
/**
* Fill a template with random values
*/
function fillTemplate(template, rng) {
let filled = template;
for (const [key, values] of Object.entries(TEMPLATE_VALUES)) {
const regex = new RegExp(`\\{${key}\\}`, 'g');
filled = filled.replace(regex, () => pickRandom(values, rng));
}
return filled;
}
/**
* Generate a sub-query from a decomposition step
*/
function generateSubQuery(id, step, agent, rng, dependencies = []) {
const stepDescriptions = {
research: 'Research best practices and options for',
design: 'Design the architecture for',
implement: 'Implement the functionality for',
test: 'Write comprehensive tests for',
document: 'Document the implementation of',
analyze: 'Analyze the current state of',
design_refactor: 'Design the refactoring approach for',
implement_changes: 'Implement the refactored code for',
write_tests: 'Write regression tests for',
review: 'Review the code quality of',
requirements: 'Gather and analyze requirements for',
implementation: 'Build the core implementation of',
error_handling: 'Add error handling to',
logging: 'Implement logging for',
testing: 'Create test suite for',
investigate: 'Investigate the root cause of',
identify_cause: 'Identify the specific cause of',
design_fix: 'Design a fix for',
implement_fix: 'Implement the fix for',
verify: 'Verify the fix works for',
design_api: 'Design the API structure for',
implement_endpoints: 'Implement API endpoints for',
add_auth: 'Add authentication to',
add_rate_limiting: 'Implement rate limiting for',
write_docs: 'Write API documentation for',
plan_migration: 'Create migration plan for',
prepare_infrastructure: 'Prepare infrastructure for',
migrate_data: 'Migrate data for',
switch_traffic: 'Switch traffic for',
cleanup: 'Clean up old resources for',
research_approaches: 'Research possible approaches for',
design_algorithm: 'Design the algorithm for',
optimize: 'Optimize performance of',
benchmark: 'Benchmark performance of',
design_pipeline: 'Design CI/CD pipeline for',
setup_tests: 'Set up automated testing for',
add_security: 'Add security scanning to',
configure_deployment: 'Configure deployment for',
audit_current: 'Audit current security of',
identify_vulnerabilities: 'Identify vulnerabilities in',
plan_fixes: 'Plan security fixes for',
implement_fixes: 'Implement security fixes for',
research_options: 'Research implementation options for',
design_structure: 'Design data structure for',
};
const description = stepDescriptions[step] || `Process ${step} for`;
return {
id,
query: `${description} the component`,
expectedType: agent === 'coder' ? 'code' : agent === 'documenter' || agent === 'api-docs' ? 'documentation' : 'analysis',
dependencies,
recommendedAgent: agent,
complexity: 0.3 + rng() * 0.5,
context: null,
};
}
/**
* Generate sub-answers for sub-queries
*/
function generateSubAnswers(subQueries, rng, successRate = 0.9) {
return subQueries.map(sq => ({
subQueryId: sq.id,
content: `Completed ${sq.query}`,
confidence: 0.7 + rng() * 0.3,
agent: sq.recommendedAgent,
latencyMs: Math.floor(100 + rng() * 2000),
quality: rng() < successRate ? 0.7 + rng() * 0.3 : 0.3 + rng() * 0.4,
success: rng() < successRate,
error: rng() >= successRate ? 'Partial completion' : null,
reasoning: null,
}));
}
/**
* Generate dependencies based on strategy
*/
function generateDependencies(subQueries, strategy) {
switch (strategy) {
case 'sequential':
return subQueries.map((sq, i) => ({
...sq,
dependencies: i > 0 ? [i - 1] : [],
}));
case 'parallel':
return subQueries.map(sq => ({
...sq,
dependencies: [],
}));
case 'hierarchical':
// First query is root, others depend on it or previous
return subQueries.map((sq, i) => ({
...sq,
dependencies: i === 0 ? [] : i < 3 ? [0] : [Math.floor(i / 2)],
}));
case 'dag-based':
// Complex dependencies
return subQueries.map((sq, i) => {
const deps = [];
if (i > 0) deps.push(i - 1);
if (i > 2) deps.push(0);
return { ...sq, dependencies: deps };
});
case 'iterative':
return subQueries.map((sq, i) => ({
...sq,
dependencies: i > 0 ? [i - 1] : [],
}));
default:
return subQueries;
}
}
/**
* Generate a single RLM training example
*/
function generateExample(config, rng) {
const template = pickRandom(COMPLEX_QUERY_TEMPLATES, rng);
const query = fillTemplate(template.template, rng);
// Generate sub-queries
let subQueries = template.decomposition.map((step, i) =>
generateSubQuery(i, step, template.agents[i], rng)
);
// Add dependencies based on strategy
subQueries = generateDependencies(subQueries, template.strategy);
const strategyDef = DECOMPOSITION_STRATEGIES[template.strategy];
const totalComplexity = subQueries.reduce((sum, sq) => sum + sq.complexity, 0) * strategyDef.complexityWeight;
// Generate decomposition
const decomposition = {
subQueries,
strategy: template.strategy,
rationale: `Using ${template.strategy} strategy for optimal execution`,
totalComplexity,
success: true,
error: null,
};
// Generate sub-answers
const subAnswers = generateSubAnswers(subQueries, rng, template.quality);
// Calculate quality score
const avgSubAnswerQuality = subAnswers.length > 0
? subAnswers.reduce((sum, a) => sum + a.quality, 0) / subAnswers.length
: 0;
const success = subAnswers.every(a => a.success);
const qualityScore = success
? template.quality * (0.9 + rng() * 0.1)
: template.quality * (0.5 + rng() * 0.3);
// Generate trajectory metadata
const trajectory = {
sessionId: generateUUID(),
userId: null,
totalLatencyMs: subAnswers.reduce((sum, a) => sum + a.latencyMs, 0),
retries: success ? 0 : Math.floor(rng() * 3),
maxParallelism: template.strategy === 'parallel' ? subQueries.length : 1,
modelsUsed: ['ruvltra-0.5b'],
agentsInvoked: [...new Set(subQueries.map(sq => sq.recommendedAgent))],
toolsUsed: [],
attributes: {},
};
return {
id: generateUUID(),
query,
queryEmbedding: generateEmbedding(config.embeddingDim, rng),
decomposition,
subAnswers,
finalAnswer: `Successfully completed: ${query}`,
finalEmbedding: generateEmbedding(config.embeddingDim, rng),
qualityScore,
trajectory,
success,
lessons: success ? [] : ['Encountered challenges during execution'],
source: 'synthetic',
};
}
/**
* Generate contrastive pairs from examples
*/
function generateContrastivePairs(examples, config, rng) {
const pairs = [];
const agents = Object.keys(AGENT_TRAINING_DATA);
for (const example of examples) {
for (const subQuery of example.decomposition.subQueries) {
if (!subQuery.recommendedAgent) continue;
const positiveAgent = subQuery.recommendedAgent;
for (const negativeAgent of agents) {
if (negativeAgent === positiveAgent) continue;
const isHard = isHardNegative(positiveAgent, negativeAgent);
// Apply hard negative ratio
const include = isHard
? rng() < config.hardNegativeRatio
: rng() < (1 - config.hardNegativeRatio) / agents.length;
if (include) {
pairs.push({
anchor: subQuery.query,
anchorEmbedding: example.queryEmbedding,
positiveAgent,
negativeAgent,
isHardNegative: isHard,
quality: example.qualityScore,
sourceId: example.id,
});
}
}
}
}
return pairs;
}
/**
* Generate the complete RLM dataset
*/
function generateRlmDataset(config = {}) {
const finalConfig = { ...DEFAULT_CONFIG, ...config };
const rng = seededRandom(finalConfig.seed);
console.log('\n============================================================');
console.log(' RLM TRAINING DATASET GENERATOR');
console.log('============================================================\n');
console.log('Configuration:');
console.log(` Examples to generate: ${finalConfig.exampleCount}`);
console.log(` Minimum quality: ${finalConfig.minQuality}`);
console.log(` Hard negative ratio: ${finalConfig.hardNegativeRatio}`);
console.log(` Embedding dimension: ${finalConfig.embeddingDim}`);
console.log(` Random seed: ${finalConfig.seed}`);
console.log('');
// Generate examples
console.log('Generating examples...');
const examples = [];
let attempts = 0;
const maxAttempts = finalConfig.exampleCount * 2;
while (examples.length < finalConfig.exampleCount && attempts < maxAttempts) {
const example = generateExample(finalConfig, rng);
if (example.qualityScore >= finalConfig.minQuality) {
examples.push(example);
}
attempts++;
}
console.log(` Generated ${examples.length} examples (${attempts} attempts)`);
// Generate contrastive pairs
console.log('\nGenerating contrastive pairs...');
const contrastivePairs = generateContrastivePairs(examples, finalConfig, rng);
console.log(` Generated ${contrastivePairs.length} contrastive pairs`);
// Calculate statistics
const stats = {
totalExamples: examples.length,
successfulExamples: examples.filter(e => e.success).length,
avgQuality: examples.reduce((sum, e) => sum + e.qualityScore, 0) / examples.length,
avgDecompositionDepth: examples.reduce((sum, e) => sum + e.decomposition.subQueries.length, 0) / examples.length,
strategyDistribution: {},
agentDistribution: {},
contrastivePairs: contrastivePairs.length,
hardNegativePairs: contrastivePairs.filter(p => p.isHardNegative).length,
};
// Calculate strategy distribution
for (const example of examples) {
const strategy = example.decomposition.strategy;
stats.strategyDistribution[strategy] = (stats.strategyDistribution[strategy] || 0) + 1;
}
// Calculate agent distribution
for (const example of examples) {
for (const sq of example.decomposition.subQueries) {
const agent = sq.recommendedAgent;
stats.agentDistribution[agent] = (stats.agentDistribution[agent] || 0) + 1;
}
}
console.log('\n============================================================');
console.log(' DATASET STATISTICS');
console.log('============================================================\n');
console.log(`Total Examples: ${stats.totalExamples}`);
console.log(`Successful Examples: ${stats.successfulExamples}`);
console.log(`Average Quality: ${(stats.avgQuality * 100).toFixed(1)}%`);
console.log(`Avg Decomposition Depth: ${stats.avgDecompositionDepth.toFixed(1)} steps`);
console.log(`Contrastive Pairs: ${stats.contrastivePairs}`);
console.log(`Hard Negative Pairs: ${stats.hardNegativePairs} (${((stats.hardNegativePairs / stats.contrastivePairs) * 100).toFixed(1)}%)`);
console.log('\nStrategy Distribution:');
for (const [strategy, count] of Object.entries(stats.strategyDistribution)) {
console.log(` ${strategy.padEnd(15)} ${count} (${((count / stats.totalExamples) * 100).toFixed(1)}%)`);
}
console.log('\nAgent Distribution:');
const sortedAgents = Object.entries(stats.agentDistribution).sort((a, b) => b[1] - a[1]);
for (const [agent, count] of sortedAgents) {
console.log(` ${agent.padEnd(20)} ${count}`);
}
return {
examples,
contrastivePairs,
stats,
config: finalConfig,
};
}
/**
* Export dataset to JSON file
*/
function exportDataset(dataset, outputFile) {
const output = {
metadata: {
generatedAt: new Date().toISOString(),
version: '1.0.0',
config: dataset.config,
stats: dataset.stats,
},
examples: dataset.examples,
contrastivePairs: dataset.contrastivePairs,
};
fs.writeFileSync(outputFile, JSON.stringify(output, null, 2));
console.log(`\nDataset exported to: ${outputFile}`);
console.log(`File size: ${(fs.statSync(outputFile).size / 1024 / 1024).toFixed(2)} MB`);
}
// =============================================================================
// CLI Interface
// =============================================================================
function parseArgs(args) {
const config = { ...DEFAULT_CONFIG };
for (let i = 0; i < args.length; i++) {
const arg = args[i];
if (arg === '--output' && args[i + 1]) {
config.outputFile = args[++i];
} else if (arg === '--count' && args[i + 1]) {
config.exampleCount = parseInt(args[++i], 10);
} else if (arg === '--quality' && args[i + 1]) {
config.minQuality = parseFloat(args[++i]);
} else if (arg === '--seed' && args[i + 1]) {
config.seed = parseInt(args[++i], 10);
} else if (arg === '--hard-ratio' && args[i + 1]) {
config.hardNegativeRatio = parseFloat(args[++i]);
} else if (arg === '--help' || arg === '-h') {
console.log(`
RLM Training Dataset Generator
Usage: node rlm-dataset.js [options]
Options:
--output <file> Output file path (default: rlm-training-dataset.json)
--count <n> Number of examples to generate (default: 500)
--quality <min> Minimum quality threshold (default: 0.6)
--seed <n> Random seed (default: 42)
--hard-ratio <r> Hard negative pair ratio (default: 0.3)
--help, -h Show this help message
Example:
node rlm-dataset.js --output my-dataset.json --count 1000 --quality 0.7
`);
process.exit(0);
}
}
return config;
}
// Main execution
if (require.main === module) {
const config = parseArgs(process.argv.slice(2));
const dataset = generateRlmDataset(config);
exportDataset(dataset, config.outputFile);
}
// Module exports
module.exports = {
generateRlmDataset,
generateExample,
generateContrastivePairs,
exportDataset,
COMPLEX_QUERY_TEMPLATES,
DECOMPOSITION_STRATEGIES,
TEMPLATE_VALUES,
HARD_NEGATIVE_PAIRS,
DEFAULT_CONFIG,
};