mark-improving-agent 2.2.0

package/dist/skills/dag.js

@@ -0,0 +1,181 @@
+function createSkillDAG() {
+    const nodes = new Map();
+    const adjacencyList = new Map();
+    const reverseAdjacencyList = new Map();
+    function getIncomingEdges(nodeId) {
+        return reverseAdjacencyList.get(nodeId) ?? new Set();
+    }
+    function getOutgoingEdges(nodeId) {
+        return adjacencyList.get(nodeId) ?? new Set();
+    }
+    // DFS-based cycle detection using three-color marking
+    function detectCycle() {
+        const color = new Map();
+        for (const id of nodes.keys()) {
+            color.set(id, 'white');
+        }
+        function dfs(nodeId) {
+            color.set(nodeId, 'grey');
+            const neighbors = getOutgoingEdges(nodeId);
+            for (const neighbor of neighbors) {
+                if (color.get(neighbor) === 'grey') {
+                    return true; // Back edge found - cycle detected
+                }
+                if (color.get(neighbor) === 'white' && dfs(neighbor)) {
+                    return true;
+                }
+            }
+            color.set(nodeId, 'black');
+            return false;
+        }
+        for (const id of nodes.keys()) {
+            if (color.get(id) === 'white') {
+                if (dfs(id)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    // Kahn's algorithm for topological sort
+    function topologicalSort() {
+        if (detectCycle()) {
+            throw new Error('Cycle detected in DAG - cannot compute topological order');
+        }
+        const inDegree = new Map();
+        const result = [];
+        const queue = [];
+        // Initialize in-degree counts
+        for (const id of nodes.keys()) {
+            inDegree.set(id, getIncomingEdges(id).size);
+        }
+        // Find all nodes with no incoming edges
+        for (const [id, degree] of inDegree) {
+            if (degree === 0) {
+                queue.push(id);
+            }
+        }
+        // Process nodes in topological order
+        while (queue.length > 0) {
+            const current = queue.shift();
+            result.push(current);
+            for (const neighbor of getOutgoingEdges(current)) {
+                const newDegree = (inDegree.get(neighbor) ?? 0) - 1;
+                inDegree.set(neighbor, newDegree);
+                if (newDegree === 0) {
+                    queue.push(neighbor);
+                }
+            }
+        }
+        // If we processed all nodes, return the result
+        if (result.length === nodes.size) {
+            return result;
+        }
+        // This shouldn't happen if cycle detection passed
+        throw new Error('Topological sort failed - possible cycle detected');
+    }
+    return {
+        addSkill(skill) {
+            nodes.set(skill.id, skill);
+            // Initialize adjacency lists for the node
+            if (!adjacencyList.has(skill.id)) {
+                adjacencyList.set(skill.id, new Set());
+            }
+            if (!reverseAdjacencyList.has(skill.id)) {
+                reverseAdjacencyList.set(skill.id, new Set());
+            }
+            // Validate and add dependencies
+            for (const depId of skill.deps) {
+                if (!nodes.has(depId)) {
+                    throw new Error(`Skill "${skill.id}" depends on non-existent skill "${depId}"`);
+                }
+                adjacencyList.get(skill.id).add(depId);
+                if (!reverseAdjacencyList.has(depId)) {
+                    reverseAdjacencyList.set(depId, new Set());
+                }
+                reverseAdjacencyList.get(depId).add(skill.id);
+            }
+        },
+        removeSkill(id) {
+            const skill = nodes.get(id);
+            if (!skill) {
+                return false;
+            }
+            // Remove this node from all adjacency lists
+            for (const depId of skill.deps) {
+                reverseAdjacencyList.get(depId)?.delete(id);
+            }
+            for (const [nodeId, neighbors] of adjacencyList) {
+                neighbors.delete(id);
+            }
+            adjacencyList.delete(id);
+            reverseAdjacencyList.delete(id);
+            return nodes.delete(id);
+        },
+        getExecutionOrder() {
+            return topologicalSort();
+        },
+        hasCycle() {
+            return detectCycle();
+        },
+        getReadySkills(completed) {
+            const ready = [];
+            for (const [id, skill] of nodes) {
+                if (completed.has(id)) {
+                    continue;
+                }
+                // Check if all dependencies are completed
+                const allDepsCompleted = skill.deps.every(depId => completed.has(depId));
+                if (allDepsCompleted) {
+                    ready.push(skill);
+                }
+            }
+            return ready;
+        },
+    };
+}
+function createDAGExecutor(registry, dag) {
+    return {
+        async execute(skillIds, input) {
+            const results = new Map();
+            const completed = new Set();
+            // Topologically sort the requested skills
+            const sorted = dag.getExecutionOrder().filter(id => skillIds.includes(id));
+            for (const skillId of sorted) {
+                const skill = registry.get(skillId);
+                if (!skill) {
+                    throw new Error(`Skill "${skillId}" not found in registry`);
+                }
+                // Get input for this skill (use result of last skill or initial input)
+                const skillInput = results.size > 0
+                    ? Array.from(results.values()).pop()
+                    : input;
+                try {
+                    const output = await skill.execute(skillInput);
+                    results.set(skillId, output);
+                    completed.add(skillId);
+                }
+                catch (error) {
+                    throw new Error(`Skill "${skillId}" execution failed: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+            return results;
+        },
+        async executeWithDeps(skillId, input) {
+            const skill = registry.get(skillId);
+            if (!skill) {
+                throw new Error(`Skill "${skillId}" not found in registry`);
+            }
+            // Get execution order for all dependencies
+            const executionOrder = dag.getExecutionOrder();
+            const skillsToExecute = executionOrder.filter(id => {
+                const s = registry.get(id);
+                return s && (id === skillId || skill.deps.includes(id) || executionOrder.indexOf(id) < executionOrder.indexOf(skillId));
+            });
+            const results = await this.execute(skillsToExecute, input);
+            return results.get(skillId);
+        },
+    };
+}
+export { createSkillDAG, createDAGExecutor };
+export default { createSkillDAG, createDAGExecutor };

package/dist/skills/index.js

@@ -0,0 +1,5 @@
+export * from './types.js';
+export * from './registry.js';
+export * from './dag.js';
+export { createSkillRegistry } from './registry.js';
+export { createSkillDAG, createDAGExecutor } from './dag.js';

package/dist/skills/registry.js

@@ -0,0 +1,40 @@
+function createSkillRegistry() {
+    const skills = new Map();
+    return {
+        register(skill) {
+            if (!skill.id) {
+                throw new Error('Skill must have an id');
+            }
+            if (!skill.name) {
+                throw new Error('Skill must have a name');
+            }
+            if (!skill.execute || typeof skill.execute !== 'function') {
+                throw new Error('Skill must have an execute function');
+            }
+            skills.set(skill.id, skill);
+        },
+        unregister(id) {
+            return skills.delete(id);
+        },
+        get(id) {
+            return skills.get(id);
+        },
+        findByTag(tag) {
+            const result = [];
+            for (const skill of skills.values()) {
+                if (skill.tags.includes(tag)) {
+                    result.push(skill);
+                }
+            }
+            return result;
+        },
+        list() {
+            return Array.from(skills.values());
+        },
+        has(id) {
+            return skills.has(id);
+        },
+    };
+}
+export { createSkillRegistry };
+export default createSkillRegistry;

package/dist/skills/types.js

@@ -0,0 +1 @@
+export {};

package/dist/storage/archive.js

@@ -0,0 +1,77 @@
+import { writeFile, readFile, mkdir, rename, readdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { dirname } from 'path';
+const TEMP_SUFFIX = '.tmp';
+const sleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+export async function ensureDir(dir) {
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+}
+export async function safeReadDir(dir) {
+    try {
+        if (!existsSync(dir)) {
+            return [];
+        }
+        const entries = await readdir(dir, { withFileTypes: true });
+        return entries
+            .filter(e => e.isFile())
+            .map(e => e.name);
+    }
+    catch {
+        return [];
+    }
+}
+export async function atomicWrite(path, content) {
+    const dir = dirname(path);
+    await ensureDir(dir);
+    const tmpPath = `${path}${TEMP_SUFFIX}`;
+    let attempts = 0;
+    const maxAttempts = 3;
+    while (attempts < maxAttempts) {
+        try {
+            await writeFile(tmpPath, content, 'utf-8');
+            await rename(tmpPath, path);
+            return;
+        }
+        catch (err) {
+            attempts++;
+            if (attempts >= maxAttempts) {
+                try {
+                    const { unlink } = await import('fs/promises');
+                    await unlink(tmpPath);
+                }
+                catch { }
+                throw err;
+            }
+            await sleep(10 * attempts);
+        }
+    }
+}
+export async function atomicWriteJSON(path, data) {
+    const content = JSON.stringify(data, null, 2);
+    await atomicWrite(path, content);
+}
+export function atomicWriteJSONSync(path, data) {
+    const content = JSON.stringify(data, null, 2);
+    const dir = dirname(path);
+    if (!existsSync(dir)) {
+        require('fs').mkdirSync(dir, { recursive: true });
+    }
+    const tmpPath = `${path}${TEMP_SUFFIX}`;
+    require('fs').writeFileSync(tmpPath, content, 'utf-8');
+    require('fs').renameSync(tmpPath, path);
+}
+export async function readJSON(path, fallback) {
+    try {
+        if (!existsSync(path)) {
+            return fallback;
+        }
+        const content = await readFile(path, 'utf-8');
+        const parsed = JSON.parse(content);
+        return parsed;
+    }
+    catch {
+        return fallback;
+    }
+}

package/dist/storage/checkpoint.js

@@ -0,0 +1,119 @@
+import { randomUUID } from 'crypto';
+import { atomicWriteJSON, readJSON, ensureDir } from './archive.js';
+import { VERSION } from '../version.js';
+import { createLogger } from '../utils/logger.js';
+const logger = createLogger('checkpoint');
+export function createCheckpointManager(dataDir, maxKeep = 10) {
+    const checkpointDir = `${dataDir}/checkpoints`;
+    const metaPath = `${checkpointDir}/meta.json`;
+    const meta = async () => {
+        return readJSON(metaPath, { checkpoints: [], latest: null });
+    };
+    const saveMeta = async (m) => {
+        await atomicWriteJSON(metaPath, m);
+    };
+    const getCheckpointPath = (id) => {
+        return `${checkpointDir}/checkpoint-${id}.json`;
+    };
+    return {
+        async save(label) {
+            await ensureDir(checkpointDir);
+            const m = await meta();
+            const id = randomUUID();
+            const timestamp = Date.now();
+            const checkpointData = {
+                id,
+                timestamp,
+                state: {
+                    version: VERSION,
+                    timestamp,
+                    data: {},
+                },
+            };
+            const size = JSON.stringify(checkpointData).length;
+            const info = {
+                id,
+                label: label ?? null,
+                timestamp,
+                size,
+                version: VERSION,
+            };
+            m.checkpoints.push(info);
+            m.latest = id;
+            if (m.checkpoints.length > maxKeep) {
+                const sorted = [...m.checkpoints].sort((a, b) => b.timestamp - a.timestamp);
+                const toRemove = sorted.slice(maxKeep);
+                for (const cp of toRemove) {
+                    try {
+                        const { unlink } = await import('fs/promises');
+                        await unlink(getCheckpointPath(cp.id));
+                    }
+                    catch { }
+                }
+                m.checkpoints = sorted.slice(0, maxKeep);
+            }
+            await atomicWriteJSON(getCheckpointPath(id), checkpointData);
+            await saveMeta(m);
+            logger.info(`Checkpoint saved: ${id}`, { label, size });
+            return id;
+        },
+        async load(id) {
+            const m = await meta();
+            const targetId = id ?? m.latest;
+            if (!targetId) {
+                return null;
+            }
+            const info = m.checkpoints.find(cp => cp.id === targetId);
+            if (!info) {
+                return null;
+            }
+            try {
+                const data = await readJSON(getCheckpointPath(targetId), {
+                    id: '',
+                    timestamp: 0,
+                    state: { version: '', timestamp: 0, data: {} },
+                });
+                return data.state;
+            }
+            catch {
+                logger.warn(`Failed to load checkpoint: ${targetId}`);
+                return null;
+            }
+        },
+        async list() {
+            const m = await meta();
+            return [...m.checkpoints].sort((a, b) => b.timestamp - a.timestamp);
+        },
+        async prune(keep = maxKeep) {
+            const m = await meta();
+            if (m.checkpoints.length <= keep) {
+                return 0;
+            }
+            const sorted = [...m.checkpoints].sort((a, b) => b.timestamp - a.timestamp);
+            const toRemove = sorted.slice(keep);
+            let removed = 0;
+            for (const cp of toRemove) {
+                try {
+                    const { unlink } = await import('fs/promises');
+                    await unlink(getCheckpointPath(cp.id));
+                    m.checkpoints = m.checkpoints.filter(c => c.id !== cp.id);
+                    removed++;
+                }
+                catch { }
+            }
+            if (m.latest && !m.checkpoints.find(c => c.id === m.latest)) {
+                m.latest = m.checkpoints[0]?.id ?? null;
+            }
+            await saveMeta(m);
+            logger.info(`Pruned ${removed} checkpoints, kept ${m.checkpoints.length}`);
+            return removed;
+        },
+        async getLatest() {
+            const m = await meta();
+            if (!m.latest) {
+                return null;
+            }
+            return m.checkpoints.find(cp => cp.id === m.latest) ?? null;
+        },
+    };
+}

package/dist/storage/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/config.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+const HeartFlowConfigSchema = z.object({
+    version: z.string(),
+    dataDir: z.string(),
+    logLevel: z.enum(['debug', 'info', 'warn', 'error']),
+    memory: z.object({
+        archiveThreshold: z.number().min(0).max(100),
+        maxEphemeral: z.number().positive(),
+        learnedTtlDays: z.number().positive(),
+    }),
+    evolution: z.object({
+        maxGoals: z.number().positive(),
+        cycleIntervalMs: z.number().positive(),
+    }),
+    checkpoint: z.object({
+        maxKeep: z.number().positive(),
+        intervalInteractions: z.number().positive(),
+    }),
+    identity: z.object({
+        driftThreshold: z.number().min(0).max(1),
+    }),
+    consciousness: z.object({
+        emotionDecay: z.number().min(0).max(1),
+        flowThreshold: z.number().min(0).max(1),
+    }),
+    agent: z.object({
+        maxContext: z.number().positive(),
+    }),
+});
+export const DEFAULT_CONFIG = {
+    version: '2.0.0',
+    dataDir: './data',
+    logLevel: 'info',
+    memory: {
+        archiveThreshold: 70,
+        maxEphemeral: 1000,
+        learnedTtlDays: 90,
+    },
+    evolution: {
+        maxGoals: 5,
+        cycleIntervalMs: 3600000,
+    },
+    checkpoint: {
+        maxKeep: 10,
+        intervalInteractions: 100,
+    },
+    identity: {
+        driftThreshold: 0.15,
+    },
+    consciousness: {
+        emotionDecay: 0.95,
+        flowThreshold: 0.7,
+    },
+    agent: {
+        maxContext: 100000,
+    },
+};
+export function loadConfig() {
+    const configPath = process.env['HEARTFLOW_CONFIG_PATH'];
+    if (!configPath) {
+        return { ...DEFAULT_CONFIG };
+    }
+    try {
+        const fs = require('fs');
+        const fileContent = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(fileContent);
+        return validateConfig(parsed);
+    }
+    catch {
+        console.warn(`Failed to load config from ${configPath}, using defaults`);
+        return { ...DEFAULT_CONFIG };
+    }
+}
+export function validateConfig(config) {
+    const result = HeartFlowConfigSchema.safeParse(config);
+    if (!result.success) {
+        const errors = result.error.issues.map(i => `${i.path.join('.')}: ${i.message}`).join(', ');
+        throw new Error(`Invalid configuration: ${errors}`);
+    }
+    return result.data;
+}

package/dist/utils/logger.js

@@ -0,0 +1,49 @@
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+const currentLevel = () => {
+    const envLevel = process.env['LOG_LEVEL'];
+    return envLevel && LOG_LEVELS[envLevel] !== undefined ? envLevel : 'info';
+};
+const formatTimestamp = () => {
+    return new Date().toISOString();
+};
+const formatMessage = (level, name, message, ctx) => {
+    const timestamp = formatTimestamp();
+    const levelStr = level.toUpperCase().padEnd(5, ' ');
+    const nameStr = `\x1b[34m${name}\x1b[0m`;
+    const ctxStr = ctx ? ` ${JSON.stringify(ctx)}` : '';
+    return `${timestamp} ${levelStr} ${nameStr} ${message}${ctxStr}`;
+};
+const shouldLog = (level) => {
+    return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel()];
+};
+export const createLogger = (name, level) => {
+    const effectiveLevel = level ?? currentLevel();
+    return {
+        debug(message, ctx) {
+            if (shouldLog('debug')) {
+                console.debug(formatMessage('debug', name, message, ctx));
+            }
+        },
+        info(message, ctx) {
+            if (shouldLog('info')) {
+                console.info(formatMessage('info', name, message, ctx));
+            }
+        },
+        warn(message, ctx) {
+            if (shouldLog('warn')) {
+                console.warn(formatMessage('warn', name, message, ctx));
+            }
+        },
+        error(message, ctx) {
+            if (shouldLog('error')) {
+                console.error(formatMessage('error', name, message, ctx));
+            }
+        },
+    };
+};
+export const DEFAULT_LOGGER = createLogger('mark-improving-agent');

package/dist/version.js

@@ -0,0 +1 @@
+export const VERSION = '2.2.0';

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "mark-improving-agent",
+  "version": "2.2.0",
+  "description": "Self-evolving AI agent with permanent memory, identity continuity, and self-evolution — for AI agents that need to remember, learn, and evolve across sessions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "bin": {
+    "heartflow": "dist/cli/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node bin/cli.js",
+    "test": "vitest run",
+    "prepublish": "npm run build"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "identity",
+    "self-evolution",
+    "memory"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "events": "3.3.0",
+    "zod": "3.25.76"
+  },
+  "devDependencies": {
+    "@types/events": "3.0.0",
+    "@types/node": "22.19.19",
+    "typescript": "5.7.3",
+    "vitest": "4.1.6"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}