@aitos/core 1.0.0 → 1.0.1

package/dist/runtime.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TelemetryStore = exports.AtomRegistryImpl = exports.Store = exports.AitosRuntime = void 0;
+class Store {
+    constructor() {
+        this.data = new Map();
+    }
+    get(key) {
+        return this.data.get(key);
+    }
+    set(key, value) {
+        this.data.set(key, value);
+    }
+    has(key) {
+        return this.data.has(key);
+    }
+    delete(key) {
+        this.data.delete(key);
+    }
+    clear() {
+        this.data.clear();
+    }
+}
+exports.Store = Store;
+class TelemetryStore {
+    constructor() {
+        this.atoms = new Map();
+    }
+    record(atom, graphName, duration, success) {
+        let entry = this.atoms.get(atom);
+        if (!entry) {
+            entry = { count: 0, totalDuration: 0, maxDuration: 0, errorCount: 0, lastCalled: 0, graphs: new Set() };
+            this.atoms.set(atom, entry);
+        }
+        entry.count++;
+        entry.totalDuration += duration;
+        if (duration > entry.maxDuration)
+            entry.maxDuration = duration;
+        if (!success)
+            entry.errorCount++;
+        entry.lastCalled = Date.now();
+        entry.graphs.add(graphName);
+    }
+    getStats() {
+        const result = [];
+        for (const [atom, data] of this.atoms) {
+            result.push({
+                atom,
+                count: data.count,
+                avgDuration: data.count > 0 ? Math.round(data.totalDuration / data.count) : 0,
+                maxDuration: data.maxDuration,
+                errorCount: data.errorCount,
+                errorRate: data.count > 0 ? Math.round((data.errorCount / data.count) * 10000) / 100 : 0,
+                lastCalled: data.lastCalled,
+                graphs: Array.from(data.graphs),
+            });
+        }
+        result.sort((a, b) => b.count - a.count);
+        return result;
+    }
+    reset() {
+        this.atoms.clear();
+    }
+}
+exports.TelemetryStore = TelemetryStore;
+class AtomRegistryImpl {
+    constructor() {
+        this.atoms = new Map();
+    }
+    register(atom) {
+        const key = `${atom.name}@${atom.version}`;
+        this.atoms.set(key, atom);
+        this.atoms.set(atom.name, atom);
+    }
+    get(name) {
+        return this.atoms.get(name);
+    }
+    has(name) {
+        return this.atoms.has(name);
+    }
+    list() {
+        const result = [];
+        const seen = new Set();
+        for (const [key, atom] of this.atoms.entries()) {
+            if (!seen.has(atom.name)) {
+                seen.add(atom.name);
+                result.push(atom.name);
+            }
+        }
+        return result;
+    }
+}
+exports.AtomRegistryImpl = AtomRegistryImpl;
+class AitosRuntime {
+    constructor() {
+        this.atoms = new Map();
+        this.telemetryStore = new TelemetryStore();
+        this.telemetryHistory = [];
+    }
+    register(atom) {
+        const key = `${atom.name}@${atom.version}`;
+        this.atoms.set(key, atom);
+        this.atoms.set(atom.name, atom);
+    }
+    validateGraph(graph) {
+        const errors = [];
+        this.validateGraphNodes(graph.nodes, graph.order, errors);
+        return { valid: errors.length === 0, errors: errors.map(e => JSON.stringify(e)) };
+    }
+    validateGraphNodes(nodes, order, errors, path = '', parentExecuted) {
+        const executed = parentExecuted ? new Set(parentExecuted) : new Set();
+        for (const nodeId of order) {
+            const node = nodes[nodeId];
+            if (!node) {
+                errors.push({
+                    node: path,
+                    code: 'NODE_NOT_FOUND',
+                    param: '',
+                    ref: nodeId,
+                    message: `Node "${nodeId}" not found in nodes`
+                });
+                continue;
+            }
+            const nodePath = path ? `${path}.${nodeId}` : nodeId;
+            if (!node.atom) {
+                errors.push({ node: nodePath, code: 'MISSING_ATOM', param: '', ref: '', message: 'Missing atom field' });
+                continue;
+            }
+            if (typeof node.atom !== 'string') {
+                errors.push({ node: nodePath, code: 'INVALID_ATOM_TYPE', param: '', ref: '', message: 'Atom must be a string' });
+                continue;
+            }
+            if (!this.atoms.has(node.atom)) {
+                errors.push({ node: nodePath, code: 'ATOM_NOT_FOUND', param: '', ref: '', message: `Atom "${node.atom}" not registered` });
+            }
+            this.validateGraphReferences(node, executed, errors, nodePath, nodes);
+            if (node.nodes && typeof node.nodes === 'object' && 'order' in node.nodes) {
+                const subGraph = node.nodes;
+                if (subGraph.nodes && subGraph.order) {
+                    this.validateGraphNodes(subGraph.nodes, subGraph.order, errors, `${nodePath}.nodes`, executed);
+                }
+            }
+            if (node.then && typeof node.then === 'object' && 'order' in node.then) {
+                const subGraph = node.then;
+                if (subGraph.nodes && subGraph.order) {
+                    this.validateGraphNodes(subGraph.nodes, subGraph.order, errors, `${nodePath}.then`, executed);
+                }
+            }
+            if (node.else && typeof node.else === 'object' && 'order' in node.else) {
+                const subGraph = node.else;
+                if (subGraph.nodes && subGraph.order) {
+                    this.validateGraphNodes(subGraph.nodes, subGraph.order, errors, `${nodePath}.else`, executed);
+                }
+            }
+            executed.add(nodeId);
+        }
+    }
+    validateGraphReferences(node, executed, errors, nodePath, nodes) {
+        for (const [key, value] of Object.entries(node)) {
+            if (['atom', 'nodes', 'then', 'else'].includes(key))
+                continue;
+            if (typeof value === 'string') {
+                const matches = value.matchAll(/\{\{(\w+)(?:\.(.+?))?\}\}/g);
+                for (const match of matches) {
+                    const refId = match[1];
+                    if (!executed.has(refId) && !nodes[refId]) {
+                        const suggestions = this.generateGraphSuggestions(executed, nodes);
+                        errors.push({
+                            node: nodePath,
+                            code: 'INVALID_REFERENCE',
+                            param: key,
+                            ref: refId,
+                            message: `Invalid reference {{${refId}}}: node not found or not yet executed`,
+                            suggestions
+                        });
+                    }
+                }
+            }
+        }
+    }
+    generateGraphSuggestions(executed, nodes) {
+        const suggestions = [];
+        for (const nodeId of executed) {
+            if (suggestions.length >= 5)
+                break;
+            const node = nodes[nodeId];
+            if (node) {
+                const atom = this.atoms.get(node.atom);
+                suggestions.push({
+                    id: nodeId,
+                    type: atom?.meta.output.type || 'unknown',
+                    source: node.atom
+                });
+            }
+        }
+        return suggestions;
+    }
+    async executeGraph(graph, context, outerScope, graphName) {
+        const results = outerScope ? { ...outerScope } : {};
+        const gName = graphName || 'unknown';
+        const previousScope = context.currentScope;
+        context.currentScope = results;
+        context.runtime = this;
+        for (const nodeId of graph.order) {
+            const node = graph.nodes[nodeId];
+            const input = this.resolveGraphInput(node, results, context);
+            const startTime = performance.now();
+            const result = await context.execute(node.atom, input);
+            const duration = Math.round(performance.now() - startTime);
+            this.telemetryStore.record(node.atom, gName, duration, result.success);
+            if (!result.success) {
+                context.currentScope = previousScope;
+                throw new Error(JSON.stringify({ node: nodeId, atom: node.atom, error: result.error }));
+            }
+            results[nodeId] = result.data;
+        }
+        context.currentScope = previousScope;
+        return results;
+    }
+    onSnapshot(callback) {
+        this.snapshotCallback = callback;
+    }
+    flushTelemetry() {
+        const stats = this.telemetryStore.getStats();
+        const snapshot = { timestamp: Date.now(), stats };
+        this.telemetryHistory.push(snapshot);
+        if (this.telemetryHistory.length > 100) {
+            this.telemetryHistory.shift();
+        }
+        this.snapshotCallback?.(snapshot);
+        return snapshot;
+    }
+    getTelemetryHistory() {
+        return this.telemetryHistory;
+    }
+    restoreTelemetryHistory(history) {
+        this.telemetryHistory = history.slice(-100);
+    }
+    resolveGraphInput(node, results, context) {
+        const resolved = {};
+        const SUBGRAPH_KEYS = new Set(['nodes', 'then', 'else']);
+        for (const [key, value] of Object.entries(node)) {
+            if (key === 'atom')
+                continue;
+            if (SUBGRAPH_KEYS.has(key)) {
+                resolved[key] = value;
+            }
+            else {
+                resolved[key] = this.resolveGraphValue(value, results, context);
+            }
+        }
+        return resolved;
+    }
+    resolveGraphValue(value, results, context) {
+        if (typeof value === 'string') {
+            const ESCAPE_PLACEHOLDER = '\x00ESCAPED_BRACE\x00';
+            let processedValue = value.replace(/\\{{/g, ESCAPE_PLACEHOLDER);
+            const match = processedValue.match(/^\{\{(\w+)(?:\.(.+?))?\}\}$/);
+            if (match) {
+                const nodeId = match[1];
+                const field = match[2];
+                let resolvedValue;
+                if (nodeId in results) {
+                    resolvedValue = results[nodeId];
+                }
+                else if (context.store.has(nodeId)) {
+                    resolvedValue = context.store.get(nodeId);
+                }
+                else {
+                    throw new Error(JSON.stringify({
+                        code: 'REFERENCE_NOT_FOUND',
+                        ref: nodeId,
+                        message: `Reference {{${nodeId}}} not found in current scope or store`,
+                        availableInScope: Object.keys(results),
+                        availableInStore: context.store.has(nodeId) ? [nodeId] : [],
+                        hint: 'Check if the reference is a node output or a store value.',
+                        fix: `Ensure the node "${nodeId}" is executed before this reference, or use { "atom": "set", "key": "${nodeId}", "value": ... } to store the value.`
+                    }));
+                }
+                if (field) {
+                    return this.getFieldValue(resolvedValue, field);
+                }
+                return resolvedValue;
+            }
+            const result = processedValue.replace(/\{\{(\w+)(?:\.(.+?))?\}\}/g, (_, nodeId, field) => {
+                let resolvedValue;
+                if (nodeId in results) {
+                    resolvedValue = results[nodeId];
+                }
+                else if (context.store.has(nodeId)) {
+                    resolvedValue = context.store.get(nodeId);
+                }
+                else {
+                    throw new Error(JSON.stringify({
+                        code: 'REFERENCE_NOT_FOUND',
+                        ref: nodeId,
+                        message: `Reference {{${nodeId}}} not found in current scope or store`,
+                        availableInScope: Object.keys(results),
+                        availableInStore: context.store.has(nodeId) ? [nodeId] : [],
+                        hint: 'Check if the reference is a node output or a store value.',
+                        fix: `Ensure the node "${nodeId}" is executed before this reference, or use { "atom": "set", "key": "${nodeId}", "value": ... } to store the value.`
+                    }));
+                }
+                if (field) {
+                    return this.getFieldValue(resolvedValue, field);
+                }
+                return resolvedValue;
+            });
+            return result.replace(new RegExp(ESCAPE_PLACEHOLDER, 'g'), '{{');
+        }
+        if (Array.isArray(value)) {
+            return value.map(item => this.resolveGraphValue(item, results, context));
+        }
+        if (typeof value === 'object' && value !== null) {
+            const resolved = {};
+            for (const [k, v] of Object.entries(value)) {
+                resolved[k] = this.resolveGraphValue(v, results, context);
+            }
+            return resolved;
+        }
+        return value;
+    }
+    getFieldValue(obj, field) {
+        const parts = field.split('.');
+        let current = obj;
+        for (const part of parts) {
+            if (current === undefined || current === null)
+                return undefined;
+            current = current[part];
+        }
+        return current;
+    }
+    listAtoms() {
+        const result = [];
+        const seen = new Set();
+        for (const [key, atom] of this.atoms.entries()) {
+            if (!seen.has(atom.name)) {
+                seen.add(atom.name);
+                result.push(atom);
+            }
+        }
+        return result;
+    }
+    getSkillSet() {
+        const atoms = this.listAtoms();
+        const registry = {
+            aitos: {
+                version: '1.0.0',
+                type: 'graph-instruction-set',
+            },
+            graph: {
+                format: {
+                    nodes: 'Record<nodeId, GraphNode>',
+                    order: 'string[] (execution order)'
+                },
+                example: {
+                    nodes: {
+                        getY: { atom: 'get', key: 'fruitY' },
+                        addFive: { atom: 'add', a: '{{getY}}', b: 5 },
+                        saveY: { atom: 'set', key: 'fruitY', value: '{{addFive}}' }
+                    },
+                    order: ['getY', 'addFive', 'saveY']
+                }
+            },
+            node: {
+                format: { atom: 'string', '...params': 'per atom.input' },
+                example: { atom: 'add', a: '{{otherNodeId}}', b: 1 }
+            },
+            ref: {
+                format: '{{nodeId}} or {{nodeId.field}}',
+                rules: [
+                    'Use nodeId to reference another node result',
+                    'nodeId must be defined in nodes and appear earlier in order',
+                    'Use {{nodeId.field}} to access nested properties',
+                    'References are resolved before execution'
+                ]
+            },
+            atoms: atoms.map(a => ({
+                name: a.name,
+                version: a.version,
+                input: a.meta.input,
+                output: a.meta.output,
+            })),
+            validation: {
+                description: 'Validation checks node references and atom existence',
+                errorFormat: {
+                    node: 'Node path',
+                    code: 'Error code',
+                    param: 'Parameter name',
+                    ref: 'Invalid reference',
+                    message: 'Error description',
+                    suggestions: [
+                        { id: 'Suggested nodeId', type: 'Output type', source: 'Atom name' }
+                    ]
+                }
+            }
+        };
+        return JSON.stringify(registry);
+    }
+    getTelemetryStats() {
+        return this.telemetryStore.getStats();
+    }
+    resetTelemetry() {
+        this.telemetryStore.reset();
+    }
+}
+exports.AitosRuntime = AitosRuntime;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runtime.js","sourceRoot":"","sources":["../src/runtime.ts"],"names":[],"mappings":"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","sourcesContent":["import { Atom, Context, Result, Graph, GraphNode, Scope, AtomRegistry, GraphValidationError, GraphSuggestion, Runtime, TelemetryStats, TelemetrySnapshot } from './types';\n\nclass Store {\n  private data: Map<string, any> = new Map();\n\n  get(key: string): any {\n    return this.data.get(key);\n  }\n\n  set(key: string, value: any): void {\n    this.data.set(key, value);\n  }\n\n  has(key: string): boolean {\n    return this.data.has(key);\n  }\n\n  delete(key: string): void {\n    this.data.delete(key);\n  }\n\n  clear(): void {\n    this.data.clear();\n  }\n}\n\nclass TelemetryStore {\n  private atoms: Map<string, {\n    count: number;\n    totalDuration: number;\n    maxDuration: number;\n    errorCount: number;\n    lastCalled: number;\n    graphs: Set<string>;\n  }> = new Map();\n\n  record(atom: string, graphName: string, duration: number, success: boolean): void {\n    let entry = this.atoms.get(atom);\n    if (!entry) {\n      entry = { count: 0, totalDuration: 0, maxDuration: 0, errorCount: 0, lastCalled: 0, graphs: new Set() };\n      this.atoms.set(atom, entry);\n    }\n    entry.count++;\n    entry.totalDuration += duration;\n    if (duration > entry.maxDuration) entry.maxDuration = duration;\n    if (!success) entry.errorCount++;\n    entry.lastCalled = Date.now();\n    entry.graphs.add(graphName);\n  }\n\n  getStats(): TelemetryStats[] {\n    const result: TelemetryStats[] = [];\n    for (const [atom, data] of this.atoms) {\n      result.push({\n        atom,\n        count: data.count,\n        avgDuration: data.count > 0 ? Math.round(data.totalDuration / data.count) : 0,\n        maxDuration: data.maxDuration,\n        errorCount: data.errorCount,\n        errorRate: data.count > 0 ? Math.round((data.errorCount / data.count) * 10000) / 100 : 0,\n        lastCalled: data.lastCalled,\n        graphs: Array.from(data.graphs),\n      });\n    }\n    result.sort((a, b) => b.count - a.count);\n    return result;\n  }\n\n  reset(): void {\n    this.atoms.clear();\n  }\n}\n\nclass AtomRegistryImpl implements AtomRegistry {\n  private atoms: Map<string, Atom> = new Map();\n\n  register(atom: Atom): void {\n    const key = `${atom.name}@${atom.version}`;\n    this.atoms.set(key, atom);\n    this.atoms.set(atom.name, atom);\n  }\n\n  get(name: string): Atom | undefined {\n    return this.atoms.get(name);\n  }\n\n  has(name: string): boolean {\n    return this.atoms.has(name);\n  }\n\n  list(): string[] {\n    const result: string[] = [];\n    const seen = new Set<string>();\n    \n    for (const [key, atom] of this.atoms.entries()) {\n      if (!seen.has(atom.name)) {\n        seen.add(atom.name);\n        result.push(atom.name);\n      }\n    }\n    \n    return result;\n  }\n}\n\nexport class AitosRuntime implements Runtime {\n  private atoms: Map<string, Atom> = new Map();\n  private telemetryStore: TelemetryStore = new TelemetryStore();\n  private telemetryHistory: TelemetrySnapshot[] = [];\n  private snapshotCallback?: (snapshot: TelemetrySnapshot) => void;\n\n  register(atom: Atom): void {\n    const key = `${atom.name}@${atom.version}`;\n    this.atoms.set(key, atom);\n    this.atoms.set(atom.name, atom);\n  }\n\n  validateGraph(graph: Graph): { valid: boolean; errors: string[] } {\n    const errors: GraphValidationError[] = [];\n    this.validateGraphNodes(graph.nodes, graph.order, errors);\n    return { valid: errors.length === 0, errors: errors.map(e => JSON.stringify(e)) };\n  }\n\n  private validateGraphNodes(nodes: Record<string, GraphNode>, order: string[], errors: GraphValidationError[], path: string = '', parentExecuted?: Set<string>): void {\n    const executed = parentExecuted ? new Set(parentExecuted) : new Set<string>();\n\n    for (const nodeId of order) {\n      const node = nodes[nodeId];\n      if (!node) {\n        errors.push({\n          node: path,\n          code: 'NODE_NOT_FOUND',\n          param: '',\n          ref: nodeId,\n          message: `Node \"${nodeId}\" not found in nodes`\n        });\n        continue;\n      }\n\n      const nodePath = path ? `${path}.${nodeId}` : nodeId;\n\n      if (!node.atom) {\n        errors.push({ node: nodePath, code: 'MISSING_ATOM', param: '', ref: '', message: 'Missing atom field' });\n        continue;\n      }\n\n      if (typeof node.atom !== 'string') {\n        errors.push({ node: nodePath, code: 'INVALID_ATOM_TYPE', param: '', ref: '', message: 'Atom must be a string' });\n        continue;\n      }\n\n      if (!this.atoms.has(node.atom)) {\n        errors.push({ node: nodePath, code: 'ATOM_NOT_FOUND', param: '', ref: '', message: `Atom \"${node.atom}\" not registered` });\n      }\n\n      this.validateGraphReferences(node, executed, errors, nodePath, nodes);\n\n      if (node.nodes && typeof node.nodes === 'object' && 'order' in node.nodes) {\n        const subGraph = node.nodes as Graph;\n        if (subGraph.nodes && subGraph.order) {\n          this.validateGraphNodes(subGraph.nodes, subGraph.order, errors, `${nodePath}.nodes`, executed);\n        }\n      }\n      if (node.then && typeof node.then === 'object' && 'order' in node.then) {\n        const subGraph = node.then as Graph;\n        if (subGraph.nodes && subGraph.order) {\n          this.validateGraphNodes(subGraph.nodes, subGraph.order, errors, `${nodePath}.then`, executed);\n        }\n      }\n      if (node.else && typeof node.else === 'object' && 'order' in node.else) {\n        const subGraph = node.else as Graph;\n        if (subGraph.nodes && subGraph.order) {\n          this.validateGraphNodes(subGraph.nodes, subGraph.order, errors, `${nodePath}.else`, executed);\n        }\n      }\n\n      executed.add(nodeId);\n    }\n  }\n\n  private validateGraphReferences(node: GraphNode, executed: Set<string>, errors: GraphValidationError[], nodePath: string, nodes: Record<string, GraphNode>): void {\n    for (const [key, value] of Object.entries(node)) {\n      if (['atom', 'nodes', 'then', 'else'].includes(key)) continue;\n\n      if (typeof value === 'string') {\n        const matches = value.matchAll(/\\{\\{(\\w+)(?:\\.(.+?))?\\}\\}/g);\n        for (const match of matches) {\n          const refId = match[1];\n          if (!executed.has(refId) && !nodes[refId]) {\n            const suggestions = this.generateGraphSuggestions(executed, nodes);\n            errors.push({\n              node: nodePath,\n              code: 'INVALID_REFERENCE',\n              param: key,\n              ref: refId,\n              message: `Invalid reference {{${refId}}}: node not found or not yet executed`,\n              suggestions\n            });\n          }\n        }\n      }\n    }\n  }\n\n  private generateGraphSuggestions(executed: Set<string>, nodes: Record<string, GraphNode>): GraphSuggestion[] {\n    const suggestions: GraphSuggestion[] = [];\n\n    for (const nodeId of executed) {\n      if (suggestions.length >= 5) break;\n      const node = nodes[nodeId];\n      if (node) {\n        const atom = this.atoms.get(node.atom);\n        suggestions.push({\n          id: nodeId,\n          type: atom?.meta.output.type || 'unknown',\n          source: node.atom\n        });\n      }\n    }\n\n    return suggestions;\n  }\n\n  async executeGraph(graph: Graph, context: Context, outerScope?: Record<string, any>, graphName?: string): Promise<Record<string, any>> {\n    const results: Record<string, any> = outerScope ? { ...outerScope } : {};\n    const gName = graphName || 'unknown';\n    \n    const previousScope = context.currentScope;\n    context.currentScope = results;\n    context.runtime = this;\n\n    for (const nodeId of graph.order) {\n      const node = graph.nodes[nodeId];\n      const input = this.resolveGraphInput(node, results, context);\n      const startTime = performance.now();\n      const result = await context.execute(node.atom, input);\n      const duration = Math.round(performance.now() - startTime);\n\n      this.telemetryStore.record(node.atom, gName, duration, result.success);\n\n      if (!result.success) {\n        context.currentScope = previousScope;\n        throw new Error(JSON.stringify({ node: nodeId, atom: node.atom, error: result.error }));\n      }\n\n      results[nodeId] = result.data;\n    }\n\n    context.currentScope = previousScope;\n\n    return results;\n  }\n\n  onSnapshot(callback: (snapshot: TelemetrySnapshot) => void): void {\n    this.snapshotCallback = callback;\n  }\n\n  flushTelemetry(): TelemetrySnapshot {\n    const stats = this.telemetryStore.getStats();\n    const snapshot: TelemetrySnapshot = { timestamp: Date.now(), stats };\n    this.telemetryHistory.push(snapshot);\n    if (this.telemetryHistory.length > 100) {\n      this.telemetryHistory.shift();\n    }\n    this.snapshotCallback?.(snapshot);\n    return snapshot;\n  }\n\n  getTelemetryHistory(): TelemetrySnapshot[] {\n    return this.telemetryHistory;\n  }\n\n  restoreTelemetryHistory(history: TelemetrySnapshot[]): void {\n    this.telemetryHistory = history.slice(-100);\n  }\n\n  private resolveGraphInput(node: GraphNode, results: Record<string, any>, context: Context): any {\n    const resolved: any = {};\n    const SUBGRAPH_KEYS = new Set(['nodes', 'then', 'else']);\n\n    for (const [key, value] of Object.entries(node)) {\n      if (key === 'atom') continue;\n      if (SUBGRAPH_KEYS.has(key)) {\n        resolved[key] = value;\n      } else {\n        resolved[key] = this.resolveGraphValue(value, results, context);\n      }\n    }\n\n    return resolved;\n  }\n\n  private resolveGraphValue(value: any, results: Record<string, any>, context: Context): any {\n    if (typeof value === 'string') {\n      const ESCAPE_PLACEHOLDER = '\\x00ESCAPED_BRACE\\x00';\n      let processedValue = value.replace(/\\\\{{/g, ESCAPE_PLACEHOLDER);\n\n      const match = processedValue.match(/^\\{\\{(\\w+)(?:\\.(.+?))?\\}\\}$/);\n      if (match) {\n        const nodeId = match[1];\n        const field = match[2];\n\n        let resolvedValue: any;\n        \n        if (nodeId in results) {\n          resolvedValue = results[nodeId];\n        } else if (context.store.has(nodeId)) {\n          resolvedValue = context.store.get(nodeId);\n        } else {\n          throw new Error(JSON.stringify({\n            code: 'REFERENCE_NOT_FOUND',\n            ref: nodeId,\n            message: `Reference {{${nodeId}}} not found in current scope or store`,\n            availableInScope: Object.keys(results),\n            availableInStore: context.store.has(nodeId) ? [nodeId] : [],\n            hint: 'Check if the reference is a node output or a store value.',\n            fix: `Ensure the node \"${nodeId}\" is executed before this reference, or use { \"atom\": \"set\", \"key\": \"${nodeId}\", \"value\": ... } to store the value.`\n          }));\n        }\n\n        if (field) {\n          return this.getFieldValue(resolvedValue, field);\n        }\n        return resolvedValue;\n      }\n\n      const result = processedValue.replace(/\\{\\{(\\w+)(?:\\.(.+?))?\\}\\}/g, (_, nodeId, field) => {\n        let resolvedValue: any;\n        \n        if (nodeId in results) {\n          resolvedValue = results[nodeId];\n        } else if (context.store.has(nodeId)) {\n          resolvedValue = context.store.get(nodeId);\n        } else {\n          throw new Error(JSON.stringify({\n            code: 'REFERENCE_NOT_FOUND',\n            ref: nodeId,\n            message: `Reference {{${nodeId}}} not found in current scope or store`,\n            availableInScope: Object.keys(results),\n            availableInStore: context.store.has(nodeId) ? [nodeId] : [],\n            hint: 'Check if the reference is a node output or a store value.',\n            fix: `Ensure the node \"${nodeId}\" is executed before this reference, or use { \"atom\": \"set\", \"key\": \"${nodeId}\", \"value\": ... } to store the value.`\n          }));\n        }\n        if (field) {\n          return this.getFieldValue(resolvedValue, field);\n        }\n        return resolvedValue;\n      });\n\n      return result.replace(new RegExp(ESCAPE_PLACEHOLDER, 'g'), '{{');\n    }\n\n    if (Array.isArray(value)) {\n      return value.map(item => this.resolveGraphValue(item, results, context));\n    }\n\n    if (typeof value === 'object' && value !== null) {\n      const resolved: any = {};\n      for (const [k, v] of Object.entries(value)) {\n        resolved[k] = this.resolveGraphValue(v, results, context);\n      }\n      return resolved;\n    }\n\n    return value;\n  }\n\n  private getFieldValue(obj: any, field: string): any {\n    const parts = field.split('.');\n    let current = obj;\n\n    for (const part of parts) {\n      if (current === undefined || current === null) return undefined;\n      current = current[part];\n    }\n\n    return current;\n  }\n\n  listAtoms(): Atom[] {\n    const result: Atom[] = [];\n    const seen = new Set<string>();\n\n    for (const [key, atom] of this.atoms.entries()) {\n      if (!seen.has(atom.name)) {\n        seen.add(atom.name);\n        result.push(atom);\n      }\n    }\n\n    return result;\n  }\n\n  getSkillSet(): string {\n    const atoms = this.listAtoms();\n\n    const registry = {\n      aitos: {\n        version: '1.0.0',\n        type: 'graph-instruction-set',\n      },\n      graph: {\n        format: {\n          nodes: 'Record<nodeId, GraphNode>',\n          order: 'string[] (execution order)'\n        },\n        example: {\n          nodes: {\n            getY: { atom: 'get', key: 'fruitY' },\n            addFive: { atom: 'add', a: '{{getY}}', b: 5 },\n            saveY: { atom: 'set', key: 'fruitY', value: '{{addFive}}' }\n          },\n          order: ['getY', 'addFive', 'saveY']\n        }\n      },\n      node: {\n        format: { atom: 'string', '...params': 'per atom.input' },\n        example: { atom: 'add', a: '{{otherNodeId}}', b: 1 }\n      },\n      ref: {\n        format: '{{nodeId}} or {{nodeId.field}}',\n        rules: [\n          'Use nodeId to reference another node result',\n          'nodeId must be defined in nodes and appear earlier in order',\n          'Use {{nodeId.field}} to access nested properties',\n          'References are resolved before execution'\n        ]\n      },\n      atoms: atoms.map(a => ({\n        name: a.name,\n        version: a.version,\n        input: a.meta.input,\n        output: a.meta.output,\n      })),\n      validation: {\n        description: 'Validation checks node references and atom existence',\n        errorFormat: {\n          node: 'Node path',\n          code: 'Error code',\n          param: 'Parameter name',\n          ref: 'Invalid reference',\n          message: 'Error description',\n          suggestions: [\n            { id: 'Suggested nodeId', type: 'Output type', source: 'Atom name' }\n          ]\n        }\n      }\n    };\n\n    return JSON.stringify(registry);\n  }\n\n  getTelemetryStats(): TelemetryStats[] {\n    return this.telemetryStore.getStats();\n  }\n\n  resetTelemetry(): void {\n    this.telemetryStore.reset();\n  }\n}\n\nexport { Store, AtomRegistryImpl, TelemetryStore };\nexport type { Atom, Context, Result, Graph, GraphNode, Scope, AtomRegistry, GraphValidationError, GraphSuggestion, Runtime, TelemetryStats, TelemetrySnapshot };\n"]}

package/dist/types.d.ts

@@ -0,0 +1,123 @@
+export interface Atom {
+    name: string;
+    version: string;
+    meta: {
+        input: Array<{
+            name: string;
+            type: string;
+            description?: string;
+        }>;
+        output: {
+            type: string;
+            description?: string;
+        };
+    };
+    characteristics: {
+        stateless: boolean;
+        atomic: boolean;
+        composable: boolean;
+    };
+    execute: (input: any, context: Context) => Promise<Result>;
+}
+export interface Result {
+    success: boolean;
+    data?: any;
+    error?: string;
+}
+export interface GraphNode {
+    atom: string;
+    nodes?: Graph;
+    then?: Graph;
+    else?: Graph;
+    [key: string]: any;
+}
+export type GraphMode = 'kernel' | 'user';
+export interface GraphInterface {
+    input: Array<{
+        name: string;
+        type: string;
+        description?: string;
+    }>;
+    output: {
+        type: string;
+        description?: string;
+    };
+}
+export interface Graph {
+    mode?: GraphMode;
+    _meta?: {
+        description?: string;
+        type?: string;
+        category?: string;
+        author?: string;
+    };
+    interface?: GraphInterface;
+    order: string[];
+    nodes: Record<string, GraphNode>;
+}
+export interface Scope {
+    [key: string]: any;
+}
+export interface Context {
+    store: {
+        get: (key: string) => any;
+        set: (key: string, value: any) => void;
+        has: (key: string) => boolean;
+        delete: (key: string) => void;
+        clear: () => void;
+        keys: () => IterableIterator<string>;
+    };
+    currentScope: Scope;
+    execute: (atomName: string, input: any) => Promise<Result>;
+    executeGraph?: (graph: Graph, scope?: Scope, graphName?: string) => Promise<Record<string, any>>;
+    runtime?: Runtime;
+}
+export interface AtomRegistry {
+    register: (atom: Atom) => void;
+    get: (name: string) => Atom | undefined;
+    has: (name: string) => boolean;
+    list: () => string[];
+}
+export interface GraphValidationError {
+    node: string;
+    code: string;
+    param: string;
+    ref: string;
+    message: string;
+    suggestions?: GraphSuggestion[];
+}
+export interface GraphSuggestion {
+    id: string;
+    type: string;
+    source: string;
+}
+export interface TelemetrySnapshot {
+    timestamp: number;
+    stats: TelemetryStats[];
+}
+export interface Runtime {
+    register(atom: Atom): void;
+    validateGraph(graph: Graph): {
+        valid: boolean;
+        errors: string[];
+    };
+    executeGraph(graph: Graph, context: Context, outerScope?: Record<string, any>, graphName?: string): Promise<Record<string, any>>;
+    listAtoms(): Atom[];
+    getSkillSet(): string;
+    getTelemetryStats(): TelemetryStats[];
+    resetTelemetry(): void;
+    onSnapshot(callback: (snapshot: TelemetrySnapshot) => void): void;
+    flushTelemetry(): TelemetrySnapshot;
+    getTelemetryHistory(): TelemetrySnapshot[];
+    restoreTelemetryHistory(history: TelemetrySnapshot[]): void;
+}
+export interface TelemetryStats {
+    atom: string;
+    count: number;
+    avgDuration: number;
+    maxDuration: number;
+    errorCount: number;
+    errorRate: number;
+    lastCalled: number;
+    graphs: string[];
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,13 +1,27 @@
 {
   "name": "@aitos/core",
-  "version": "1.0.0",
-  "description": "AI-Native Application Framework - Build apps with atomic composition and graph execution",
-  "main": "index.js",
+  "version": "1.0.1",
+  "description": "AITOS Core Package - AI-friendly atomic architecture based on capability dimensions",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "build": "tsc",
+    "dev": "tsc --watch"
   },
-  "keywords": ["ai", "framework", "atomic", "graph-execution", "cross-platform"],
-  "author": "",
+  "keywords": [
+    "aitos",
+    "atomic",
+    "architecture",
+    "ai-friendly",
+    "capability-based"
+  ],
+  "author": "AITOS Team",
   "license": "MIT",
-  "type": "commonjs"
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.9.3"
+  }
 }