@holoscript/framework 6.0.3 → 6.0.4

package/dist/learning/index.d.ts

@@ -1,104 +0,0 @@
-interface EpisodicMemory {
-    id: string;
-    timestamp: number;
-    action: string;
-    outcome: string;
-    entitiesInvolved: string[];
-    semanticVector?: number[];
-}
-interface SemanticFact {
-    id: string;
-    fact: string;
-    confidence: number;
-    sourceEpisodes: string[];
-}
-/**
- * MemoryConsolidator
- *
- * Compresses raw episodic events into structured semantic facts
- * via idle background cycles, mirroring human sleep consolidation.
- */
-declare class MemoryConsolidator {
-    /**
-     * Identifies conceptually similar episodic memories based on shared entities and actions.
-     */
-    private static clusterEpisodes;
-    /**
-     * Mocks an LLM-based summarization pass converting a cluster of raw events
-     * into a single concrete semantic truth.
-     */
-    private static summarizeCluster;
-    /**
-     * Executes the background consolidation pass.
-     * Takes raw episodes, clusters them, extracts truths, and returns the facts
-     * while reporting which raw episodes can be safely garbage collected.
-     */
-    static compressEpisodes(rawEpisodes: EpisodicMemory[]): {
-        newFacts: SemanticFact[];
-        prunedEpisodes: string[];
-    };
-}
-
-/**
- * MemoryScorer
- *
- * Generates an 'importance' dimensional scalar for Episodic memories.
- * Allows the aggregation engine to aggressively prune trivial loops (like 'Idle')
- * and permanently archive high-value bounds (like 'Combat' or 'Crafting').
- */
-interface EpisodicEvent {
-    agentId: string;
-    timestamp: number;
-    action: string;
-    context: Record<string, any>;
-    outcome: string;
-}
-declare class MemoryScorer {
-    /**
-     * Scores an event from -100 (Absolute Noise) to 100 (Critical Experience).
-     */
-    static computeImportance(event: EpisodicEvent): number;
-    /**
-     * Filters arrays natively discarding negative arrays
-     */
-    static cullLowImportance(events: EpisodicEvent[], threshold?: number): EpisodicEvent[];
-}
-
-interface ProceduralSkill {
-    id: string;
-    name: string;
-    description?: string;
-    code?: string;
-}
-/**
- * ProceduralCompiler
- *
- * Takes JSON-based AI logic trees extracted from temporal LLM generation natively
- * and compiles them strictly down into raw executable `.holo` syntax bounds.
- */
-declare class ProceduralCompiler {
-    /**
-     * Translates an Abstract Skill representation into native text executing within the VM.
-     */
-    static compile(skill: ProceduralSkill): string;
-}
-
-/**
- * SemanticClusterer
- *
- * Compresses raw temporal Episodic buffers into distilled arrays.
- * Native distillation drops repeating trivial structures mapping them into aggregated
- * density nodes explicitly reducing database storage loads across vector boundaries.
- */
-declare class SemanticClusterer {
-    /**
-     * Actively squash sequentially repeating abstract patterns mapping out semantic arrays.
-     */
-    static distill(events: EpisodicEvent[]): EpisodicEvent[];
-    /**
-     * Determines heuristic thresholds to squash logic natively offline without LLM.
-     */
-    private static isSimilar;
-}
-
-export { type EpisodicEvent, type EpisodicMemory, MemoryConsolidator, MemoryScorer, ProceduralCompiler, type ProceduralSkill, SemanticClusterer, type SemanticFact };

package/dist/learning/index.js

