@holoscript/framework 6.0.3

package/dist/learning/index.cjs

@@ -0,0 +1,219 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/learning/index.ts
+var learning_exports = {};
+__export(learning_exports, {
+  MemoryConsolidator: () => MemoryConsolidator,
+  MemoryScorer: () => MemoryScorer,
+  ProceduralCompiler: () => ProceduralCompiler,
+  SemanticClusterer: () => SemanticClusterer
+});
+module.exports = __toCommonJS(learning_exports);
+
+// 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;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryConsolidator,
+  MemoryScorer,
+  ProceduralCompiler,
+  SemanticClusterer
+});

package/dist/learning/index.d.cts

@@ -0,0 +1,104 @@
+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.d.ts

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,189 @@
+// 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
+};