@nahisaho/musubix-neural-search 2.0.0

package/dist/search/PruningManager.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Pruning Manager
+ * @module @nahisaho/musubix-neural-search
+ * @description Learning-based pruning for search
+ * Traces to: REQ-NS-003 (学習ベースプルーニング)
+ */
+import type { IPruningManager, PruningDecision, PruningStatistics, SearchContext, SearchState } from '../types.js';
+/**
+ * Pruning configuration
+ */
+export interface PruningConfig {
+    scoreThreshold: number;
+    maxDepth: number;
+    enableLearning: boolean;
+}
+/**
+ * Pruning manager implementation
+ */
+export declare class PruningManager implements IPruningManager {
+    private readonly config;
+    private readonly seenStates;
+    private readonly learnedPatterns;
+    private stats;
+    constructor(config?: Partial<PruningConfig>);
+    /**
+     * Decide whether to prune a state
+     */
+    shouldPrune(state: SearchState, context: SearchContext): PruningDecision;
+    /**
+     * Learn from pruning outcome
+     */
+    learn(state: SearchState, outcome: 'correct' | 'incorrect'): void;
+    /**
+     * Get pruning statistics
+     */
+    getStatistics(): PruningStatistics;
+    /**
+     * Get learned patterns count
+     */
+    getLearnedPatternsCount(): number;
+    /**
+     * Reset state (for new search)
+     */
+    reset(): void;
+    /**
+     * Hash a state for duplicate detection
+     */
+    private hashState;
+    /**
+     * Extract pattern from state for learning
+     */
+    private extractPattern;
+    /**
+     * Check if state matches learned patterns to prune
+     */
+    private checkLearnedPatterns;
+    /**
+     * Check if state is a dead end
+     */
+    private isDeadEnd;
+}
+//# sourceMappingURL=PruningManager.d.ts.map

package/dist/search/PruningManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PruningManager.d.ts","sourceRoot":"","sources":["../../src/search/PruningManager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EACV,eAAe,EACf,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,WAAW,EACZ,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,OAAO,CAAC;CACzB;AA8BD;;GAEG;AACH,qBAAa,cAAe,YAAW,eAAe;IACpD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAc;IACzC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA8B;IAC9D,OAAO,CAAC,KAAK,CAAoB;gBAErB,MAAM,GAAE,OAAO,CAAC,aAAa,CAAM;IAY/C;;OAEG;IACH,WAAW,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,aAAa,GAAG,eAAe;IAgDxE;;OAEG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,SAAS,GAAG,WAAW,GAAG,IAAI;IAkCjE;;OAEG;IACH,aAAa,IAAI,iBAAiB;IAIlC;;OAEG;IACH,uBAAuB,IAAI,MAAM;IAIjC;;OAEG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,OAAO,CAAC,SAAS;IAIjB;;OAEG;IACH,OAAO,CAAC,cAAc;IAWtB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAe5B;;OAEG;IACH,OAAO,CAAC,SAAS;CAsBlB"}

package/dist/search/PruningManager.js

