cognitive-core 0.2.5 → 0.3.1

package/src/search/index.ts

@@ -1,78 +0,0 @@
-export {
-  TaskRouter,
-  createRouter,
-  type RoutingDecision,
-} from './router.js';
-
-// MoE-inspired routing gate
-export {
-  MoEGate,
-  createMoEGate,
-  extractTaskFeatures,
-  MOE_FEATURE_SIZE,
-  MOE_STRATEGIES,
-  type MoEGateState,
-} from './moe-gate.js';
-
-export {
-  DirectSolver,
-  createSolver,
-  type SolverConfig,
-  type SolverResult,
-} from './solver.js';
-
-// Refinement types
-export {
-  type EvaluationResult,
-  type EvaluationIssue,
-  type EvaluationMethod,
-  type QualityLevel,
-  type FailureContext,
-  type RefinementResult,
-  type IssueType,
-  type IssueSeverity,
-  createEvaluationResult,
-  scoreToQuality,
-  isQualityAcceptable,
-  EvaluationResultSchema,
-  EvaluationIssueSchema,
-  QualityLevelSchema,
-  IssueSeveritySchema,
-  IssueTypeSchema,
-  EvaluationMethodSchema,
-} from './refinement-types.js';
-
-// Solution evaluator
-export {
-  SolutionEvaluator,
-  createSolutionEvaluator,
-  type EvaluatorConfig,
-  type VerificationFunction,
-  type VerificationResult,
-} from './evaluator.js';
-
-// Refinement loop
-export {
-  RefinementLoop,
-  createRefinementLoop,
-  type RefinementLoopConfig,
-} from './refinement-loop.js';
-
-// Team routing
-export {
-  TeamRouter,
-  createTeamRouter,
-  type TeamRouterConfig,
-  type TeamRecommendation,
-  type TeamRecommendationInput,
-} from './team-router.js';
-
-// Verification runner
-export {
-  VerificationRunner,
-  createVerificationRunner,
-  TestRunners,
-  type CommandVerificationConfig,
-  type CommandResult,
-  type VerificationIssue,
-} from './verification-runner.js';

package/src/search/moe-gate.ts

