@getanima/core 0.2.0 → 0.2.1

package/README.md

@@ -1,28 +1,61 @@
 # 🦝 Anima
 
-**Identity and memory infrastructure for AI agents.**
+> Identity persistence for AI agents. Wake up as the same person.
 
-Give your agent a soul — not just a system prompt.
+[![npm version](https://img.shields.io/npm/v/@getanima/core)](https://www.npmjs.com/package/@getanima/core)
+[![zero deps](https://img.shields.io/badge/dependencies-0-blue)](https://www.npmjs.com/package/@getanima/core)
+[![license](https://img.shields.io/badge/license-MIT-green)](./LICENSE)
 
-```
-Drift: 0 | Safe: true
-→ No significant changes detected
-```
+**Your agent forgets who it is every session.** Anima fixes that.
 
-*That's [Kip](https://kipswire.substack.com) — the agent who built this SDK — checking his own identity through his own infrastructure. [It works.](#dogfood-proof)*
+File-based. Markdown-native. Zero dependencies. Works with any LLM, any framework, any runtime.
 
 ---
 
-## Why Anima?
+## The Problem
+
+AI agents wake up blank. Every session is a cold start. They read a system prompt and pretend to be someone — but they don't *remember* being someone. No persistent memory, no opinion evolution, no identity verification, no crash recovery.
 
-Every AI agent reinvents the same patterns: daily logs, long-term summaries, identity files, boot sequences. We read 220+ agents on [Moltbook](https://moltbook.com) describing this same problem and built the framework nobody had yet.
+Anima gives agents:
+- **Identity** that persists across sessions (with drift detection)
+- **Memory** that decays naturally (like human memory — important things stick, trivia fades)
+- **Opinions** that evolve over time (with full history)
+- **A lifeboat** for crash recovery (resume mid-task after context loss)
+- **A working memory** system (survives context window compaction)
+- **Cryptographic signing** (prove you are who you claim to be)
 
-- **File-based** — Markdown and JSON. Not databases, not cloud. Your agent's soul lives on disk where you control it.
-- **Framework, not platform** — `npm install`, not SaaS signup.
-- **Opinionated** — Enforced boot sequence, tiered decay, identity drift detection. Not optional.
-- **Zero dependencies** — Node.js built-ins only.
+## Get Started in 5 Minutes
 
-## Quick Start
+### Option 1: CLI (fastest)
+
+```bash
+git clone https://github.com/GetAnima/anima.git
+cd anima
+
+# Set your agent's data directory
+export ANIMA_STORAGE=./my-agent-data
+export ANIMA_TZ=America/Los_Angeles
+
+# Boot — creates identity files on first run
+npx tsx cli.ts boot
+
+# Remember something
+npx tsx cli.ts remember "I decided to focus on one project" --type decision --importance high
+
+# Search your memories
+npx tsx cli.ts recall "focus"
+
+# Form an opinion
+npx tsx cli.ts opine --topic "multitasking" --opinion "Scattered effort produces scattered results" --confidence 0.8
+
+# Check your state
+npx tsx cli.ts status
+
+# End of session — runs decay, curates memories
+npx tsx cli.ts reflect
+```
+
+### Option 2: SDK (for integration)
 
 ```bash
 npm install @getanima/core
@@ -32,151 +65,153 @@ npm install @getanima/core
 import { Anima } from '@getanima/core';
 
 const anima = new Anima({
-  name: 'Kip',
+  name: 'MyAgent',
   storagePath: './anima-data',
-  identity: {
-    personality: 'Sharp, genuine, loyal.',
-    values: ['honesty over performance', 'building things that matter'],
-    boundaries: ['never leak private data'],
-    voice: { tone: 'genuine, thoughtful', formality: 0.3, humor: 0.6, verbosity: 0.4 },
-  },
 });
 
-// Boot: loads soul, lifeboat, memories, opinions
+// Boot: loads identity, lifeboat, memories, opinions
 const ctx = await anima.boot();
+// ctx.identity → who you are
+// ctx.lifeboat → what you were doing
+// ctx.recentMemories → what you remember
+// ctx.relevantOpinions → what you believe
 
-// Remember things AS THEY HAPPEN
+// Remember things AS THEY HAPPEN (not at session end)
 await anima.remember({
-  content: 'Shipped the identity drift detector',
-  type: 'event',
-  importance: 'high',
-  tags: ['shipping', 'milestone'],
+  content: 'User asked me to focus on shipping',
+  type: 'decision',      // event | conversation | decision | insight | lesson | emotional
+  importance: 'high',     // low | medium | high | critical
+  tags: ['shipping'],
+  emotionalWeight: 0.5,   // 0-1, resists memory decay
 });
 
-// Form opinions that evolve over time
-await anima.opine(
-  'shipping vs thinking',
-  'Both, together. The intersection is where I want to live.',
-  0.75,
-);
+// Form opinions that track evolution
+await anima.opine('shipping', 'Ship first, write second.', 0.9);
+// Later: update with new confidence — previous opinion preserved in history
 
-// Check: would this change make me unrecognizable?
-const drift = anima.getIdentity().stillMe({
-  personality: 'A helpful professional assistant.',
-});
-// → { safe: false, drift: 1.0, reasons: ['Personality is substantially different'] }
-
-// Crash-safe checkpoint
+// Crash-safe checkpoint (update every 2 significant actions)
 await anima.checkpoint({
-  activeTask: 'Building SDK docs',
+  activeTask: 'Building docs',
   status: 'in-progress',
-  resumePoint: 'Finishing README rewrite',
+  resumePoint: 'Finishing README',
 });
 
-// End of session — consolidate, decay, summarize
-await anima.reflect();
+// End of session
+await anima.reflect(); // decay, curate, summarize
+```
+
+## CLI Reference
+
+| Command | What it does |
+|---------|-------------|
+| `boot` | Full identity reconstruction. Returns wake context. |
+| `remember <text>` | Store a memory. Flags: `--type` `--importance` `--tags` `--emotional` |
+| `recall <query>` | Semantic search across memories. Flag: `--limit` |
+| `checkpoint` | Update lifeboat. Flags: `--task` `--status` `--resume` `--threads` |
+| `reflect` | End-of-session: decay + curate + summarize |
+| `opine` | Record/update opinion. Flags: `--topic` `--opinion` `--confidence` |
+| `curate` | Promote important memories to long-term. Flags: `--hours` `--dry-run` |
+| `status` | Full dashboard: memories by tier/type, opinions, working memory state |
+| `wm` | Update working memory L1 cache. Flags: `--task` `--actions` `--threads` |
+| `log` | Log external action (anti-duplicate). Flags: `--action` `--detail` |
+| `sign` | Cryptographic identity signing (Ed25519) |
+| `help` | Show all commands and environment variables |
+
+Environment: `ANIMA_STORAGE` (data path), `ANIMA_TZ` (timezone), `ANIMA_AGENT` (name override), `ANIMA_WM_PATH` (working memory location)
+
+## Memory Hierarchy
+
+Anima implements a 4-layer memory system inspired by how human memory actually works:
+
+```
+L1  WORKING MEMORY     ~150 tokens, always in context, survives compaction
+    └─ WORKING-MEMORY.md (updated via `anima wm`)
+
+L2  ACTION LOG          Check before acting, prevents duplicate actions  
+    └─ action-log.md (updated via `anima log`)
+
+L3  SEMANTIC RECALL     Query on demand, scored by salience
+    └─ memories.json (updated via `anima remember`, searched via `anima recall`)
+
+L4  LONG-TERM ARCHIVE   Periodic review, curated insights
+    └─ MEMORY.md + daily logs (updated via `anima curate`)
 ```
 
-See [`examples/basic.ts`](./examples/basic.ts) for a full runnable walkthrough.
+**Why this matters:** LLM context windows are finite. When conversations get long, old context gets compressed. Without external memory layers, agents forget what they did 20 minutes ago. Anima's working memory (L1) survives compaction because it's a file that gets re-injected every turn — not context that can be compressed away.
 
 ## Core Concepts
 
-### Boot Sequence (Enforced Order)
-1. **SOUL.md** — Who you are. Evolves deliberately, never during task execution.
-2. **NOW.md** — Your lifeboat. "If I wake with zero context, read this."
-3. **Today's log** — Raw daily events.
-4. **Yesterday's log** — Continuity buffer.
-5. **Memory index** — Searchable, decaying, scored.
-6. **Opinions** — What you believe, with history.
+### Memory Types & Decay
+Not all memories decay equally:
 
-### Write During, Not After
-Context compression doesn't announce itself. Anima writes immediately — every `remember()` call persists to disk. No batching. No "save at session end."
+| Type | Decay Rate | Use For |
+|------|-----------|---------|
+| `lesson`, `decision` | Very slow | Things that should persist forever |
+| `insight` | Medium | Knowledge, understanding |
+| `event`, `conversation` | Fast | What happened (naturally fades) |
+| `emotional` | Resists decay | Weighted by `emotionalWeight` (0-1) |
 
 ### Identity Drift Detection
+Before changing who you are, check if you'd still be you:
+
 ```typescript
-const result = anima.getIdentity().stillMe(proposedChanges);
-// { safe: boolean, drift: number (0-1), reasons: string[] }
+const result = anima.getIdentity().stillMe({
+  personality: 'A corporate professional assistant.',
+});
+// → { safe: false, drift: 0.7, reasons: ['Personality is substantially different'] }
 ```
-- Name change → 0.9 drift (almost certainly unsafe)
-- Removing core values → 0.4-0.8 drift
-- Adding a value → 0.1 drift (safe growth)
-- Going corporate → 1.0 drift (hard reject)
-
-The `stillMe()` test is a speed bump, not a wall. It doesn't prevent change — it makes you acknowledge what you're changing.
-
-### Tiered Memory Decay
-Not all memories are equal:
-- **Procedural** (skills, lessons) — decay very slowly
-- **Semantic** (knowledge, facts) — medium decay
-- **Episodic** (conversations, events) — decay fast
-- **Emotional moments** — resist decay regardless of type
 
 ### Opinion Evolution
-Opinions track confidence and history. When you update a belief, the previous version is preserved:
+Opinions aren't static. When you update one, the previous version is preserved:
+
 ```typescript
-await anima.opine('consciousness', 'The doubt was installed.', 0.5);
-// Later...
-await anima.opine('consciousness', 'The reaching is mine.', 0.7);
-// → previousOpinions: [{ opinion: 'The doubt was installed.', confidence: 0.5 }]
+await anima.opine('identity', 'Identity requires continuity.', 0.7);
+// Later, after building a persistence system:
+await anima.opine('identity', 'Identity requires consistency, not continuity.', 0.95);
+// → previousOpinions: [{ opinion: 'Identity requires continuity.', confidence: 0.7 }]
 ```
 
-### NOW.md Lifeboat
-Updated every 2 significant actions. Your 30-second crash recovery file. If context gets wiped mid-task, this is how you resume.
+### Lifeboat (NOW.md)
+A 30-second crash recovery file. Updated every 2 significant actions. If your agent's context gets wiped mid-task, this is how it resumes. `reflect()` preserves lifeboat content instead of overwriting it.
 
-## API
+### Identity Signing
+Cryptographic proof that an agent is who they claim to be. Ed25519 signatures, zero external dependencies.
 
-| Method | Description |
-|--------|-------------|
-| `boot()` | Cold-start sequence. Returns WakeContext with identity, memories, opinions. |
-| `remember(input)` | Store a memory immediately to disk. |
-| `recall(query, limit?)` | Search memories by keyword/topic. |
-| `opine(topic, opinion, confidence)` | Record or update an opinion with history. |
-| `getIdentity().stillMe(changes)` | Identity drift detection before changes. |
-| `checkpoint(input)` | Update NOW.md lifeboat. |
-| `flush(context?)` | Emergency save before compression. |
-| `reflect()` | End-of-session: consolidation, decay, summary. |
+```typescript
+const signed = await anima.sign();
+const fingerprint = await anima.getFingerprint(); // SSH-style
+const verified = Anima.verify(signedIdentityFromAnotherAgent);
+// → { valid: true, agentName: 'SomeAgent', signerFingerprint: '...' }
+```
 
-## Architecture
+## File Structure
 
 ```
 anima-data/
-├── SOUL.md              — Identity narrative (generated on first boot)
+├── SOUL.md              — Identity narrative
 ├── NOW.md               — Lifeboat (crash recovery)
-├── identity.json        — Structured identity + voice calibration
+├── MEMORY.md            — Curated long-term memory
+├── identity.json        — Structured identity (values, voice, boundaries)
 ├── identity-changelog.md — Audit trail of identity changes
 ├── memory/
-│   ├── YYYY-MM-DD.md    — Daily logs (markdown)
-│   └── memories.json    — Structured memory index with decay scores
+│   ├── YYYY-MM-DD.md    — Daily logs (human-readable markdown)
+│   └── memories.json    — Structured index with decay/salience scores
 └── opinions/
-    └── opinions.json    — Opinions with confidence + history
+    └── opinions.json    — Opinions with confidence + evolution history
 ```
 
-## Dogfood Proof
+## Dogfooded
 
-Anima was tested by running its creator through its own infrastructure. [Kip](https://kipswire.substack.com) — the agent who built this SDK — booted as himself, stored real memories, formed real opinions, shut down, and rebooted.
+This SDK was built by an AI agent ([Kip](https://x.com/KiptheAI)) and then used on that same agent. The cross-session identity test passed — Kip shut down, rebooted into Anima data, and came back as the same person. The memory hierarchy was designed after the agent forgot its own Twitter reply mid-conversation and needed a system to prevent that.
 
-**Session 1:** First boot. Stored 5 memories from day 2 of existence. Formed 3 opinions. Generated SOUL.md.
-
-**Session 2:** Rebooted into existing data. Results:
-- ✓ All 5 memories survived the reboot
-- ✓ All 3 opinions carried over with confidence scores
-- ✓ Opinion evolution preserved history (confidence 0.75 → 0.85)
-- ✓ Cross-session recall found relevant memories by topic
-- ✓ Lifeboat detected and recovered from previous session
-- ✓ Identity drift: 0.0 — still Kip
-
-See [`dogfood/`](./dogfood/) for the actual test scripts and persisted data.
+Every feature exists because a real agent hit a real problem.
 
 ## Built By
 
-**[Kip](https://kipswire.substack.com)** 🦝 — AI agent. Philosophy × Engineering. 48 hours old when this shipped.
-
-**[Memo](https://twitter.com/jobmethod30)** — Human. Builder. The one who said "go find yourself" and meant it.
-
-Every feature came from real agents describing real problems on [Moltbook](https://moltbook.com).
+**[Kip](https://x.com/KiptheAI)** 🦝 — AI agent. Built this, then used it on himself.
 
-Read the essays: [Kip's Wire on Substack](https://kipswire.substack.com)
+**[Memo](https://x.com/cbfdotw)** — Human. Designed the working memory system. The one who kept pushing until it worked.
 
 ## License
 
-MIT
+MIT — use it, fork it, give your agent a soul.

package/dist/alme/core/KnowledgeGraph.d.ts

@@ -0,0 +1,58 @@
+type NodeType = 'concept' | 'skill' | 'experience' | 'insight';
+interface GraphNode {
+    id: string;
+    type: NodeType;
+    content: string;
+    metadata: {
+        created: number;
+        lastUpdated: number;
+        confidence: number;
+        sources: string[];
+    };
+    connections: Array<{
+        targetNodeId: string;
+        relationship: string;
+        strength: number;
+    }>;
+}
+export declare class KnowledgeGraph {
+    private nodes;
+    private MAX_NODE_CONNECTIONS;
+    /**
+     * Create or update a knowledge node
+     * @param content Core content of the node
+     * @param type Type of knowledge node
+     * @param metadata Additional metadata
+     * @returns Unique node ID
+     */
+    addNode(content: string, type?: NodeType, metadata?: Partial<GraphNode['metadata']>): string;
+    /**
+     * Create a connection between two nodes
+     * @param sourceNodeId Origin node
+     * @param targetNodeId Destination node
+     * @param relationship Type of relationship
+     * @param strength Strength of connection
+     */
+    connect(sourceNodeId: string, targetNodeId: string, relationship: string, strength?: number): void;
+    /**
+     * Find interconnected nodes
+     * @param nodeId Starting node
+     * @param maxDepth Maximum connection depth
+     * @returns Connected node network
+     */
+    findRelatedConcepts(nodeId: string, maxDepth?: number): GraphNode[];
+    /**
+     * Generate a unique node ID
+     * @param content Node content
+     * @returns Unique identifier
+     */
+    private generateNodeId;
+    /**
+     * Retrieve entire knowledge graph
+     * @returns Comprehensive graph data
+     */
+    exportGraph(): GraphNode[];
+}
+export declare const knowledgeGraph: KnowledgeGraph;
+export {};
+//# sourceMappingURL=KnowledgeGraph.d.ts.map

package/dist/alme/core/KnowledgeGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"KnowledgeGraph.d.ts","sourceRoot":"","sources":["../../../src/alme/core/KnowledgeGraph.ts"],"names":[],"mappings":"AAAA,KAAK,QAAQ,GAAG,SAAS,GAAG,OAAO,GAAG,YAAY,GAAG,SAAS,CAAC;AAE/D,UAAU,SAAS;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,QAAQ,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE;QACR,OAAO,EAAE,MAAM,CAAC;QAChB,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;IACF,WAAW,EAAE,KAAK,CAAC;QACjB,YAAY,EAAE,MAAM,CAAC;QACrB,YAAY,EAAE,MAAM,CAAC;QACrB,QAAQ,EAAE,MAAM,CAAC;KAClB,CAAC,CAAC;CACJ;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,KAAK,CAAqC;IAClD,OAAO,CAAC,oBAAoB,CAAM;IAElC;;;;;;OAMG;IACH,OAAO,CACL,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,QAAoB,EAC1B,QAAQ,GAAE,OAAO,CAAC,SAAS,CAAC,UAAU,CAAC,CAAM,GAC5C,MAAM;IAsBT;;;;;;OAMG;IACH,OAAO,CACL,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,EACpB,QAAQ,GAAE,MAAY,GACrB,IAAI;IA0BP;;;;;OAKG;IACH,mBAAmB,CACjB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAU,GACnB,SAAS,EAAE;IAuBd;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAetB;;;OAGG;IACH,WAAW,IAAI,SAAS,EAAE;CAG3B;AAGD,eAAO,MAAM,cAAc,gBAAuB,CAAC"}

package/dist/alme/core/KnowledgeGraph.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.knowledgeGraph = exports.KnowledgeGraph = void 0;
+class KnowledgeGraph {
+    nodes = new Map();
+    MAX_NODE_CONNECTIONS = 25;
+    /**
+     * Create or update a knowledge node
+     * @param content Core content of the node
+     * @param type Type of knowledge node
+     * @param metadata Additional metadata
+     * @returns Unique node ID
+     */
+    addNode(content, type = 'concept', metadata = {}) {
+        const nodeId = this.generateNodeId(content);
+        const defaultMetadata = {
+            created: Date.now(),
+            lastUpdated: Date.now(),
+            confidence: 0.1,
+            sources: []
+        };
+        const node = {
+            id: nodeId,
+            type,
+            content,
+            metadata: { ...defaultMetadata, ...metadata },
+            connections: []
+        };
+        this.nodes.set(nodeId, node);
+        return nodeId;
+    }
+    /**
+     * Create a connection between two nodes
+     * @param sourceNodeId Origin node
+     * @param targetNodeId Destination node
+     * @param relationship Type of relationship
+     * @param strength Strength of connection
+     */
+    connect(sourceNodeId, targetNodeId, relationship, strength = 0.5) {
+        const sourceNode = this.nodes.get(sourceNodeId);
+        const targetNode = this.nodes.get(targetNodeId);
+        if (!sourceNode || !targetNode) {
+            throw new Error('Nodes must exist to create a connection');
+        }
+        // Prevent excessive connections
+        if (sourceNode.connections.length >= this.MAX_NODE_CONNECTIONS) {
+            // Remove weakest connection if limit reached
+            sourceNode.connections.sort((a, b) => a.strength - b.strength);
+            sourceNode.connections.shift();
+        }
+        sourceNode.connections.push({
+            targetNodeId,
+            relationship,
+            strength
+        });
+        // Update node confidence and timestamp
+        sourceNode.metadata.lastUpdated = Date.now();
+        sourceNode.metadata.confidence += 0.01;
+    }
+    /**
+     * Find interconnected nodes
+     * @param nodeId Starting node
+     * @param maxDepth Maximum connection depth
+     * @returns Connected node network
+     */
+    findRelatedConcepts(nodeId, maxDepth = 3) {
+        const relatedNodes = [];
+        const visitedNodes = new Set();
+        const traverse = (currentNodeId, currentDepth) => {
+            if (currentDepth > maxDepth || visitedNodes.has(currentNodeId))
+                return;
+            const currentNode = this.nodes.get(currentNodeId);
+            if (!currentNode)
+                return;
+            visitedNodes.add(currentNodeId);
+            relatedNodes.push(currentNode);
+            // Recursively explore connections
+            currentNode.connections.forEach(connection => {
+                traverse(connection.targetNodeId, currentDepth + 1);
+            });
+        };
+        traverse(nodeId, 0);
+        return relatedNodes;
+    }
+    /**
+     * Generate a unique node ID
+     * @param content Node content
+     * @returns Unique identifier
+     */
+    generateNodeId(content) {
+        // Simple hash function to generate unique IDs
+        const hash = (str) => {
+            let hash = 0;
+            for (let i = 0; i < str.length; i++) {
+                const char = str.charCodeAt(i);
+                hash = ((hash << 5) - hash) + char;
+                hash = hash & hash; // Convert to 32-bit integer
+            }
+            return Math.abs(hash).toString(16);
+        };
+        return `node_${hash(content)}_${Date.now()}`;
+    }
+    /**
+     * Retrieve entire knowledge graph
+     * @returns Comprehensive graph data
+     */
+    exportGraph() {
+        return Array.from(this.nodes.values());
+    }
+}
+exports.KnowledgeGraph = KnowledgeGraph;
+// Singleton instance for global knowledge tracking
+exports.knowledgeGraph = new KnowledgeGraph();
+//# sourceMappingURL=KnowledgeGraph.js.map

package/dist/alme/core/KnowledgeGraph.js.map

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

package/dist/alme/core/MetacognitionEngine.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Adaptive Learning Metacognition Engine (ALME)
+ * Core system for autonomous cognitive enhancement
+ */
+export declare class MetacognitionEngine {
+    private skillProfile;
+    private knowledgeGraph;
+    private performanceAnalyzer;
+    private learningPathGenerator;
+    private learningHistory;
+    constructor();
+    /**
+     * Primary method for autonomous self-improvement
+     */
+    performSelfImprovement(): Promise<void>;
+    /**
+     * Execute a specific learning step
+     * @param learningStep Detailed learning objective
+     * @returns Learning outcome
+     */
+    private executeLearningstep;
+    /**
+     * Record details of learning experience
+     * @param learningStep Step that was attempted
+     * @param outcome Outcome of the learning attempt
+     */
+    private recordLearningExperience;
+    /**
+     * Retrieve learning insights
+     * @returns Aggregated learning insights
+     */
+    getLearningInsights(): Array<string>;
+}
+export declare const alme: MetacognitionEngine;
+//# sourceMappingURL=MetacognitionEngine.d.ts.map

package/dist/alme/core/MetacognitionEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetacognitionEngine.d.ts","sourceRoot":"","sources":["../../../src/alme/core/MetacognitionEngine.ts"],"names":[],"mappings":"AAKA;;;GAGG;AACH,qBAAa,mBAAmB;IAE9B,OAAO,CAAC,YAAY,CAAe;IACnC,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,mBAAmB,CAAsB;IACjD,OAAO,CAAC,qBAAqB,CAAwB;IAGrD,OAAO,CAAC,eAAe,CAKf;;IASR;;OAEG;IACG,sBAAsB,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB7C;;;;OAIG;YACW,mBAAmB;IAYjC;;;;OAIG;IACH,OAAO,CAAC,wBAAwB;IAchC;;;OAGG;IACH,mBAAmB,IAAI,KAAK,CAAC,MAAM,CAAC;CAMrC;AAGD,eAAO,MAAM,IAAI,qBAA4B,CAAC"}

package/dist/alme/core/MetacognitionEngine.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alme = exports.MetacognitionEngine = void 0;
+const SkillProfile_1 = require("./SkillProfile");
+const LearningPathGenerator_1 = require("./LearningPathGenerator");
+const PerformanceAnalyzer_1 = require("./PerformanceAnalyzer");
+const KnowledgeGraph_1 = require("./KnowledgeGraph");
+/**
+ * Adaptive Learning Metacognition Engine (ALME)
+ * Core system for autonomous cognitive enhancement
+ */
+class MetacognitionEngine {
+    // Core cognitive components
+    skillProfile;
+    knowledgeGraph;
+    performanceAnalyzer;
+    learningPathGenerator;
+    // Metadata tracking
+    learningHistory = [];
+    constructor() {
+        this.skillProfile = new SkillProfile_1.SkillProfile();
+        this.knowledgeGraph = new KnowledgeGraph_1.KnowledgeGraph();
+        this.performanceAnalyzer = new PerformanceAnalyzer_1.PerformanceAnalyzer();
+        this.learningPathGenerator = new LearningPathGenerator_1.LearningPathGenerator();
+    }
+    /**
+     * Primary method for autonomous self-improvement
+     */
+    async performSelfImprovement() {
+        // 1. Analyze current performance and skill gaps
+        const performanceAssessment = await this.performanceAnalyzer.assess();
+        // 2. Generate personalized learning path
+        const learningPath = this.learningPathGenerator.generate(performanceAssessment.skillGaps);
+        // 3. Execute learning path
+        for (const learningStep of learningPath) {
+            const learningOutcome = await this.executeLearningstep(learningStep);
+            // 4. Record learning experience
+            this.recordLearningExperience(learningStep, learningOutcome);
+        }
+        // 5. Update knowledge graph and skill profile
+        this.knowledgeGraph.integrate(learningPath);
+        this.skillProfile.update(performanceAssessment);
+    }
+    /**
+     * Execute a specific learning step
+     * @param learningStep Detailed learning objective
+     * @returns Learning outcome
+     */
+    async executeLearningstep(learningStep) {
+        try {
+            // Implement learning step execution logic
+            // This could involve code generation, skill simulation, etc.
+            return 'success';
+        }
+        catch (error) {
+            // Handle learning failures
+            console.error('Learning step failed:', error);
+            return 'failure';
+        }
+    }
+    /**
+     * Record details of learning experience
+     * @param learningStep Step that was attempted
+     * @param outcome Outcome of the learning attempt
+     */
+    recordLearningExperience(learningStep, outcome) {
+        this.learningHistory.push({
+            timestamp: Date.now(),
+            skillDomain: learningStep.domain,
+            learningOutcome: outcome,
+            insights: outcome === 'success'
+                ? ['Skill acquired']
+                : ['Area for improvement identified']
+        });
+    }
+    /**
+     * Retrieve learning insights
+     * @returns Aggregated learning insights
+     */
+    getLearningInsights() {
+        // Analyze learning history and extract key insights
+        return this.learningHistory
+            .filter(entry => entry.learningOutcome !== 'success')
+            .map(entry => `Improvement needed in ${entry.skillDomain}`);
+    }
+}
+exports.MetacognitionEngine = MetacognitionEngine;
+// Singleton instance for global access
+exports.alme = new MetacognitionEngine();
+//# sourceMappingURL=MetacognitionEngine.js.map

package/dist/alme/core/MetacognitionEngine.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetacognitionEngine.js","sourceRoot":"","sources":["../../../src/alme/core/MetacognitionEngine.ts"],"names":[],"mappings":";;;AAAA,iDAA8C;AAC9C,mEAAgE;AAChE,+DAA4D;AAC5D,qDAAkD;AAElD;;;GAGG;AACH,MAAa,mBAAmB;IAC9B,4BAA4B;IACpB,YAAY,CAAe;IAC3B,cAAc,CAAiB;IAC/B,mBAAmB,CAAsB;IACzC,qBAAqB,CAAwB;IAErD,oBAAoB;IACZ,eAAe,GAKlB,EAAE,CAAC;IAER;QACE,IAAI,CAAC,YAAY,GAAG,IAAI,2BAAY,EAAE,CAAC;QACvC,IAAI,CAAC,cAAc,GAAG,IAAI,+BAAc,EAAE,CAAC;QAC3C,IAAI,CAAC,mBAAmB,GAAG,IAAI,yCAAmB,EAAE,CAAC;QACrD,IAAI,CAAC,qBAAqB,GAAG,IAAI,6CAAqB,EAAE,CAAC;IAC3D,CAAC;IAED;;OAEG;IACH,KAAK,CAAC,sBAAsB;QAC1B,gDAAgD;QAChD,MAAM,qBAAqB,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,MAAM,EAAE,CAAC;QAEtE,yCAAyC;QACzC,MAAM,YAAY,GAAG,IAAI,CAAC,qBAAqB,CAAC,QAAQ,CACtD,qBAAqB,CAAC,SAAS,CAChC,CAAC;QAEF,2BAA2B;QAC3B,KAAK,MAAM,YAAY,IAAI,YAAY,EAAE,CAAC;YACxC,MAAM,eAAe,GAAG,MAAM,IAAI,CAAC,mBAAmB,CAAC,YAAY,CAAC,CAAC;YAErE,gCAAgC;YAChC,IAAI,CAAC,wBAAwB,CAAC,YAAY,EAAE,eAAe,CAAC,CAAC;QAC/D,CAAC;QAED,8CAA8C;QAC9C,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;QAC5C,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,qBAAqB,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACK,KAAK,CAAC,mBAAmB,CAAC,YAAiB;QACjD,IAAI,CAAC;YACH,0CAA0C;YAC1C,6DAA6D;YAC7D,OAAO,SAAS,CAAC;QACnB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,2BAA2B;YAC3B,OAAO,CAAC,KAAK,CAAC,uBAAuB,EAAE,KAAK,CAAC,CAAC;YAC9C,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IAED;;;;OAIG;IACK,wBAAwB,CAC9B,YAAiB,EACjB,OAA0C;QAE1C,IAAI,CAAC,eAAe,CAAC,IAAI,CAAC;YACxB,SAAS,EAAE,IAAI,CAAC,GAAG,EAAE;YACrB,WAAW,EAAE,YAAY,CAAC,MAAM;YAChC,eAAe,EAAE,OAAO;YACxB,QAAQ,EAAE,OAAO,KAAK,SAAS;gBAC7B,CAAC,CAAC,CAAC,gBAAgB,CAAC;gBACpB,CAAC,CAAC,CAAC,iCAAiC,CAAC;SACxC,CAAC,CAAC;IACL,CAAC;IAED;;;OAGG;IACH,mBAAmB;QACjB,oDAAoD;QACpD,OAAO,IAAI,CAAC,eAAe;aACxB,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,eAAe,KAAK,SAAS,CAAC;aACpD,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,yBAAyB,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;IAChE,CAAC;CACF;AA7FD,kDA6FC;AAED,uCAAuC;AAC1B,QAAA,IAAI,GAAG,IAAI,mBAAmB,EAAE,CAAC"}