@aitos/core 1.0.0 → 1.0.1

package/dist/atoms/time.d.ts

@@ -0,0 +1,5 @@
+import { Atom } from '../types';
+export declare const nowAtom: Atom;
+export declare const timestampToDateAtom: Atom;
+export declare const getMonthDaysAtom: Atom;
+export declare const isLeapYearAtom: Atom;

package/dist/atoms/time.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLeapYearAtom = exports.getMonthDaysAtom = exports.timestampToDateAtom = exports.nowAtom = void 0;
+exports.nowAtom = {
+    name: 'now',
+    version: '1.0.0',
+    meta: {
+        input: [],
+        output: { type: 'number', description: 'Current timestamp in milliseconds since epoch' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        return { success: true, data: Date.now() };
+    },
+};
+exports.timestampToDateAtom = {
+    name: 'timestampToDate',
+    version: '1.0.0',
+    meta: {
+        input: [{ name: 'timestamp', type: 'number', description: 'Milliseconds since epoch' }],
+        output: { type: 'object', description: '{ year, month, day, dayOfWeek, hour, minute, second }' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        const d = new Date(input.timestamp);
+        return {
+            success: true,
+            data: {
+                year: d.getFullYear(),
+                month: d.getMonth(),
+                day: d.getDate(),
+                dayOfWeek: d.getDay(),
+                hour: d.getHours(),
+                minute: d.getMinutes(),
+                second: d.getSeconds()
+            }
+        };
+    },
+};
+exports.getMonthDaysAtom = {
+    name: 'getMonthDays',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'year', type: 'number' },
+            { name: 'month', type: 'number' }
+        ],
+        output: { type: 'object', description: '{ firstDay, daysInMonth }' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        const firstDay = new Date(input.year, input.month, 1).getDay();
+        const daysInMonth = new Date(input.year, input.month + 1, 0).getDate();
+        return { success: true, data: { firstDay, daysInMonth } };
+    },
+};
+exports.isLeapYearAtom = {
+    name: 'isLeapYear',
+    version: '1.0.0',
+    meta: {
+        input: [{ name: 'year', type: 'number', description: 'Year to check' }],
+        output: { type: 'boolean', description: 'True if leap year' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        const year = input.year;
+        const isLeap = (year % 4 === 0 && year % 100 !== 0) || (year % 400 === 0);
+        return { success: true, data: isLeap };
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/atoms/tool-calls.d.ts

@@ -0,0 +1,2 @@
+import { Atom } from '../types';
+export declare const handleToolCallsAtom: Atom;

package/dist/atoms/tool-calls.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleToolCallsAtom = void 0;
+const acs_1 = require("../acs");
+function isGraph(obj) {
+    return obj && typeof obj === 'object' && Array.isArray(obj.order) && typeof obj.nodes === 'object';
+}
+exports.handleToolCallsAtom = {
+    name: 'handleToolCalls',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'toolCalls', type: 'array', description: 'Array of tool calls from AI response' }
+        ],
+        output: { type: 'array', description: 'Array of tool results' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        if (!input.toolCalls || input.toolCalls.length === 0) {
+            return { success: true, data: [] };
+        }
+        const results = [];
+        for (const toolCall of input.toolCalls) {
+            const toolName = toolCall.function?.name;
+            let toolArgs = {};
+            try {
+                if (toolCall.function?.arguments) {
+                    toolArgs = JSON.parse(toolCall.function.arguments);
+                }
+            }
+            catch (e) {
+                results.push({
+                    toolCallId: toolCall.id,
+                    name: toolName,
+                    result: JSON.stringify({ error: 'Failed to parse arguments' })
+                });
+                continue;
+            }
+            let result;
+            if (toolName === 'getSkillSet') {
+                if (context.runtime) {
+                    result = JSON.parse(context.runtime.getSkillSet());
+                }
+                else {
+                    result = { error: 'Runtime not available' };
+                }
+            }
+            else {
+                const atom = context.runtime?.listAtoms().find(a => a.name === toolName);
+                if (atom) {
+                    try {
+                        const execResult = await atom.execute(toolArgs, context);
+                        result = execResult.success ? execResult.data : { error: execResult.error };
+                    }
+                    catch (e) {
+                        result = { error: `Execution failed: ${e}` };
+                    }
+                }
+                else {
+                    const toolToGraphMap = {
+                        'save-growth': 'growth/save-growth',
+                        'get-growth-log': 'growth/get-growth-log',
+                        'analyze-telemetry': 'telemetry/analyze',
+                    };
+                    const graphKey = toolToGraphMap[toolName] || toolName;
+                    const graphSource = context.store.get(`__graph_${graphKey}`);
+                    if (graphSource && context.executeGraph && context.runtime) {
+                        try {
+                            for (const [key, value] of Object.entries(toolArgs)) {
+                                context.store.set(key, value);
+                            }
+                            let graph;
+                            if (typeof graphSource === 'string') {
+                                graph = (0, acs_1.compileAcs)(graphSource);
+                            }
+                            else if (isGraph(graphSource)) {
+                                graph = graphSource;
+                            }
+                            else {
+                                result = { error: `Graph "${toolName}" has invalid format` };
+                                results.push({ toolCallId: toolCall.id, name: toolName, result: JSON.stringify(result) });
+                                continue;
+                            }
+                            const graphResults = await context.runtime.executeGraph(graph, context, undefined, graphKey);
+                            const lastNodeId = graph.order[graph.order.length - 1];
+                            result = graphResults[lastNodeId];
+                        }
+                        catch (e) {
+                            result = { error: `Graph execution failed: ${e.message}` };
+                        }
+                    }
+                    else {
+                        result = { error: `Unknown tool: ${toolName}` };
+                    }
+                }
+            }
+            results.push({
+                toolCallId: toolCall.id,
+                name: toolName,
+                result: JSON.stringify(result)
+            });
+        }
+        return { success: true, data: results };
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tool-calls.js","sourceRoot":"","sources":["../../src/atoms/tool-calls.ts"],"names":[],"mappings":"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","sourcesContent":["import { Atom, Context, Result } from '../types';\nimport { compileAcs } from '../acs';\n\nfunction isGraph(obj: any): boolean {\n  return obj && typeof obj === 'object' && Array.isArray(obj.order) && typeof obj.nodes === 'object';\n}\n\nexport const handleToolCallsAtom: Atom = {\n  name: 'handleToolCalls',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'toolCalls', type: 'array', description: 'Array of tool calls from AI response' }\n    ],\n    output: { type: 'array', description: 'Array of tool results' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { toolCalls: any[] }, context: Context): Promise<Result> => {\n    if (!input.toolCalls || input.toolCalls.length === 0) {\n      return { success: true, data: [] };\n    }\n\n    const results: any[] = [];\n\n    for (const toolCall of input.toolCalls) {\n      const toolName = toolCall.function?.name;\n      let toolArgs: any = {};\n\n      try {\n        if (toolCall.function?.arguments) {\n          toolArgs = JSON.parse(toolCall.function.arguments);\n        }\n      } catch (e) {\n        results.push({\n          toolCallId: toolCall.id,\n          name: toolName,\n          result: JSON.stringify({ error: 'Failed to parse arguments' })\n        });\n        continue;\n      }\n\n      let result: any;\n\n      if (toolName === 'getSkillSet') {\n        if (context.runtime) {\n          result = JSON.parse(context.runtime.getSkillSet());\n        } else {\n          result = { error: 'Runtime not available' };\n        }\n      } else {\n        const atom = context.runtime?.listAtoms().find(a => a.name === toolName);\n        if (atom) {\n          try {\n            const execResult = await atom.execute(toolArgs, context);\n            result = execResult.success ? execResult.data : { error: execResult.error };\n          } catch (e) {\n            result = { error: `Execution failed: ${e}` };\n          }\n        } else {\n          const toolToGraphMap: Record<string, string> = {\n            'save-growth': 'growth/save-growth',\n            'get-growth-log': 'growth/get-growth-log',\n            'analyze-telemetry': 'telemetry/analyze',\n          };\n          const graphKey = toolToGraphMap[toolName] || toolName;\n          const graphSource = context.store.get(`__graph_${graphKey}`);\n          if (graphSource && context.executeGraph && context.runtime) {\n            try {\n              for (const [key, value] of Object.entries(toolArgs)) {\n                context.store.set(key, value);\n              }\n\n              let graph: any;\n              if (typeof graphSource === 'string') {\n                graph = compileAcs(graphSource);\n              } else if (isGraph(graphSource)) {\n                graph = graphSource;\n              } else {\n                result = { error: `Graph \"${toolName}\" has invalid format` };\n                results.push({ toolCallId: toolCall.id, name: toolName, result: JSON.stringify(result) });\n                continue;\n              }\n\n              const graphResults = await context.runtime.executeGraph(graph, context, undefined, graphKey);\n              const lastNodeId = graph.order[graph.order.length - 1];\n              result = graphResults[lastNodeId];\n            } catch (e: any) {\n              result = { error: `Graph execution failed: ${e.message}` };\n            }\n          } else {\n            result = { error: `Unknown tool: ${toolName}` };\n          }\n        }\n      }\n\n      results.push({\n        toolCallId: toolCall.id,\n        name: toolName,\n        result: JSON.stringify(result)\n      });\n    }\n\n    return { success: true, data: results };\n  },\n};\n"]}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export * from './types';
+export * from './runtime';
+export * from './acs';
+export * from './atoms/state';
+export * from './atoms/calculation';
+export * from './atoms/judgment';
+export * from './atoms/control';
+export * from './atoms/manipulation';
+export * from './atoms/time';
+export * from './atoms/tool-calls';
+export * from './atoms/telemetry';
+import { Atom } from './types';
+export declare const allAtoms: Atom[];

package/dist/index.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allAtoms = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./acs"), exports);
+__exportStar(require("./atoms/state"), exports);
+__exportStar(require("./atoms/calculation"), exports);
+__exportStar(require("./atoms/judgment"), exports);
+__exportStar(require("./atoms/control"), exports);
+__exportStar(require("./atoms/manipulation"), exports);
+__exportStar(require("./atoms/time"), exports);
+__exportStar(require("./atoms/tool-calls"), exports);
+__exportStar(require("./atoms/telemetry"), exports);
+const state_1 = require("./atoms/state");
+const calculation_1 = require("./atoms/calculation");
+const judgment_1 = require("./atoms/judgment");
+const control_1 = require("./atoms/control");
+const manipulation_1 = require("./atoms/manipulation");
+const time_1 = require("./atoms/time");
+const tool_calls_1 = require("./atoms/tool-calls");
+const telemetry_1 = require("./atoms/telemetry");
+exports.allAtoms = [
+    state_1.getAtom, state_1.setAtom,
+    calculation_1.addAtom, calculation_1.subAtom, calculation_1.mulAtom, calculation_1.divAtom, calculation_1.modAtom, calculation_1.randomAtom,
+    judgment_1.eqAtom, judgment_1.gtAtom, judgment_1.ltAtom, judgment_1.gteAtom, judgment_1.lteAtom,
+    judgment_1.andAtom, judgment_1.orAtom, judgment_1.notAtom,
+    judgment_1.isNilAtom, judgment_1.isNumAtom, judgment_1.isStrAtom, judgment_1.isArrAtom, judgment_1.isObjAtom,
+    control_1.branchAtom, control_1.loopAtom, control_1.forEachAtom, control_1.execAtom, control_1.execGraphAtom, control_1.waitAtom, control_1.execFileAtom, control_1.logAtom, control_1.getSkillSetAtom, control_1.compileAcsAtom,
+    manipulation_1.concatAtom, manipulation_1.splitAtom, manipulation_1.lenAtom,
+    manipulation_1.pushAtom, manipulation_1.popAtom, manipulation_1.sliceAtom,
+    manipulation_1.getPropAtom, manipulation_1.setPropAtom, manipulation_1.keysAtom, manipulation_1.valuesAtom, manipulation_1.mergeAtom, manipulation_1.filterAtom, manipulation_1.formatAtom,
+    manipulation_1.toNumAtom, manipulation_1.containsAtom, manipulation_1.startsWithAtom, manipulation_1.replaceAtom, manipulation_1.trimAtom, manipulation_1.toLowerAtom, manipulation_1.toUpperAtom, manipulation_1.getAtAtom,
+    time_1.nowAtom, time_1.timestampToDateAtom, time_1.getMonthDaysAtom, time_1.isLeapYearAtom,
+    tool_calls_1.handleToolCallsAtom,
+    telemetry_1.getTelemetryStatsAtom, telemetry_1.resetTelemetryAtom, telemetry_1.flushTelemetryAtom, telemetry_1.getTelemetryHistoryAtom, telemetry_1.analyzeTelemetryAtom,
+];
+//# sourceMappingURL=data:application/json;base64,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

package/dist/runtime.d.ts

@@ -0,0 +1,50 @@
+import { Atom, Context, Result, Graph, GraphNode, Scope, AtomRegistry, GraphValidationError, GraphSuggestion, Runtime, TelemetryStats, TelemetrySnapshot } from './types';
+declare class Store {
+    private data;
+    get(key: string): any;
+    set(key: string, value: any): void;
+    has(key: string): boolean;
+    delete(key: string): void;
+    clear(): void;
+}
+declare class TelemetryStore {
+    private atoms;
+    record(atom: string, graphName: string, duration: number, success: boolean): void;
+    getStats(): TelemetryStats[];
+    reset(): void;
+}
+declare class AtomRegistryImpl implements AtomRegistry {
+    private atoms;
+    register(atom: Atom): void;
+    get(name: string): Atom | undefined;
+    has(name: string): boolean;
+    list(): string[];
+}
+export declare class AitosRuntime implements Runtime {
+    private atoms;
+    private telemetryStore;
+    private telemetryHistory;
+    private snapshotCallback?;
+    register(atom: Atom): void;
+    validateGraph(graph: Graph): {
+        valid: boolean;
+        errors: string[];
+    };
+    private validateGraphNodes;
+    private validateGraphReferences;
+    private generateGraphSuggestions;
+    executeGraph(graph: Graph, context: Context, outerScope?: Record<string, any>, graphName?: string): Promise<Record<string, any>>;
+    onSnapshot(callback: (snapshot: TelemetrySnapshot) => void): void;
+    flushTelemetry(): TelemetrySnapshot;
+    getTelemetryHistory(): TelemetrySnapshot[];
+    restoreTelemetryHistory(history: TelemetrySnapshot[]): void;
+    private resolveGraphInput;
+    private resolveGraphValue;
+    private getFieldValue;
+    listAtoms(): Atom[];
+    getSkillSet(): string;
+    getTelemetryStats(): TelemetryStats[];
+    resetTelemetry(): void;
+}
+export { Store, AtomRegistryImpl, TelemetryStore };
+export type { Atom, Context, Result, Graph, GraphNode, Scope, AtomRegistry, GraphValidationError, GraphSuggestion, Runtime, TelemetryStats, TelemetrySnapshot };