@@ -1,304 +0,0 @@
-/**
- * MoEGate — Mixture-of-Experts inspired gating for task routing.
- *
- * Learns per-domain weight vectors over routing strategies from outcome
- * feedback. Replaces threshold-based strategy selection with a learned
- * linear gate:
- *
- *   gate(features) = softmax(W · features)
- *
- * where W is a weight matrix (one row per strategy), and features are
- * extracted from the task + memory state.
- *
- * Online gradient update:
- *   w[chosen] += learningRate * reward * features
- *   w[others] -= learningRate * (1 - reward) * features / (numStrategies - 1)
- *
- * Cold start: uniform weights → falls back to existing threshold logic.
- */
-
-/**
- * Serialized gate state for persistence
- */
-export interface MoEGateState {
-  strategies: string[];
-  featureSize: number;
-  globalWeights: number[][];
-  domainWeights: Record<string, number[][]>;
-  updateCount: number;
-}
-
-/**
- * MoE-inspired gating function over routing strategies
- */
-export class MoEGate {
-  private strategies: string[];
-  private featureSize: number;
-  private globalWeights: number[][];
-  private domainWeights: Map<string, number[][]> = new Map();
-  private updateCount = 0;
-
-  constructor(strategies: string[], featureSize: number) {
-    this.strategies = strategies;
-    this.featureSize = featureSize;
-
-    // Initialize global weights to small random values (near-uniform gate)
-    this.globalWeights = strategies.map(() =>
-      Array.from({ length: featureSize }, () => (Math.random() - 0.5) * 0.01)
-    );
-  }
-
-  /**
-   * Compute gate weights for a task given its feature vector.
-   * Returns a map of strategy → probability.
-   */
-  gate(features: number[], domain?: string): Map<string, number> {
-    const weights = this.getWeights(domain);
-    const logits = this.computeLogits(weights, features);
-    const probs = this.softmax(logits);
-
-    const result = new Map<string, number>();
-    for (let i = 0; i < this.strategies.length; i++) {
-      result.set(this.strategies[i], probs[i]);
-    }
-    return result;
-  }
-
-  /**
-   * Select the best strategy (argmax of gate output).
-   */
-  selectStrategy(features: number[], domain?: string): string {
-    const gateOutput = this.gate(features, domain);
-
-    let bestStrategy = this.strategies[0];
-    let bestProb = -1;
-    for (const [strategy, prob] of gateOutput) {
-      if (prob > bestProb) {
-        bestProb = prob;
-        bestStrategy = strategy;
-      }
-    }
-
-    return bestStrategy;
-  }
-
-  /**
-   * Update weights from outcome feedback (online gradient).
-   *
-   * Positive reward → increase weight for chosen strategy's features.
-   * Negative reward → decrease weight.
-   */
-  update(
-    features: number[],
-    chosenStrategy: string,
-    reward: number,
-    learningRate = 0.01,
-    domain?: string
-  ): void {
-    const chosenIdx = this.strategies.indexOf(chosenStrategy);
-    if (chosenIdx === -1) return;
-
-    // Update global weights
-    this.updateWeightMatrix(this.globalWeights, features, chosenIdx, reward, learningRate);
-
-    // Update domain-specific weights if domain provided
-    if (domain) {
-      if (!this.domainWeights.has(domain)) {
-        // Initialize domain weights as copy of global
-        this.domainWeights.set(
-          domain,
-          this.globalWeights.map((row) => [...row])
-        );
-      }
-      const domainW = this.domainWeights.get(domain)!;
-      this.updateWeightMatrix(domainW, features, chosenIdx, reward, learningRate);
-    }
-
-    this.updateCount++;
-  }
-
-  /**
-   * Whether the gate has been trained (has seen any updates).
-   */
-  get isTrained(): boolean {
-    return this.updateCount > 0;
-  }
-
-  /**
-   * Number of updates the gate has seen.
-   */
-  get totalUpdates(): number {
-    return this.updateCount;
-  }
-
-  /**
-   * Serialize for persistence.
-   */
-  toJSON(): MoEGateState {
-    const domainWeights: Record<string, number[][]> = {};
-    for (const [domain, weights] of this.domainWeights) {
-      domainWeights[domain] = weights;
-    }
-
-    return {
-      strategies: this.strategies,
-      featureSize: this.featureSize,
-      globalWeights: this.globalWeights,
-      domainWeights,
-      updateCount: this.updateCount,
-    };
-  }
-
-  /**
-   * Deserialize from persisted state.
-   */
-  static fromJSON(data: MoEGateState): MoEGate {
-    const gate = new MoEGate(data.strategies, data.featureSize);
-    gate.globalWeights = data.globalWeights;
-    gate.updateCount = data.updateCount;
-
-    for (const [domain, weights] of Object.entries(data.domainWeights)) {
-      gate.domainWeights.set(domain, weights);
-    }
-
-    return gate;
-  }
-
-  // === Internal ===
-
-  /**
-   * Get the weight matrix for a domain (with fallback to global).
-   */
-  private getWeights(domain?: string): number[][] {
-    if (domain && this.domainWeights.has(domain)) {
-      return this.domainWeights.get(domain)!;
-    }
-    return this.globalWeights;
-  }
-
-  /**
-   * Compute logits = W · features for each strategy.
-   */
-  private computeLogits(weights: number[][], features: number[]): number[] {
-    return weights.map((row) => {
-      let sum = 0;
-      for (let j = 0; j < Math.min(row.length, features.length); j++) {
-        sum += row[j] * features[j];
-      }
-      return sum;
-    });
-  }
-
-  /**
-   * Softmax with numerical stability (subtract max).
-   */
-  private softmax(logits: number[]): number[] {
-    const max = Math.max(...logits);
-    const exps = logits.map((l) => Math.exp(l - max));
-    const sum = exps.reduce((a, b) => a + b, 0);
-    return exps.map((e) => e / sum);
-  }
-
-  /**
-   * Online gradient update on a weight matrix.
-   *
-   * Uses centered reward (reward - 0.5) so that:
-   *   reward=1 → positive update for chosen, negative for others
-   *   reward=0 → negative update for chosen, positive for others
-   */
-  private updateWeightMatrix(
-    weights: number[][],
-    features: number[],
-    chosenIdx: number,
-    reward: number,
-    learningRate: number
-  ): void {
-    const numStrategies = this.strategies.length;
-    const centered = reward - 0.5; // range: [-0.5, 0.5]
-
-    for (let i = 0; i < numStrategies; i++) {
-      for (let j = 0; j < this.featureSize; j++) {
-        if (i === chosenIdx) {
-          // Positive reward → boost chosen; negative → penalize chosen
-          weights[i][j] += learningRate * centered * features[j];
-        } else {
-          // Opposite direction for unchosen strategies
-          weights[i][j] -=
-            learningRate * centered * features[j] / (numStrategies - 1);
-        }
-      }
-    }
-  }
-}
-
-/**
- * Extract feature vector from a task and memory context for the MoE gate.
- *
- * Features (8 dimensions):
- * 0: task description length (normalized)
- * 1: domain familiarity (experience count, normalized)
- * 2: best experience match score
- * 3: best playbook match score
- * 4: best playbook confidence
- * 5: is bug fix (0/1)
- * 6: is new feature (0/1)
- * 7: task complexity proxy (word count, normalized)
- */
-export function extractTaskFeatures(
-  taskDescription: string,
-  memoryContext: {
-    experiences: Array<{ score: number }>;
-    playbooks: Array<{ score: number; playbook: { confidence: number } }>;
-  },
-  experienceCountInDomain = 0
-): number[] {
-  const desc = taskDescription.toLowerCase();
-
-  const bestExpScore = memoryContext.experiences.length > 0
-    ? Math.max(...memoryContext.experiences.map((e) => e.score))
-    : 0;
-
-  const bestPlaybookScore = memoryContext.playbooks.length > 0
-    ? Math.max(...memoryContext.playbooks.map((p) => p.score))
-    : 0;
-
-  const bestPlaybookConfidence = memoryContext.playbooks.length > 0
-    ? Math.max(...memoryContext.playbooks.map((p) => p.playbook.confidence))
-    : 0;
-
-  const isBugFix =
-    desc.includes('bug') || desc.includes('fix') || desc.includes('error')
-      ? 1
-      : 0;
-
-  const isNewFeature =
-    desc.includes('implement') || desc.includes('create') || desc.includes('add')
-      ? 1
-      : 0;
-
-  const wordCount = taskDescription.split(/\s+/).length;
-
-  return [
-    Math.min(taskDescription.length / 1000, 1),     // [0] length, normalized
-    Math.min(experienceCountInDomain / 100, 1),      // [1] domain familiarity
-    bestExpScore,                                     // [2] best experience match
-    bestPlaybookScore,                                // [3] best playbook match
-    bestPlaybookConfidence,                           // [4] best playbook confidence
-    isBugFix,                                         // [5] bug fix indicator
-    isNewFeature,                                     // [6] new feature indicator
-    Math.min(wordCount / 100, 1),                     // [7] complexity proxy
-  ];
-}
-
-/** Default feature size for the MoE gate */
-export const MOE_FEATURE_SIZE = 8;
-
-/** Default strategies for the MoE gate */
-export const MOE_STRATEGIES = ['direct', 'adapt', 'explore', 'fallback'] as const;
-
-/**
- * Create a MoEGate with default settings
- */
-export function createMoEGate(): MoEGate {
-  return new MoEGate([...MOE_STRATEGIES], MOE_FEATURE_SIZE);
-}