@aitos/core 1.0.0 → 1.0.1

package/dist/atoms/calculation.d.ts

@@ -0,0 +1,7 @@
+import { Atom } from '../types';
+export declare const addAtom: Atom;
+export declare const subAtom: Atom;
+export declare const mulAtom: Atom;
+export declare const divAtom: Atom;
+export declare const modAtom: Atom;
+export declare const randomAtom: Atom;

package/dist/atoms/calculation.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomAtom = exports.modAtom = exports.divAtom = exports.mulAtom = exports.subAtom = exports.addAtom = void 0;
+exports.addAtom = {
+    name: 'add',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'a', type: 'number' },
+            { name: 'b', type: 'number' }
+        ],
+        output: { type: 'number' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        return { success: true, data: input.a + input.b };
+    },
+};
+exports.subAtom = {
+    name: 'sub',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'a', type: 'number' },
+            { name: 'b', type: 'number' }
+        ],
+        output: { type: 'number' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        return { success: true, data: input.a - input.b };
+    },
+};
+exports.mulAtom = {
+    name: 'mul',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'a', type: 'number' },
+            { name: 'b', type: 'number' }
+        ],
+        output: { type: 'number' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        return { success: true, data: input.a * input.b };
+    },
+};
+exports.divAtom = {
+    name: 'div',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'a', type: 'number' },
+            { name: 'b', type: 'number' }
+        ],
+        output: { type: 'number' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        return { success: true, data: input.a / input.b };
+    },
+};
+exports.modAtom = {
+    name: 'mod',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'a', type: 'number' },
+            { name: 'b', type: 'number' }
+        ],
+        output: { type: 'number' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        return { success: true, data: input.a % input.b };
+    },
+};
+exports.randomAtom = {
+    name: 'random',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'min', type: 'number' },
+            { name: 'max', type: 'number' }
+        ],
+        output: { type: 'number' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        const { min, max } = input;
+        return { success: true, data: Math.floor(Math.random() * (max - min + 1)) + min };
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"calculation.js","sourceRoot":"","sources":["../../src/atoms/calculation.ts"],"names":[],"mappings":"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","sourcesContent":["import { Atom, Context, Result } from '../types';\n\nexport const addAtom: Atom = {\n  name: 'add',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'a', type: 'number' },\n      { name: 'b', type: 'number' }\n    ],\n    output: { type: 'number' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { a: number; b: number }, context: Context): Promise<Result> => {\n    return { success: true, data: input.a + input.b };\n  },\n};\n\nexport const subAtom: Atom = {\n  name: 'sub',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'a', type: 'number' },\n      { name: 'b', type: 'number' }\n    ],\n    output: { type: 'number' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { a: number; b: number }, context: Context): Promise<Result> => {\n    return { success: true, data: input.a - input.b };\n  },\n};\n\nexport const mulAtom: Atom = {\n  name: 'mul',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'a', type: 'number' },\n      { name: 'b', type: 'number' }\n    ],\n    output: { type: 'number' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { a: number; b: number }, context: Context): Promise<Result> => {\n    return { success: true, data: input.a * input.b };\n  },\n};\n\nexport const divAtom: Atom = {\n  name: 'div',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'a', type: 'number' },\n      { name: 'b', type: 'number' }\n    ],\n    output: { type: 'number' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { a: number; b: number }, context: Context): Promise<Result> => {\n    return { success: true, data: input.a / input.b };\n  },\n};\n\nexport const modAtom: Atom = {\n  name: 'mod',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'a', type: 'number' },\n      { name: 'b', type: 'number' }\n    ],\n    output: { type: 'number' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { a: number; b: number }, context: Context): Promise<Result> => {\n    return { success: true, data: input.a % input.b };\n  },\n};\n\nexport const randomAtom: Atom = {\n  name: 'random',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'min', type: 'number' },\n      { name: 'max', type: 'number' }\n    ],\n    output: { type: 'number' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { min: number; max: number }, context: Context): Promise<Result> => {\n    const { min, max } = input;\n    return { success: true, data: Math.floor(Math.random() * (max - min + 1)) + min };\n  },\n};\n"]}

package/dist/atoms/control.d.ts

