claude-flow
Version:
Ruflo - Enterprise AI agent orchestration for Claude Code. Deploy 60+ specialized agents in coordinated swarms with self-learning, fault-tolerant consensus, vector memory, and MCP integration
344 lines (294 loc) • 9.2 kB
text/typescript
/**
* Cognitive Kernel Bridge
*
* Bridge to cognitum-gate-kernel for cognitive computation including
* working memory, attention control, meta-cognition, and scaffolding.
*/
import type { WasmBridge, WasmModuleStatus, CognitiveConfig } from '../types.js';
import { CognitiveConfigSchema } from '../types.js';
/**
* Cognitive item in working memory
*/
export interface CognitiveItem {
id: string;
content: Float32Array;
salience: number;
decay: number;
associations: string[];
metadata?: Record<string, unknown>;
}
/**
* Attention state
*/
export interface AttentionState {
focus: string[];
breadth: number;
intensity: number;
distractors: string[];
}
/**
* Meta-cognitive assessment
*/
export interface MetaCognitiveAssessment {
confidence: number;
uncertainty: number;
knowledgeGaps: string[];
suggestedStrategies: string[];
cognitiveLoad: number;
}
/**
* Cognitive WASM module interface
*/
interface CognitiveModule {
// Working memory
store(item: CognitiveItem): boolean;
retrieve(id: string): CognitiveItem | null;
search(query: Float32Array, k: number): CognitiveItem[];
decay(deltaTime: number): void;
consolidate(): void;
// Attention control
focus(ids: string[]): AttentionState;
broaden(): AttentionState;
narrow(): AttentionState;
getAttentionState(): AttentionState;
// Meta-cognition
assess(): MetaCognitiveAssessment;
monitor(task: string): number;
regulate(strategy: string): void;
// Scaffolding
scaffold(task: string, difficulty: number): string[];
adapt(performance: number): void;
}
/**
* Cognitive Kernel Bridge implementation
*/
export class CognitiveBridge implements WasmBridge<CognitiveModule> {
readonly name = 'cognitum-gate-kernel';
readonly version = '0.1.0';
private _status: WasmModuleStatus = 'unloaded';
private _module: CognitiveModule | null = null;
private config: CognitiveConfig;
constructor(config?: Partial<CognitiveConfig>) {
this.config = CognitiveConfigSchema.parse(config ?? {});
}
get status(): WasmModuleStatus {
return this._status;
}
async init(): Promise<void> {
if (this._status === 'ready') return;
if (this._status === 'loading') return;
this._status = 'loading';
try {
const wasmModule = await import('@ruvector/cognitum-gate-kernel').catch(() => null);
if (wasmModule) {
this._module = wasmModule as unknown as CognitiveModule;
} else {
this._module = this.createMockModule();
}
this._status = 'ready';
} catch (error) {
this._status = 'error';
throw error;
}
}
async destroy(): Promise<void> {
this._module = null;
this._status = 'unloaded';
}
isReady(): boolean {
return this._status === 'ready';
}
getModule(): CognitiveModule | null {
return this._module;
}
/**
* Store item in working memory
*/
store(item: CognitiveItem): boolean {
if (!this._module) throw new Error('Cognitive module not initialized');
return this._module.store(item);
}
/**
* Retrieve item from working memory
*/
retrieve(id: string): CognitiveItem | null {
if (!this._module) throw new Error('Cognitive module not initialized');
return this._module.retrieve(id);
}
/**
* Search working memory
*/
search(query: Float32Array, k: number): CognitiveItem[] {
if (!this._module) throw new Error('Cognitive module not initialized');
return this._module.search(query, k);
}
/**
* Apply memory decay
*/
decay(deltaTime: number): void {
if (!this._module) throw new Error('Cognitive module not initialized');
this._module.decay(deltaTime);
}
/**
* Consolidate working memory to long-term
*/
consolidate(): void {
if (!this._module) throw new Error('Cognitive module not initialized');
this._module.consolidate();
}
/**
* Focus attention on specific items
*/
focus(ids: string[]): AttentionState {
if (!this._module) throw new Error('Cognitive module not initialized');
return this._module.focus(ids);
}
/**
* Perform meta-cognitive assessment
*/
assess(): MetaCognitiveAssessment {
if (!this._module) throw new Error('Cognitive module not initialized');
return this._module.assess();
}
/**
* Get scaffolding for task
*/
scaffold(task: string, difficulty: number): string[] {
if (!this._module) throw new Error('Cognitive module not initialized');
return this._module.scaffold(task, difficulty);
}
/**
* Create mock module for development
*/
private createMockModule(): CognitiveModule {
const workingMemory = new Map<string, CognitiveItem>();
let attentionState: AttentionState = {
focus: [],
breadth: 0.5,
intensity: 0.7,
distractors: [],
};
return {
store(item: CognitiveItem): boolean {
if (workingMemory.size >= 7) {
// Miller's law: 7 ± 2 items
// Remove lowest salience item
let lowestId = '';
let lowestSalience = Infinity;
for (const [id, stored] of workingMemory) {
if (stored.salience < lowestSalience) {
lowestSalience = stored.salience;
lowestId = id;
}
}
if (lowestId) workingMemory.delete(lowestId);
}
workingMemory.set(item.id, item);
return true;
},
retrieve(id: string): CognitiveItem | null {
const item = workingMemory.get(id);
if (item) {
item.salience = Math.min(1, item.salience + 0.1); // Boost on retrieval
}
return item || null;
},
search(query: Float32Array, k: number): CognitiveItem[] {
const results: Array<{ item: CognitiveItem; score: number }> = [];
for (const item of workingMemory.values()) {
let score = 0;
for (let i = 0; i < Math.min(query.length, item.content.length); i++) {
score += query[i] * item.content[i];
}
results.push({ item, score: score * item.salience });
}
results.sort((a, b) => b.score - a.score);
return results.slice(0, k).map(r => r.item);
},
decay(deltaTime: number): void {
const decayRate = 0.1 * deltaTime;
for (const [id, item] of workingMemory) {
item.salience *= 1 - decayRate * item.decay;
if (item.salience < 0.1) {
workingMemory.delete(id);
}
}
},
consolidate(): void {
// Mark high-salience items for long-term storage
for (const item of workingMemory.values()) {
if (item.salience > 0.8) {
item.metadata = { ...item.metadata, consolidated: true };
}
}
},
focus(ids: string[]): AttentionState {
attentionState = {
focus: ids,
breadth: 1 / Math.max(1, ids.length),
intensity: Math.min(1, 0.5 + ids.length * 0.1),
distractors: [],
};
return attentionState;
},
broaden(): AttentionState {
attentionState.breadth = Math.min(1, attentionState.breadth + 0.2);
attentionState.intensity = Math.max(0.3, attentionState.intensity - 0.1);
return attentionState;
},
narrow(): AttentionState {
attentionState.breadth = Math.max(0.1, attentionState.breadth - 0.2);
attentionState.intensity = Math.min(1, attentionState.intensity + 0.1);
return attentionState;
},
getAttentionState(): AttentionState {
return { ...attentionState };
},
assess(): MetaCognitiveAssessment {
const itemCount = workingMemory.size;
const avgSalience = Array.from(workingMemory.values())
.reduce((s, i) => s + i.salience, 0) / Math.max(1, itemCount);
return {
confidence: avgSalience,
uncertainty: 1 - avgSalience,
knowledgeGaps: [],
suggestedStrategies: itemCount > 5 ? ['consolidate', 'prioritize'] : ['explore'],
cognitiveLoad: itemCount / 7,
};
},
monitor(task: string): number {
return 0.7; // Mock performance score
},
regulate(strategy: string): void {
// Apply cognitive strategy
if (strategy === 'consolidate') {
this.consolidate();
} else if (strategy === 'focus') {
this.narrow();
}
},
scaffold(task: string, difficulty: number): string[] {
const steps: string[] = [];
const numSteps = Math.ceil(difficulty * 5);
for (let i = 1; i <= numSteps; i++) {
steps.push(`Step ${i}: Break down ${task} into smaller components`);
}
return steps;
},
adapt(performance: number): void {
// Adjust scaffolding based on performance
if (performance < 0.5) {
// Increase scaffolding
} else if (performance > 0.8) {
// Decrease scaffolding
}
},
};
}
}
/**
* Create a new cognitive bridge
*/
export function createCognitiveBridge(config?: Partial<CognitiveConfig>): CognitiveBridge {
return new CognitiveBridge(config);
}