@@ -1,189 +0,0 @@
-// src/learning/MemoryConsolidator.ts
-var logger = { info: console.info, error: console.error };
-var MemoryConsolidator = class {
-  /**
-   * Identifies conceptually similar episodic memories based on shared entities and actions.
-   */
-  static clusterEpisodes(episodes) {
-    const clusters = {};
-    for (const ep of episodes) {
-      const key = `${ep.action}_${ep.entitiesInvolved[0] || "generic"}`;
-      if (!clusters[key]) clusters[key] = [];
-      clusters[key].push(ep);
-    }
-    return Object.values(clusters);
-  }
-  /**
-   * Mocks an LLM-based summarization pass converting a cluster of raw events
-   * into a single concrete semantic truth.
-   */
-  static summarizeCluster(cluster) {
-    if (cluster.length < 3) return null;
-    const sample = cluster[0];
-    const successCount = cluster.filter((ep) => ep.outcome.includes("success")).length;
-    const successRate = successCount / cluster.length;
-    let rule = "";
-    if (successRate > 0.7) {
-      rule = `${sample.action} applied to ${sample.entitiesInvolved[0]} is generally effective.`;
-    } else {
-      rule = `${sample.action} applied to ${sample.entitiesInvolved[0]} has high failure risk.`;
-    }
-    return {
-      id: `fact_${Date.now()}_${Math.random().toString(36).substring(7)}`,
-      fact: rule,
-      confidence: successRate,
-      sourceEpisodes: cluster.map((c) => c.id)
-    };
-  }
-  /**
-   * Executes the background consolidation pass.
-   * Takes raw episodes, clusters them, extracts truths, and returns the facts
-   * while reporting which raw episodes can be safely garbage collected.
-   */
-  static compressEpisodes(rawEpisodes) {
-    if (rawEpisodes.length < 5) return { newFacts: [], prunedEpisodes: [] };
-    logger.info(
-      `[Consolidation] Running idle memory compression on ${rawEpisodes.length} episodes.`
-    );
-    const clusters = this.clusterEpisodes(rawEpisodes);
-    const newFacts = [];
-    const prunedEpisodes = [];
-    for (const cluster of clusters) {
-      const fact = this.summarizeCluster(cluster);
-      if (fact) {
-        newFacts.push(fact);
-        prunedEpisodes.push(...fact.sourceEpisodes);
-      }
-    }
-    logger.info(
-      `[Consolidation] Distilled ${prunedEpisodes.length} raw episodes into ${newFacts.length} semantic facts.`
-    );
-    return { newFacts, prunedEpisodes };
-  }
-};
-
-// src/learning/MemoryScorer.ts
-var MemoryScorer = class {
-  /**
-   * Scores an event from -100 (Absolute Noise) to 100 (Critical Experience).
-   */
-  static computeImportance(event) {
-    let score = 0;
-    const action = event.action.toLowerCase();
-    if (action.includes("idle") || action.includes("wait") || action.includes("sleep")) {
-      score -= 50;
-    } else if (action.includes("move") || action.includes("look") || action.includes("walk")) {
-      score -= 10;
-    } else if (action.includes("craft") || action.includes("build") || action.includes("analyze")) {
-      score += 30;
-    } else if (action.includes("combat") || action.includes("attack") || action.includes("defense") || action.includes("damage")) {
-      score += 50;
-    }
-    const contextKeys = Object.keys(event.context || {}).length;
-    score += Math.min(20, contextKeys * 2);
-    const outcome = event.outcome.toLowerCase();
-    if (outcome.includes("failed") || outcome.includes("error")) {
-      score += 25;
-    } else if (outcome.includes("success") || outcome.includes("crafted") || outcome.includes("killed")) {
-      score += 25;
-    } else if (outcome.includes("nothing") || outcome.includes("none")) {
-      score -= 20;
-    }
-    return Math.max(-100, Math.min(100, score));
-  }
-  /**
-   * Filters arrays natively discarding negative arrays
-   */
-  static cullLowImportance(events, threshold = 0) {
-    return events.filter((e) => this.computeImportance(e) >= threshold);
-  }
-};
-
-// src/learning/ProceduralCompiler.ts
-var ProceduralCompiler = class {
-  /**
-   * Translates an Abstract Skill representation into native text executing within the VM.
-   */
-  static compile(skill) {
-    let compiled = `// Auto-generated skill: ${skill.name}
-`;
-    compiled += `// Desc: ${skill.description || "N/A"}
-
-`;
-    compiled += `agent ${skill.id.replace(/-/g, "_")} {
-`;
-    compiled += `  behavior execute() {
-`;
-    const codeBlock = skill.code || "";
-    const parsedLines = codeBlock.split("\n");
-    for (let line of parsedLines) {
-      line = line.trim();
-      if (!line) continue;
-      if (line.includes("move(") || line.includes("attack(") || line.includes("craft(")) {
-        compiled += `    ensure_safety() {
-      ${line}
-    }
-`;
-      } else {
-        compiled += `    ${line}
-`;
-      }
-    }
-    compiled += `  }
-`;
-    compiled += `}
-`;
-    return compiled;
-  }
-};
-
-// src/learning/SemanticClusterer.ts
-var SemanticClusterer = class {
-  /**
-   * Actively squash sequentially repeating abstract patterns mapping out semantic arrays.
-   */
-  static distill(events) {
-    if (events.length === 0) return [];
-    const distilled = [];
-    let currentSequence = { ...events[0] };
-    let repetitonCount = 1;
-    for (let i = 1; i < events.length; i++) {
-      const ev = events[i];
-      if (this.isSimilar(currentSequence, ev)) {
-        repetitonCount++;
-        currentSequence.outcome = `Repeated action successfully (${repetitonCount} times)`;
-        if (!currentSequence.context.timeSpanStarted) {
-          currentSequence.context.timeSpanStarted = currentSequence.timestamp;
-        }
-        currentSequence.context.timeSpanEnded = ev.timestamp;
-      } else {
-        if (repetitonCount > 1) {
-          currentSequence.action = `${currentSequence.action}_Aggregated`;
-        }
-        distilled.push({ ...currentSequence });
-        currentSequence = { ...ev };
-        repetitonCount = 1;
-      }
-    }
-    if (repetitonCount > 1) {
-      currentSequence.action = `${currentSequence.action}_Aggregated`;
-    }
-    distilled.push(currentSequence);
-    return distilled;
-  }
-  /**
-   * Determines heuristic thresholds to squash logic natively offline without LLM.
-   */
-  static isSimilar(a, b) {
-    if (a.action !== b.action) return false;
-    const aTarget = a.context?.target || a.context?.location;
-    const bTarget = b.context?.target || b.context?.location;
-    return aTarget === bTarget;
-  }
-};
-export {
-  MemoryConsolidator,
-  MemoryScorer,
-  ProceduralCompiler,
-  SemanticClusterer
-};