@@ -0,0 +1,11 @@
+import { Atom } from '../types';
+export declare const branchAtom: Atom;
+export declare const loopAtom: Atom;
+export declare const forEachAtom: Atom;
+export declare const execAtom: Atom;
+export declare const execGraphAtom: Atom;
+export declare const waitAtom: Atom;
+export declare const execFileAtom: Atom;
+export declare const logAtom: Atom;
+export declare const getSkillSetAtom: Atom;
+export declare const compileAcsAtom: Atom;

package/dist/atoms/control.js

@@ -0,0 +1,269 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileAcsAtom = exports.getSkillSetAtom = exports.logAtom = exports.execFileAtom = exports.waitAtom = exports.execGraphAtom = exports.execAtom = exports.forEachAtom = exports.loopAtom = exports.branchAtom = void 0;
+const acs_1 = require("../acs");
+function isGraph(obj) {
+    return obj && typeof obj === 'object' && Array.isArray(obj.order) && typeof obj.nodes === 'object';
+}
+exports.branchAtom = {
+    name: 'branch',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'cond', type: 'boolean', description: 'Condition to evaluate' },
+            { name: 'then', type: 'object', description: 'Graph to execute if cond is true' },
+            { name: 'else', type: 'object', description: 'Graph to execute if cond is false' }
+        ],
+        output: { type: 'any' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        const condValue = !!input.cond;
+        const branchInput = condValue ? input.then : input.else;
+        if (!branchInput) {
+            return { success: true, data: null };
+        }
+        if (!isGraph(branchInput)) {
+            return { success: false, error: 'Branch input must be a valid graph with order and nodes' };
+        }
+        if (!context.executeGraph) {
+            return { success: false, error: 'executeGraph not available' };
+        }
+        const results = await context.executeGraph(branchInput, context.currentScope);
+        const lastNodeId = branchInput.order[branchInput.order.length - 1];
+        return { success: true, data: results[lastNodeId] };
+    },
+};
+exports.loopAtom = {
+    name: 'loop',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'nodes', type: 'object' },
+            { name: 'condKey', type: 'string' }
+        ],
+        output: { type: 'void' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        const { nodes, condKey } = input;
+        if (!context.executeGraph) {
+            return { success: true, data: { done: true } };
+        }
+        while (true) {
+            if (condKey) {
+                const shouldContinue = context.store.get(condKey);
+                if (!shouldContinue)
+                    break;
+            }
+            await context.executeGraph(nodes, context.currentScope);
+        }
+        return { success: true, data: { done: true } };
+    },
+};
+exports.forEachAtom = {
+    name: 'forEach',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'array', type: 'array', description: 'Array to iterate' },
+            { name: 'nodes', type: 'object', description: 'Graph to execute for each item' },
+            { name: 'itemKey', type: 'string', description: 'Key to store current item in store' },
+            { name: 'indexKey', type: 'string', description: 'Optional key to store current index' }
+        ],
+        output: { type: 'void', description: 'Nothing' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        if (!context.executeGraph) {
+            return { success: true, data: { done: true } };
+        }
+        if (!Array.isArray(input.array)) {
+            return { success: false, error: 'Input is not an array' };
+        }
+        for (let i = 0; i < input.array.length; i++) {
+            context.store.set(input.itemKey, input.array[i]);
+            if (input.indexKey) {
+                context.store.set(input.indexKey, i);
+            }
+            await context.executeGraph(input.nodes, context.currentScope);
+        }
+        return { success: true, data: { done: true } };
+    },
+};
+exports.execAtom = {
+    name: 'exec',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'nodes', type: 'object' }
+        ],
+        output: { type: 'any' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        if (!context.executeGraph) {
+            return { success: true, data: null };
+        }
+        const results = await context.executeGraph(input.nodes, context.currentScope);
+        const lastNodeId = input.nodes.order[input.nodes.order.length - 1];
+        return { success: true, data: results[lastNodeId] };
+    },
+};
+exports.execGraphAtom = {
+    name: 'execGraph',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'graph', type: 'any', description: 'Graph object or ACS string' }
+        ],
+        output: { type: 'any', description: 'Result of the last node in the graph' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        if (!context.executeGraph) {
+            return { success: false, error: 'executeGraph not available in context' };
+        }
+        let graph;
+        if (typeof input.graph === 'string') {
+            try {
+                graph = (0, acs_1.compileAcs)(input.graph);
+            }
+            catch (e) {
+                return { success: false, error: `Failed to compile ACS: ${e.message}` };
+            }
+        }
+        else if (isGraph(input.graph)) {
+            graph = input.graph;
+        }
+        else {
+            return { success: false, error: 'Invalid graph: must be a Graph object or ACS string' };
+        }
+        if (!graph.order || !graph.nodes) {
+            return { success: false, error: 'Invalid graph: missing order or nodes' };
+        }
+        const results = await context.executeGraph(graph, context.currentScope);
+        const lastNodeId = graph.order[graph.order.length - 1];
+        return { success: true, data: results[lastNodeId] };
+    },
+};
+exports.waitAtom = {
+    name: 'wait',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'ms', type: 'number' }
+        ],
+        output: { type: 'void' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        return new Promise(resolve => {
+            setTimeout(() => resolve({ success: true, data: { done: true } }), input.ms);
+        });
+    },
+};
+exports.execFileAtom = {
+    name: 'execFile',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'file', type: 'string' }
+        ],
+        output: { type: 'any' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        let graph = context.store.get(`__graph_${input.file}`);
+        if (!graph) {
+            return { success: false, error: `Graph file "${input.file}" not found in store` };
+        }
+        if (typeof graph === 'string') {
+            try {
+                graph = (0, acs_1.compileAcs)(graph);
+            }
+            catch (e) {
+                return { success: false, error: `Failed to compile ACS: ${e.message}` };
+            }
+        }
+        if (!isGraph(graph)) {
+            return { success: false, error: 'Invalid graph: must be a Graph object or ACS string' };
+        }
+        if (!context.executeGraph) {
+            return { success: false, error: 'executeGraph not available in context' };
+        }
+        const results = await context.executeGraph(graph, context.currentScope, input.file);
+        const lastNodeId = graph.order[graph.order.length - 1];
+        return { success: true, data: results[lastNodeId] };
+    },
+};
+exports.logAtom = {
+    name: 'log',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'message', type: 'string' },
+            { name: 'data', type: 'any' }
+        ],
+        output: { type: 'any' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        if (input.message && input.data !== undefined) {
+            console.log(`[AITOS] ${input.message}:`, input.data);
+        }
+        else if (input.data !== undefined) {
+            console.log('[AITOS]', input.data);
+        }
+        else if (input.message) {
+            console.log(`[AITOS] ${input.message}`);
+        }
+        return { success: true, data: input.data };
+    },
+};
+exports.getSkillSetAtom = {
+    name: 'getSkillSet',
+    version: '1.0.0',
+    meta: {
+        input: [],
+        output: { type: 'string', description: 'JSON string containing all available atoms and graph format' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        if (!context.runtime) {
+            return { success: false, error: 'Runtime not available in context' };
+        }
+        const skillSet = context.runtime.getSkillSet();
+        return { success: true, data: skillSet };
+    },
+};
+exports.compileAcsAtom = {
+    name: 'compileAcs',
+    version: '1.0.0',
+    meta: {
+        input: [
+            { name: 'acs', type: 'string', description: 'ACS string to compile' }
+        ],
+        output: { type: 'object', description: 'Compiled Graph object or error' }
+    },
+    characteristics: { stateless: true, atomic: true, composable: true },
+    execute: async (input, context) => {
+        if (typeof input.acs !== 'string') {
+            return { success: false, error: 'Input must be a string' };
+        }
+        try {
+            const graph = (0, acs_1.compileAcs)(input.acs);
+            if (context.runtime) {
+                const validation = context.runtime.validateGraph(graph);
+                if (!validation.valid) {
+                    return { success: false, error: `Graph validation failed: ${validation.errors.join('; ')}` };
+                }
+            }
+            return { success: true, data: graph };
+        }
+        catch (e) {
+            return { success: false, error: `ACS compilation error: ${e.message}` };
+        }
+    },
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"control.js","sourceRoot":"","sources":["../../src/atoms/control.ts"],"names":[],"mappings":"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","sourcesContent":["import { Atom, Context, Result, Graph } from '../types';\nimport { compileAcs } from '../acs';\n\nfunction isGraph(obj: any): obj is Graph {\n  return obj && typeof obj === 'object' && Array.isArray(obj.order) && typeof obj.nodes === 'object';\n}\n\nexport const branchAtom: Atom = {\n  name: 'branch',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'cond', type: 'boolean', description: 'Condition to evaluate' },\n      { name: 'then', type: 'object', description: 'Graph to execute if cond is true' },\n      { name: 'else', type: 'object', description: 'Graph to execute if cond is false' }\n    ],\n    output: { type: 'any' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { cond: boolean; then?: Graph; else?: Graph }, context: Context): Promise<Result> => {\n    const condValue = !!input.cond;\n    \n    const branchInput = condValue ? input.then : input.else;\n    \n    if (!branchInput) {\n      return { success: true, data: null };\n    }\n\n    if (!isGraph(branchInput)) {\n      return { success: false, error: 'Branch input must be a valid graph with order and nodes' };\n    }\n\n    if (!context.executeGraph) {\n      return { success: false, error: 'executeGraph not available' };\n    }\n\n    const results = await context.executeGraph(branchInput, context.currentScope);\n    const lastNodeId = branchInput.order[branchInput.order.length - 1];\n    return { success: true, data: results[lastNodeId] };\n  },\n};\n\nexport const loopAtom: Atom = {\n  name: 'loop',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'nodes', type: 'object' },\n      { name: 'condKey', type: 'string' }\n    ],\n    output: { type: 'void' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { nodes: Graph; condKey?: string }, context: Context): Promise<Result> => {\n    const { nodes, condKey } = input;\n\n    if (!context.executeGraph) {\n      return { success: true, data: { done: true } };\n    }\n\n    while (true) {\n      if (condKey) {\n        const shouldContinue = context.store.get(condKey);\n        if (!shouldContinue) break;\n      }\n\n      await context.executeGraph(nodes, context.currentScope);\n    }\n\n    return { success: true, data: { done: true } };\n  },\n};\n\nexport const forEachAtom: Atom = {\n  name: 'forEach',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'array', type: 'array', description: 'Array to iterate' },\n      { name: 'nodes', type: 'object', description: 'Graph to execute for each item' },\n      { name: 'itemKey', type: 'string', description: 'Key to store current item in store' },\n      { name: 'indexKey', type: 'string', description: 'Optional key to store current index' }\n    ],\n    output: { type: 'void', description: 'Nothing' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { \n    array: any[]; \n    nodes: Graph; \n    itemKey: string;\n    indexKey?: string;\n  }, context: Context): Promise<Result> => {\n    if (!context.executeGraph) {\n      return { success: true, data: { done: true } };\n    }\n\n    if (!Array.isArray(input.array)) {\n      return { success: false, error: 'Input is not an array' };\n    }\n\n    for (let i = 0; i < input.array.length; i++) {\n      context.store.set(input.itemKey, input.array[i]);\n      if (input.indexKey) {\n        context.store.set(input.indexKey, i);\n      }\n      await context.executeGraph(input.nodes, context.currentScope);\n    }\n\n    return { success: true, data: { done: true } };\n  },\n};\n\nexport const execAtom: Atom = {\n  name: 'exec',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'nodes', type: 'object' }\n    ],\n    output: { type: 'any' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { nodes: Graph }, context: Context): Promise<Result> => {\n    if (!context.executeGraph) {\n      return { success: true, data: null };\n    }\n\n    const results = await context.executeGraph(input.nodes, context.currentScope);\n    const lastNodeId = input.nodes.order[input.nodes.order.length - 1];\n    return { success: true, data: results[lastNodeId] };\n  },\n};\n\nexport const execGraphAtom: Atom = {\n  name: 'execGraph',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'graph', type: 'any', description: 'Graph object or ACS string' }\n    ],\n    output: { type: 'any', description: 'Result of the last node in the graph' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { graph: any }, context: Context): Promise<Result> => {\n    if (!context.executeGraph) {\n      return { success: false, error: 'executeGraph not available in context' };\n    }\n\n    let graph: Graph;\n    if (typeof input.graph === 'string') {\n      try {\n        graph = compileAcs(input.graph);\n      } catch (e: any) {\n        return { success: false, error: `Failed to compile ACS: ${e.message}` };\n      }\n    } else if (isGraph(input.graph)) {\n      graph = input.graph;\n    } else {\n      return { success: false, error: 'Invalid graph: must be a Graph object or ACS string' };\n    }\n\n    if (!graph.order || !graph.nodes) {\n      return { success: false, error: 'Invalid graph: missing order or nodes' };\n    }\n\n    const results = await context.executeGraph(graph, context.currentScope);\n    const lastNodeId = graph.order[graph.order.length - 1];\n    return { success: true, data: results[lastNodeId] };\n  },\n};\n\nexport const waitAtom: Atom = {\n  name: 'wait',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'ms', type: 'number' }\n    ],\n    output: { type: 'void' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { ms: number }, context: Context): Promise<Result> => {\n    return new Promise(resolve => {\n      setTimeout(() => resolve({ success: true, data: { done: true } }), input.ms);\n    });\n  },\n};\n\nexport const execFileAtom: Atom = {\n  name: 'execFile',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'file', type: 'string' }\n    ],\n    output: { type: 'any' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { file: string }, context: Context): Promise<Result> => {\n    let graph = context.store.get(`__graph_${input.file}`);\n    \n    if (!graph) {\n      return { success: false, error: `Graph file \"${input.file}\" not found in store` };\n    }\n    \n    if (typeof graph === 'string') {\n      try {\n        graph = compileAcs(graph);\n      } catch (e: any) {\n        return { success: false, error: `Failed to compile ACS: ${e.message}` };\n      }\n    }\n\n    if (!isGraph(graph)) {\n      return { success: false, error: 'Invalid graph: must be a Graph object or ACS string' };\n    }\n    \n    if (!context.executeGraph) {\n      return { success: false, error: 'executeGraph not available in context' };\n    }\n\n    const results = await context.executeGraph(graph, context.currentScope, input.file);\n    const lastNodeId = graph.order[graph.order.length - 1];\n    return { success: true, data: results[lastNodeId] };\n  },\n};\n\nexport const logAtom: Atom = {\n  name: 'log',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'message', type: 'string' },\n      { name: 'data', type: 'any' }\n    ],\n    output: { type: 'any' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { message?: string; data?: any }, context: Context): Promise<Result> => {\n    if (input.message && input.data !== undefined) {\n      console.log(`[AITOS] ${input.message}:`, input.data);\n    } else if (input.data !== undefined) {\n      console.log('[AITOS]', input.data);\n    } else if (input.message) {\n      console.log(`[AITOS] ${input.message}`);\n    }\n    return { success: true, data: input.data };\n  },\n};\n\nexport const getSkillSetAtom: Atom = {\n  name: 'getSkillSet',\n  version: '1.0.0',\n  meta: {\n    input: [],\n    output: { type: 'string', description: 'JSON string containing all available atoms and graph format' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: {}, context: Context): Promise<Result> => {\n    if (!context.runtime) {\n      return { success: false, error: 'Runtime not available in context' };\n    }\n    \n    const skillSet = context.runtime.getSkillSet();\n    return { success: true, data: skillSet };\n  },\n};\n\nexport const compileAcsAtom: Atom = {\n  name: 'compileAcs',\n  version: '1.0.0',\n  meta: {\n    input: [\n      { name: 'acs', type: 'string', description: 'ACS string to compile' }\n    ],\n    output: { type: 'object', description: 'Compiled Graph object or error' }\n  },\n  characteristics: { stateless: true, atomic: true, composable: true },\n  execute: async (input: { acs: string }, context: Context): Promise<Result> => {\n    if (typeof input.acs !== 'string') {\n      return { success: false, error: 'Input must be a string' };\n    }\n\n    try {\n      const graph = compileAcs(input.acs);\n\n      if (context.runtime) {\n        const validation = context.runtime.validateGraph(graph);\n        if (!validation.valid) {\n          return { success: false, error: `Graph validation failed: ${validation.errors.join('; ')}` };\n        }\n      }\n\n      return { success: true, data: graph };\n    } catch (e: any) {\n      return { success: false, error: `ACS compilation error: ${e.message}` };\n    }\n  },\n};\n\n\n"]}

package/dist/atoms/judgment.d.ts

@@ -0,0 +1,14 @@
+import { Atom } from '../types';
+export declare const eqAtom: Atom;
+export declare const gtAtom: Atom;
+export declare const ltAtom: Atom;
+export declare const gteAtom: Atom;
+export declare const lteAtom: Atom;
+export declare const andAtom: Atom;
+export declare const orAtom: Atom;
+export declare const notAtom: Atom;
+export declare const isNilAtom: Atom;
+export declare const isNumAtom: Atom;
+export declare const isStrAtom: Atom;
+export declare const isArrAtom: Atom;
+export declare const isObjAtom: Atom;