@@ -0,0 +1,188 @@
+/**
+ * Pruning Manager
+ * @module @nahisaho/musubix-neural-search
+ * @description Learning-based pruning for search
+ * Traces to: REQ-NS-003 (学習ベースプルーニング)
+ */
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+    scoreThreshold: 0.2,
+    maxDepth: 15,
+    enableLearning: true,
+};
+/**
+ * Pruning manager implementation
+ */
+export class PruningManager {
+    config;
+    seenStates;
+    learnedPatterns;
+    stats;
+    constructor(config = {}) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.seenStates = new Set();
+        this.learnedPatterns = new Map();
+        this.stats = {
+            totalDecisions: 0,
+            correctPrunes: 0,
+            incorrectPrunes: 0,
+            accuracy: 1.0,
+        };
+    }
+    /**
+     * Decide whether to prune a state
+     */
+    shouldPrune(state, context) {
+        this.stats.totalDecisions++;
+        // Check for duplicate
+        const stateHash = this.hashState(state);
+        if (this.seenStates.has(stateHash)) {
+            return {
+                prune: true,
+                reason: 'duplicate',
+                confidence: 1.0,
+            };
+        }
+        this.seenStates.add(stateHash);
+        // Check depth limit
+        if (state.depth > this.config.maxDepth) {
+            return {
+                prune: true,
+                reason: 'resource_limit',
+                confidence: 0.9,
+            };
+        }
+        // Check learned patterns
+        if (this.config.enableLearning) {
+            const learnedDecision = this.checkLearnedPatterns(state);
+            if (learnedDecision) {
+                return learnedDecision;
+            }
+        }
+        // Check for dead ends (empty code or obvious failures)
+        if (this.isDeadEnd(state, context)) {
+            return {
+                prune: true,
+                reason: 'dead_end',
+                confidence: 0.8,
+            };
+        }
+        // Default: don't prune
+        return {
+            prune: false,
+            reason: 'low_score', // Will only be used if prune is true
+            confidence: 0.5,
+        };
+    }
+    /**
+     * Learn from pruning outcome
+     */
+    learn(state, outcome) {
+        if (!this.config.enableLearning)
+            return;
+        if (outcome === 'correct') {
+            this.stats.correctPrunes++;
+        }
+        else {
+            this.stats.incorrectPrunes++;
+        }
+        // Update accuracy
+        const total = this.stats.correctPrunes + this.stats.incorrectPrunes;
+        this.stats.accuracy = total > 0
+            ? this.stats.correctPrunes / total
+            : 1.0;
+        // Learn pattern
+        const pattern = this.extractPattern(state);
+        const existing = this.learnedPatterns.get(pattern);
+        if (existing) {
+            existing.sampleCount++;
+            existing.pruneRate =
+                (existing.pruneRate * (existing.sampleCount - 1) +
+                    (outcome === 'correct' ? 1 : 0)) /
+                    existing.sampleCount;
+        }
+        else {
+            this.learnedPatterns.set(pattern, {
+                pattern,
+                pruneRate: outcome === 'correct' ? 1 : 0,
+                sampleCount: 1,
+            });
+        }
+    }
+    /**
+     * Get pruning statistics
+     */
+    getStatistics() {
+        return { ...this.stats };
+    }
+    /**
+     * Get learned patterns count
+     */
+    getLearnedPatternsCount() {
+        return this.learnedPatterns.size;
+    }
+    /**
+     * Reset state (for new search)
+     */
+    reset() {
+        this.seenStates.clear();
+    }
+    /**
+     * Hash a state for duplicate detection
+     */
+    hashState(state) {
+        return `${state.code}:${state.depth}`;
+    }
+    /**
+     * Extract pattern from state for learning
+     */
+    extractPattern(state) {
+        // Simple pattern: code structure signature
+        const codeSignature = state.code
+            .replace(/\s+/g, ' ')
+            .replace(/[a-z]+/g, 'x')
+            .replace(/[0-9]+/g, 'n')
+            .substring(0, 50);
+        return codeSignature;
+    }
+    /**
+     * Check if state matches learned patterns to prune
+     */
+    checkLearnedPatterns(state) {
+        const pattern = this.extractPattern(state);
+        const learned = this.learnedPatterns.get(pattern);
+        if (learned && learned.sampleCount >= 3 && learned.pruneRate > 0.7) {
+            return {
+                prune: true,
+                reason: 'learned_pattern',
+                confidence: learned.pruneRate,
+            };
+        }
+        return null;
+    }
+    /**
+     * Check if state is a dead end
+     */
+    isDeadEnd(state, _context) {
+        // Empty code
+        if (!state.code || state.code.trim().length === 0) {
+            return true;
+        }
+        // Syntax error indicators
+        const errorPatterns = [
+            'SyntaxError',
+            'TypeError',
+            'undefined is not',
+            'null is not',
+        ];
+        for (const pattern of errorPatterns) {
+            if (state.code.includes(pattern)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=PruningManager.js.map

package/dist/search/PruningManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PruningManager.js","sourceRoot":"","sources":["../../src/search/PruningManager.ts"],"names":[],"mappings":"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"}

package/dist/search/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Search Engine Module
+ * @module @nahisaho/musubix-neural-search/search
+ */
+export { PriorityQueue } from './PriorityQueue.js';
+export { BeamSearch } from './BeamSearch.js';
+export { BestFirstSearch } from './BestFirstSearch.js';
+export { PruningManager } from './PruningManager.js';
+export type { PruningConfig } from './PruningManager.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/search/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AACrD,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/search/index.js

@@ -0,0 +1,9 @@
+/**
+ * Search Engine Module
+ * @module @nahisaho/musubix-neural-search/search
+ */
+export { PriorityQueue } from './PriorityQueue.js';
+export { BeamSearch } from './BeamSearch.js';
+export { BestFirstSearch } from './BestFirstSearch.js';
+export { PruningManager } from './PruningManager.js';
+//# sourceMappingURL=index.js.map

package/dist/search/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/search/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AACvD,OAAO,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/types.d.ts

@@ -0,0 +1,416 @@
+/**
+ * Neural Search Types
+ * @module @nahisaho/musubix-neural-search
+ * @description Type definitions for neural search engine
+ */
+/**
+ * Vector embedding representation
+ */
+export type Embedding = Float32Array | number[];
+/**
+ * Configuration for embedding model
+ */
+export interface EmbeddingConfig {
+    readonly modelName: string;
+    readonly dimension: number;
+    readonly maxLength: number;
+    readonly poolingStrategy: 'mean' | 'cls' | 'max';
+}
+/**
+ * Embedding model interface
+ * Traces to: REQ-NS-001 (分岐スコアリング)
+ */
+export interface IEmbeddingModel {
+    /**
+     * Embed source code
+     */
+    embedCode(code: string): Promise<Embedding>;
+    /**
+     * Embed specification/requirement
+     */
+    embedSpec(spec: string): Promise<Embedding>;
+    /**
+     * Calculate similarity between embeddings
+     */
+    similarity(a: Embedding, b: Embedding): number;
+    /**
+     * Batch embed multiple texts
+     */
+    embedBatch(texts: string[]): Promise<Embedding[]>;
+}
+/**
+ * Search state representing a partial synthesis
+ */
+export interface SearchState {
+    readonly id: string;
+    readonly code: string;
+    readonly parent?: string;
+    readonly depth: number;
+    readonly metadata: Record<string, unknown>;
+}
+/**
+ * Branch in the search tree
+ */
+export interface Branch {
+    readonly from: SearchState;
+    readonly to: SearchState;
+    readonly action: string;
+    readonly features: BranchFeatures;
+}
+/**
+ * Features extracted from a branch
+ */
+export interface BranchFeatures {
+    readonly codeEmbedding: Embedding;
+    readonly specSimilarity: number;
+    readonly syntaxValid: boolean;
+    readonly typeChecks: boolean;
+    readonly complexity: number;
+    readonly novelty: number;
+}
+/**
+ * Score result for a branch
+ */
+export interface BranchScore {
+    readonly branch: Branch;
+    readonly score: number;
+    readonly confidence: number;
+    readonly components: ScoreComponents;
+}
+/**
+ * Components of the score
+ */
+export interface ScoreComponents {
+    readonly specAlignment: number;
+    readonly codeQuality: number;
+    readonly novelty: number;
+    readonly feasibility: number;
+}
+/**
+ * Branch scorer interface
+ * Traces to: REQ-NS-001 (分岐スコアリング)
+ */
+export interface IBranchScorer {
+    /**
+     * Score a single branch
+     */
+    score(branch: Branch, context: SearchContext): Promise<BranchScore>;
+    /**
+     * Score multiple branches
+     */
+    scoreBatch(branches: Branch[], context: SearchContext): Promise<BranchScore[]>;
+    /**
+     * Update scorer with feedback
+     */
+    update(feedback: ScoreFeedback): void;
+}
+/**
+ * Context for search scoring
+ */
+export interface SearchContext {
+    readonly specification: string;
+    readonly specEmbedding: Embedding;
+    readonly constraints: string[];
+    readonly history: SearchState[];
+}
+/**
+ * Feedback for score adjustment
+ */
+export interface ScoreFeedback {
+    readonly branchId: string;
+    readonly actualOutcome: 'success' | 'failure' | 'partial';
+    readonly reason?: string;
+}
+/**
+ * Encoded context representation
+ */
+export interface EncodedContext {
+    readonly embedding: Embedding;
+    readonly features: ContextFeatures;
+    readonly tokens: number;
+}
+/**
+ * Features extracted from context
+ */
+export interface ContextFeatures {
+    readonly specLength: number;
+    readonly constraintCount: number;
+    readonly complexityEstimate: number;
+    readonly domainSignals: string[];
+}
+/**
+ * Context encoder interface
+ */
+export interface IContextEncoder {
+    /**
+     * Encode full search context
+     */
+    encode(context: SearchContext): Promise<EncodedContext>;
+    /**
+     * Encode specification only
+     */
+    encodeSpec(spec: string): Promise<EncodedContext>;
+    /**
+     * Update encoder with learned patterns
+     */
+    updatePatterns(patterns: string[]): void;
+}
+/**
+ * Search configuration
+ */
+export interface SearchConfig {
+    readonly maxDepth: number;
+    readonly maxIterations: number;
+    readonly timeout: number;
+    readonly beamWidth?: number;
+    readonly pruneThreshold?: number;
+}
+/**
+ * Search result
+ */
+export interface SearchResult {
+    readonly state: SearchState;
+    readonly score: number;
+    readonly path: SearchState[];
+    readonly iterations: number;
+    readonly pruned: number;
+}
+/**
+ * Beam search interface
+ * Traces to: REQ-NS-002 (探索優先順位付け)
+ */
+export interface IBeamSearch {
+    /**
+     * Execute beam search
+     */
+    search(initial: SearchState, expand: (state: SearchState) => Promise<Branch[]>, scorer: IBranchScorer, context: SearchContext, config: SearchConfig): Promise<SearchResult[]>;
+    /**
+     * Get current beam
+     */
+    getCurrentBeam(): SearchState[];
+    /**
+     * Get search statistics
+     */
+    getStatistics(): SearchStatistics;
+}
+/**
+ * Best-first search interface
+ */
+export interface IBestFirstSearch {
+    /**
+     * Execute best-first search
+     */
+    search(initial: SearchState, expand: (state: SearchState) => Promise<Branch[]>, scorer: IBranchScorer, context: SearchContext, config: SearchConfig): Promise<SearchResult>;
+    /**
+     * Get open list size
+     */
+    getOpenListSize(): number;
+}
+/**
+ * Search statistics
+ */
+export interface SearchStatistics {
+    readonly totalExpanded: number;
+    readonly totalPruned: number;
+    readonly maxDepthReached: number;
+    readonly averageScore: number;
+    readonly timeElapsed: number;
+}
+/**
+ * Pruning decision
+ */
+export interface PruningDecision {
+    readonly prune: boolean;
+    readonly reason: PruningReason;
+    readonly confidence: number;
+}
+/**
+ * Pruning reason
+ */
+export type PruningReason = 'low_score' | 'duplicate' | 'dead_end' | 'resource_limit' | 'learned_pattern';
+/**
+ * Pruning manager interface
+ * Traces to: REQ-NS-003 (学習ベースプルーニング)
+ */
+export interface IPruningManager {
+    /**
+     * Decide whether to prune a state
+     */
+    shouldPrune(state: SearchState, context: SearchContext): PruningDecision;
+    /**
+     * Learn from pruning outcome
+     */
+    learn(state: SearchState, outcome: 'correct' | 'incorrect'): void;
+    /**
+     * Get pruning statistics
+     */
+    getStatistics(): PruningStatistics;
+}
+/**
+ * Pruning statistics
+ */
+export interface PruningStatistics {
+    readonly totalDecisions: number;
+    readonly correctPrunes: number;
+    readonly incorrectPrunes: number;
+    readonly accuracy: number;
+}
+/**
+ * Search trajectory
+ * Traces to: REQ-NS-004 (探索履歴学習)
+ */
+export interface SearchTrajectory {
+    readonly id: string;
+    readonly specification: string;
+    readonly path: TrajectoryStep[];
+    readonly outcome: TrajectoryOutcome;
+    readonly timestamp: Date;
+}
+/**
+ * Step in a trajectory
+ */
+export interface TrajectoryStep {
+    readonly state: SearchState;
+    readonly score: number;
+    readonly action: string;
+    readonly duration: number;
+}
+/**
+ * Outcome of a trajectory
+ */
+export interface TrajectoryOutcome {
+    readonly success: boolean;
+    readonly finalScore: number;
+    readonly reason?: string;
+    readonly userFeedback?: 'accept' | 'reject' | 'modify';
+}
+/**
+ * Trajectory log interface
+ */
+export interface ITrajectoryLog {
+    /**
+     * Log a completed trajectory
+     */
+    log(trajectory: SearchTrajectory): void;
+    /**
+     * Query trajectories by specification
+     */
+    queryBySpec(spec: string, limit?: number): SearchTrajectory[];
+    /**
+     * Get successful trajectories
+     */
+    getSuccessful(limit?: number): SearchTrajectory[];
+    /**
+     * Get statistics
+     */
+    getStatistics(): TrajectoryStatistics;
+}
+/**
+ * Trajectory statistics
+ */
+export interface TrajectoryStatistics {
+    readonly totalTrajectories: number;
+    readonly successRate: number;
+    readonly averageLength: number;
+    readonly averageDuration: number;
+}
+/**
+ * Learning update
+ */
+export interface LearningUpdate {
+    readonly trajectoryId: string;
+    readonly gradients: Map<string, number>;
+    readonly loss: number;
+}
+/**
+ * Online learner interface
+ */
+export interface IOnlineLearner {
+    /**
+     * Learn from a trajectory
+     */
+    learnFromTrajectory(trajectory: SearchTrajectory): LearningUpdate;
+    /**
+     * Get current model parameters
+     */
+    getParameters(): Map<string, number>;
+    /**
+     * Apply learning update
+     */
+    applyUpdate(update: LearningUpdate): void;
+    /**
+     * Get learning statistics
+     */
+    getStatistics(): LearningStatistics;
+}
+/**
+ * Learning statistics
+ */
+export interface LearningStatistics {
+    readonly totalUpdates: number;
+    readonly averageLoss: number;
+    readonly learningRate: number;
+    readonly convergenceMetric: number;
+}
+/**
+ * Model update request
+ */
+export interface ModelUpdateRequest {
+    readonly updates: LearningUpdate[];
+    readonly batchSize: number;
+    readonly epoch: number;
+}
+/**
+ * Model updater interface
+ */
+export interface IModelUpdater {
+    /**
+     * Queue an update
+     */
+    queueUpdate(update: LearningUpdate): void;
+    /**
+     * Flush pending updates
+     */
+    flushUpdates(): Promise<void>;
+    /**
+     * Get pending update count
+     */
+    getPendingCount(): number;
+}
+/**
+ * Priority queue item
+ */
+export interface PriorityItem<T> {
+    readonly item: T;
+    readonly priority: number;
+}
+/**
+ * Priority queue interface
+ */
+export interface IPriorityQueue<T> {
+    /**
+     * Add item with priority
+     */
+    push(item: T, priority: number): void;
+    /**
+     * Remove and return highest priority item
+     */
+    pop(): T | undefined;
+    /**
+     * Peek at highest priority item
+     */
+    peek(): T | undefined;
+    /**
+     * Get queue size
+     */
+    size(): number;
+    /**
+     * Check if empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Clear the queue
+     */
+    clear(): void;
+}
+//# sourceMappingURL=types.d.ts.map