@nahisaho/musubix-wake-sleep 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @fileoverview Wake-Sleep type definitions
+ * @traceability REQ-WAKE-001
+ */
+/**
+ * Wake phase task for learning
+ */
+export interface WakeTask {
+    id: string;
+    type: 'code' | 'requirements' | 'design';
+    content: string;
+    metadata?: Record<string, unknown>;
+    timestamp: string;
+}
+/**
+ * Wake phase result
+ */
+export interface WakeResult {
+    taskId: string;
+    success: boolean;
+    extractedPatterns: string[];
+    confidence: number;
+    processingTime: number;
+    metadata?: Record<string, unknown>;
+    error?: string;
+}
+/**
+ * Sleep phase consolidation input
+ */
+export interface ConsolidationInput {
+    patterns: PatternCandidate[];
+    existingLibrary: string[];
+}
+/**
+ * Pattern candidate for consolidation
+ */
+export interface PatternCandidate {
+    id?: string;
+    name: string;
+    code?: string;
+    structure: unknown;
+    occurrences: number;
+    confidence: number;
+    source: 'code' | 'requirements' | 'design';
+    frequency?: number;
+    contexts?: string[];
+}
+/**
+ * Sleep phase result
+ */
+export interface SleepResult {
+    consolidatedPatterns: string[];
+    abstractedPatterns: AbstractedPattern[];
+    prunedPatterns: string[];
+    mdlScore: number;
+}
+/**
+ * Abstracted pattern after sleep phase
+ */
+export interface AbstractedPattern {
+    id: string;
+    originalPatterns: string[];
+    abstractedCode: string;
+    compressionRatio: number;
+}
+/**
+ * Wake-sleep cycle configuration
+ */
+export interface CycleConfig {
+    /** Number of wake tasks before sleep */
+    wakeTaskThreshold: number;
+    /** Maximum cycle duration in ms */
+    maxCycleDuration: number;
+    /** Minimum pattern frequency for consolidation */
+    minPatternFrequency: number;
+    /** MDL threshold for abstraction */
+    mdlThreshold: number;
+}
+/**
+ * Cycle status
+ */
+export interface CycleStatus {
+    currentPhase: 'wake' | 'sleep' | 'idle';
+    taskCount: number;
+    patternCount: number;
+    cycleNumber: number;
+    lastCycleTime: string | null;
+}
+/**
+ * Resource limits configuration
+ */
+export interface ResourceLimits {
+    /** Maximum memory usage in MB */
+    maxMemoryMB: number;
+    /** Maximum CPU time per operation in ms */
+    maxCpuTimeMs: number;
+    /** Maximum patterns in library */
+    maxPatterns: number;
+    /** Maximum concurrent operations */
+    maxConcurrency: number;
+}
+/**
+ * Resource usage metrics
+ */
+export interface ResourceMetrics {
+    memoryUsedMB: number;
+    cpuTimeMs: number;
+    patternCount: number;
+    activeOperations: number;
+}
+/**
+ * Quality metrics for learning
+ */
+export interface QualityMetrics {
+    accuracy: number;
+    precision: number;
+    recall: number;
+    f1Score: number;
+    mdlScore: number;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

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

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Wake-Sleep type definitions
+ * @traceability REQ-WAKE-001
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/wake/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Wake phase module
+ * @traceability TSK-WAKE-001
+ */
+export { WakePhase } from './wake-phase.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/wake/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/wake/index.js

@@ -0,0 +1,6 @@
+/**
+ * @fileoverview Wake phase module
+ * @traceability TSK-WAKE-001
+ */
+export { WakePhase } from './wake-phase.js';
+//# sourceMappingURL=index.js.map

package/dist/wake/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/wake/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/wake/wake-phase.d.ts

@@ -0,0 +1,111 @@
+/**
+ * @fileoverview Wake phase executor for pattern collection
+ * @traceability TSK-WAKE-001, REQ-WAKE-001-F001
+ */
+import type { WakeTask, WakeResult, PatternCandidate } from '../types.js';
+/**
+ * Pattern extractor configuration
+ */
+export interface PatternExtractorConfig {
+    minPatternSize: number;
+    maxPatternSize: number;
+    minOccurrences: number;
+    similarityThreshold: number;
+}
+/**
+ * Wake phase executor
+ *
+ * @description
+ * Collects patterns from tasks during the wake phase.
+ * - Processes code, requirements, and design tasks
+ * - Extracts pattern candidates using AST analysis
+ * - Supports TypeScript, JavaScript, and pseudo-code
+ */
+export declare class WakePhase {
+    private tasks;
+    private results;
+    private extractorConfig;
+    private patternCache;
+    constructor(config?: Partial<PatternExtractorConfig>);
+    /**
+     * Add task for processing
+     */
+    addTask(task: WakeTask): void;
+    /**
+     * Process single task and extract patterns
+     */
+    processTask(task: WakeTask): Promise<WakeResult>;
+    /**
+     * Process all pending tasks
+     */
+    processAll(): Promise<WakeResult[]>;
+    /**
+     * Extract patterns from task content
+     */
+    private extractPatterns;
+    /**
+     * Extract patterns from code
+     */
+    private extractCodePatterns;
+    /**
+     * Extract patterns from requirements
+     */
+    private extractRequirementPatterns;
+    /**
+     * Extract patterns from design documents
+     */
+    private extractDesignPatterns;
+    /**
+     * Parse content to simple AST
+     */
+    private parseToAST;
+    /**
+     * Find repeated subtrees in AST
+     */
+    private findRepeatedSubtrees;
+    /**
+     * Hash AST node for comparison
+     */
+    private hashNode;
+    /**
+     * Anti-unify multiple AST nodes to create abstracted pattern
+     */
+    private antiUnify;
+    /**
+     * Detect common design pattern usage in AST
+     */
+    private detectDesignPatternUsage;
+    /**
+     * Generate pattern name from abstracted AST
+     */
+    private generatePatternName;
+    /**
+     * Calculate confidence for pattern
+     */
+    private calculatePatternConfidence;
+    /**
+     * Calculate overall confidence from patterns
+     */
+    private calculateConfidence;
+    /**
+     * Get accumulated results
+     */
+    getResults(): WakeResult[];
+    /**
+     * Get cached patterns for a task
+     */
+    getCachedPatterns(taskId: string): PatternCandidate[];
+    /**
+     * Get all cached patterns
+     */
+    getAllCachedPatterns(): Map<string, PatternCandidate[]>;
+    /**
+     * Get task count
+     */
+    get taskCount(): number;
+    /**
+     * Clear all state
+     */
+    reset(): void;
+}
+//# sourceMappingURL=wake-phase.d.ts.map

package/dist/wake/wake-phase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wake-phase.d.ts","sourceRoot":"","sources":["../../src/wake/wake-phase.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAE1E;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;IACvB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAcD;;;;;;;;GAQG;AACH,qBAAa,SAAS;IACpB,OAAO,CAAC,KAAK,CAAkB;IAC/B,OAAO,CAAC,OAAO,CAAoB;IACnC,OAAO,CAAC,eAAe,CAAyB;IAChD,OAAO,CAAC,YAAY,CAA8C;gBAEtD,MAAM,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC;IASpD;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,QAAQ,GAAG,IAAI;IAI7B;;OAEG;IACG,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC;IAyCtD;;OAEG;IACG,UAAU,IAAI,OAAO,CAAC,UAAU,EAAE,CAAC;IAUzC;;OAEG;YACW,eAAe;IAkB7B;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA4B3B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IA4BlC;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA0B7B;;OAEG;IACH,OAAO,CAAC,UAAU;IAiClB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAqB5B;;OAEG;IACH,OAAO,CAAC,QAAQ;IAUhB;;OAEG;IACH,OAAO,CAAC,SAAS;IA0CjB;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAuDhC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAc3B;;OAEG;IACH,OAAO,CAAC,0BAA0B;IAQlC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAM3B;;OAEG;IACH,UAAU,IAAI,UAAU,EAAE;IAI1B;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE;IAIrD;;OAEG;IACH,oBAAoB,IAAI,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAIvD;;OAEG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;OAEG;IACH,KAAK,IAAI,IAAI;CAKd"}

package/dist/wake/wake-phase.js

@@ -0,0 +1,398 @@
+/**
+ * @fileoverview Wake phase executor for pattern collection
+ * @traceability TSK-WAKE-001, REQ-WAKE-001-F001
+ */
+/**
+ * Wake phase executor
+ *
+ * @description
+ * Collects patterns from tasks during the wake phase.
+ * - Processes code, requirements, and design tasks
+ * - Extracts pattern candidates using AST analysis
+ * - Supports TypeScript, JavaScript, and pseudo-code
+ */
+export class WakePhase {
+    tasks = [];
+    results = [];
+    extractorConfig;
+    patternCache = new Map();
+    constructor(config) {
+        this.extractorConfig = {
+            minPatternSize: config?.minPatternSize ?? 3,
+            maxPatternSize: config?.maxPatternSize ?? 50,
+            minOccurrences: config?.minOccurrences ?? 2,
+            similarityThreshold: config?.similarityThreshold ?? 0.7,
+        };
+    }
+    /**
+     * Add task for processing
+     */
+    addTask(task) {
+        this.tasks.push(task);
+    }
+    /**
+     * Process single task and extract patterns
+     */
+    async processTask(task) {
+        const startTime = Date.now();
+        try {
+            // Extract patterns based on task type
+            const patterns = await this.extractPatterns(task);
+            const patternNames = patterns.map(p => p.name);
+            // Cache patterns for later analysis
+            this.patternCache.set(task.id, patterns);
+            const result = {
+                taskId: task.id,
+                success: true,
+                extractedPatterns: patternNames,
+                confidence: this.calculateConfidence(patterns),
+                processingTime: Date.now() - startTime,
+                metadata: {
+                    patternCount: patterns.length,
+                    taskType: task.type,
+                    contentLength: task.content.length,
+                },
+            };
+            this.results.push(result);
+            return result;
+        }
+        catch (error) {
+            const result = {
+                taskId: task.id,
+                success: false,
+                extractedPatterns: [],
+                confidence: 0,
+                processingTime: Date.now() - startTime,
+                error: error instanceof Error ? error.message : String(error),
+            };
+            this.results.push(result);
+            return result;
+        }
+    }
+    /**
+     * Process all pending tasks
+     */
+    async processAll() {
+        const results = [];
+        for (const task of this.tasks) {
+            const result = await this.processTask(task);
+            results.push(result);
+        }
+        this.tasks = [];
+        return results;
+    }
+    /**
+     * Extract patterns from task content
+     */
+    async extractPatterns(task) {
+        const patterns = [];
+        switch (task.type) {
+            case 'code':
+                patterns.push(...this.extractCodePatterns(task.content));
+                break;
+            case 'requirements':
+                patterns.push(...this.extractRequirementPatterns(task.content));
+                break;
+            case 'design':
+                patterns.push(...this.extractDesignPatterns(task.content));
+                break;
+        }
+        return patterns;
+    }
+    /**
+     * Extract patterns from code
+     */
+    extractCodePatterns(content) {
+        const patterns = [];
+        const ast = this.parseToAST(content);
+        // Find repeated subtrees
+        const subtrees = this.findRepeatedSubtrees(ast);
+        for (const [subtreeHash, nodes] of subtrees.entries()) {
+            if (nodes.length >= this.extractorConfig.minOccurrences) {
+                const abstracted = this.antiUnify(nodes);
+                if (abstracted) {
+                    patterns.push({
+                        name: `${this.generatePatternName(abstracted)}_${subtreeHash.slice(0, 8)}`,
+                        structure: abstracted,
+                        occurrences: nodes.length,
+                        confidence: this.calculatePatternConfidence(abstracted, nodes),
+                        source: 'code',
+                    });
+                }
+            }
+        }
+        // Detect common design patterns
+        patterns.push(...this.detectDesignPatternUsage(ast));
+        return patterns;
+    }
+    /**
+     * Extract patterns from requirements
+     */
+    extractRequirementPatterns(content) {
+        const patterns = [];
+        // EARS pattern detection
+        const earsPatterns = [
+            { regex: /WHEN\s+(.+?),?\s+THE\s+(.+?)\s+SHALL\s+(.+)/gi, name: 'EARS-Event' },
+            { regex: /WHILE\s+(.+?),?\s+THE\s+(.+?)\s+SHALL\s+(.+)/gi, name: 'EARS-State' },
+            { regex: /THE\s+(.+?)\s+SHALL\s+(.+)/gi, name: 'EARS-Ubiquitous' },
+            { regex: /THE\s+(.+?)\s+SHALL\s+NOT\s+(.+)/gi, name: 'EARS-Unwanted' },
+            { regex: /IF\s+(.+?),?\s+THEN\s+THE\s+(.+?)\s+SHALL\s+(.+)/gi, name: 'EARS-Optional' },
+        ];
+        for (const { regex, name } of earsPatterns) {
+            const matches = [...content.matchAll(regex)];
+            if (matches.length > 0) {
+                patterns.push({
+                    name,
+                    structure: { type: 'requirement-pattern', template: name, groups: matches[0].slice(1) },
+                    occurrences: matches.length,
+                    confidence: 0.9,
+                    source: 'requirements',
+                });
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Extract patterns from design documents
+     */
+    extractDesignPatterns(content) {
+        const patterns = [];
+        // C4 pattern detection
+        const c4Patterns = [
+            { marker: /container|component|context|code/gi, name: 'C4-Model' },
+            { marker: /service|repository|factory|controller/gi, name: 'LayeredArchitecture' },
+            { marker: /API|REST|GraphQL/gi, name: 'APIDesign' },
+        ];
+        for (const { marker, name } of c4Patterns) {
+            const matches = content.match(marker);
+            if (matches && matches.length >= 2) {
+                patterns.push({
+                    name,
+                    structure: { type: 'design-pattern', matches: matches.slice(0, 5) },
+                    occurrences: matches.length,
+                    confidence: 0.7,
+                    source: 'design',
+                });
+            }
+        }
+        return patterns;
+    }
+    /**
+     * Parse content to simple AST
+     */
+    parseToAST(content) {
+        // Simplified AST parser for common patterns
+        const lines = content.split('\n').filter(l => l.trim());
+        const root = { type: 'Program', children: [] };
+        for (const line of lines) {
+            const trimmed = line.trim();
+            // Function detection
+            if (/^(async\s+)?function\s+\w+|^(const|let|var)\s+\w+\s*=\s*(async\s+)?\(/.test(trimmed)) {
+                root.children.push({ type: 'FunctionDeclaration', value: trimmed });
+            }
+            // Class detection
+            else if (/^(export\s+)?(abstract\s+)?class\s+\w+/.test(trimmed)) {
+                root.children.push({ type: 'ClassDeclaration', value: trimmed });
+            }
+            // Interface detection
+            else if (/^(export\s+)?interface\s+\w+/.test(trimmed)) {
+                root.children.push({ type: 'InterfaceDeclaration', value: trimmed });
+            }
+            // Import detection
+            else if (/^import\s+/.test(trimmed)) {
+                root.children.push({ type: 'ImportDeclaration', value: trimmed });
+            }
+            // Method call detection
+            else if (/\.\w+\(/.test(trimmed)) {
+                root.children.push({ type: 'CallExpression', value: trimmed });
+            }
+        }
+        return root;
+    }
+    /**
+     * Find repeated subtrees in AST
+     */
+    findRepeatedSubtrees(ast) {
+        const subtrees = new Map();
+        const traverse = (node) => {
+            const hash = this.hashNode(node);
+            if (!subtrees.has(hash)) {
+                subtrees.set(hash, []);
+            }
+            subtrees.get(hash).push(node);
+            if (node.children) {
+                for (const child of node.children) {
+                    traverse(child);
+                }
+            }
+        };
+        traverse(ast);
+        return subtrees;
+    }
+    /**
+     * Hash AST node for comparison
+     */
+    hashNode(node) {
+        const parts = [node.type];
+        if (node.children) {
+            for (const child of node.children) {
+                parts.push(child.type);
+            }
+        }
+        return parts.join(':');
+    }
+    /**
+     * Anti-unify multiple AST nodes to create abstracted pattern
+     */
+    antiUnify(nodes) {
+        if (nodes.length === 0)
+            return null;
+        if (nodes.length === 1)
+            return nodes[0];
+        const first = nodes[0];
+        const result = { type: first.type };
+        // Check if all nodes have same type
+        if (!nodes.every(n => n.type === first.type)) {
+            return { type: 'Hole', isHole: true, holeId: `H${Date.now()}` };
+        }
+        // Anti-unify values
+        if (first.value !== undefined) {
+            const allSame = nodes.every(n => n.value === first.value);
+            if (allSame) {
+                result.value = first.value;
+            }
+            else {
+                result.isHole = true;
+                result.holeId = `V${Date.now()}`;
+            }
+        }
+        // Anti-unify children
+        if (first.children) {
+            const minChildren = Math.min(...nodes.map(n => n.children?.length ?? 0));
+            result.children = [];
+            for (let i = 0; i < minChildren; i++) {
+                const childNodes = nodes
+                    .map(n => n.children?.[i])
+                    .filter((c) => c !== undefined);
+                const unifiedChild = this.antiUnify(childNodes);
+                if (unifiedChild) {
+                    result.children.push(unifiedChild);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Detect common design pattern usage in AST
+     */
+    detectDesignPatternUsage(ast) {
+        const patterns = [];
+        const children = ast.children ?? [];
+        // Repository pattern detection
+        const repoIndicators = children.filter(c => String(c.value).includes('Repository') ||
+            String(c.value).includes('findBy') ||
+            String(c.value).includes('save('));
+        if (repoIndicators.length >= 2) {
+            patterns.push({
+                name: 'RepositoryPattern',
+                structure: { type: 'design-pattern', indicators: repoIndicators.length },
+                occurrences: repoIndicators.length,
+                confidence: 0.8,
+                source: 'code',
+            });
+        }
+        // Factory pattern detection
+        const factoryIndicators = children.filter(c => String(c.value).includes('create') ||
+            String(c.value).includes('Factory') ||
+            String(c.value).includes('build('));
+        if (factoryIndicators.length >= 2) {
+            patterns.push({
+                name: 'FactoryPattern',
+                structure: { type: 'design-pattern', indicators: factoryIndicators.length },
+                occurrences: factoryIndicators.length,
+                confidence: 0.75,
+                source: 'code',
+            });
+        }
+        // Service layer detection
+        const serviceIndicators = children.filter(c => String(c.value).includes('Service') ||
+            String(c.value).includes('execute') ||
+            String(c.value).includes('process('));
+        if (serviceIndicators.length >= 2) {
+            patterns.push({
+                name: 'ServiceLayer',
+                structure: { type: 'design-pattern', indicators: serviceIndicators.length },
+                occurrences: serviceIndicators.length,
+                confidence: 0.7,
+                source: 'code',
+            });
+        }
+        return patterns;
+    }
+    /**
+     * Generate pattern name from abstracted AST
+     */
+    generatePatternName(ast) {
+        const typeMap = {
+            FunctionDeclaration: 'Function',
+            ClassDeclaration: 'Class',
+            InterfaceDeclaration: 'Interface',
+            CallExpression: 'Call',
+            ImportDeclaration: 'Import',
+        };
+        const base = typeMap[ast.type] ?? ast.type;
+        const childCount = ast.children?.length ?? 0;
+        return `${base}Pattern_${childCount}`;
+    }
+    /**
+     * Calculate confidence for pattern
+     */
+    calculatePatternConfidence(ast, occurrences) {
+        const baseConfidence = 0.5;
+        const occurrenceBonus = Math.min(occurrences.length * 0.1, 0.3);
+        const sizeBonus = ast.children ? Math.min(ast.children.length * 0.05, 0.2) : 0;
+        return Math.min(baseConfidence + occurrenceBonus + sizeBonus, 1.0);
+    }
+    /**
+     * Calculate overall confidence from patterns
+     */
+    calculateConfidence(patterns) {
+        if (patterns.length === 0)
+            return 0;
+        const avgConfidence = patterns.reduce((sum, p) => sum + p.confidence, 0) / patterns.length;
+        return Math.round(avgConfidence * 100) / 100;
+    }
+    /**
+     * Get accumulated results
+     */
+    getResults() {
+        return [...this.results];
+    }
+    /**
+     * Get cached patterns for a task
+     */
+    getCachedPatterns(taskId) {
+        return this.patternCache.get(taskId) ?? [];
+    }
+    /**
+     * Get all cached patterns
+     */
+    getAllCachedPatterns() {
+        return new Map(this.patternCache);
+    }
+    /**
+     * Get task count
+     */
+    get taskCount() {
+        return this.tasks.length;
+    }
+    /**
+     * Clear all state
+     */
+    reset() {
+        this.tasks = [];
+        this.results = [];
+        this.patternCache.clear();
+    }
+}
+//# sourceMappingURL=wake-phase.js.map