johankit-runtime 0.0.2 → 0.4.3

package/src/core/register/decorators.js

@@ -1,150 +0,0 @@
-const path = require('path');
-const fs = require('fs').promises;
-
-const { parseTool } = require('../parse/tools');
-const { parseHook } = require('../parse/hooks');
-const { parseCognite } = require('../parse/cognites');
-const { parseRouter } = require('../parse/routes');
-const { parsePredicate } = require('../parse/predicates');
-const { parseMiddleware } = require('../parse/middleware');
-
-async function getJsFilesRecursively(dir) {
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  const tasks = entries.map(async entry => {
-    const fullPath = path.join(dir, entry.name);
-    if (entry.isDirectory()) return getJsFilesRecursively(fullPath);
-    if (entry.isFile() && entry.name.endsWith('.js')) return [fullPath];
-    return [];
-  });
-  const results = await Promise.all(tasks);
-  return results.flat();
-}
-
-async function isRelevantFile(filePath) {
-  try {
-    const content = await fs.readFile(filePath, 'utf-8');
-    return content.includes('@register_');
-  } catch {
-    return false;
-  }
-}
-
-function extractExportedFunctions(mod) {
-  if (typeof mod === 'function') return [mod];
-  if (typeof mod === 'object' && mod !== null) return Object.values(mod);
-  return [];
-}
-
-async function registerGeneric(agentFolder, parser, mapFn) {
-  const baseDir = process.env.PACKAGES_PATH || path.resolve(__dirname, '..', '..', 'packages');
-  
-  let folderPath;
-  if (path.isAbsolute(String(agentFolder))) {
-    folderPath = agentFolder;
-  } else if (String(agentFolder).includes('packages')) {
-    const folderName = path.basename(agentFolder);
-    folderPath = path.join(baseDir, folderName);
-  } else {
-    folderPath = path.join(baseDir, String(agentFolder));
-  }
-
-  try {
-    await fs.access(folderPath);
-  } catch {
-    throw new Error(`Folder not found: ${folderPath}`);
-  }
-
-  const files = await getJsFilesRecursively(folderPath);
-
-  const results = await Promise.all(
-    files.map(async filePath => {
-      if (!(await isRelevantFile(filePath))) return [];
-      try {
-        const absolutePath = path.resolve(filePath);
-        delete require.cache[require.resolve(absolutePath)];
-        const mod = require(absolutePath);
-
-        return extractExportedFunctions(mod)
-          .map(fn => {
-            const meta = parser(fn);
-            if (!meta) return null;
-            return mapFn(meta);
-          })
-          .filter(Boolean);
-      } catch (err) {
-        console.warn(`Erro ao registrar em ${filePath}:`, err.message);
-        return [];
-      }
-    })
-  );
-
-  return results.flat();
-}
-
-function registerTools(agentFolder) {
-  return registerGeneric(agentFolder, parseTool, meta => {
-    const tool = {
-      name: meta.name,
-      description: meta.description,
-      parameters: {
-        type: 'object',
-        properties: (meta.parameters || []).reduce((acc, p) => {
-          acc[p.name] = { type: p.type === 'array' ? 'array' : p.type, description: p.description };
-          if (p.type === 'array') acc[p.name].items = { type: 'object' };
-          return acc;
-        }, {}),
-        required: (meta.parameters || []).filter(p => p.required).map(p => p.name),
-      },
-      call: meta.call,
-    };
-    if (meta.condition) tool.condition = meta.condition;
-    return tool;
-  });
-}
-
-function registerHooks(agentFolder) {
-  return registerGeneric(agentFolder, parseHook, meta => {
-    const hook = { event: meta.event, call: meta.call };
-    if (meta.condition) hook.condition = meta.condition;
-    return hook;
-  });
-}
-
-function registerCognites(agentFolder) {
-  return registerGeneric(agentFolder, parseCognite, meta => ({
-    name: meta.name,
-    description: meta.description,
-    execute: meta.execute,
-    options: meta.options || {},
-  }));
-}
-
-function registerRoutes(agentFolder) {
-  return registerGeneric(agentFolder, parseRouter, meta => ({
-    path: meta.path,
-    method: meta.method || 'get',
-    handler: meta.handler,
-  }));
-}
-
-async function registerPredicates(agentFolder) {
-  const preds = await registerGeneric(agentFolder, parsePredicate, meta => meta);
-  return Object.fromEntries(preds.map(p => [p.name, p.call]));
-}
-
-function registerMiddlewares(agentFolder) {
-  return registerGeneric(agentFolder, parseMiddleware, meta => ({
-    name: meta.name,
-    call: meta.call,
-    predicates: meta.predicates || []
-  }));
-}
-
-module.exports = {
-  registerTools,
-  registerHooks,
-  registerCognites,
-  registerRoutes,
-  registerPredicates,
-  registerMiddlewares
-};

package/src/core/register/decorators.test.js

@@ -1,13 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import fs from 'fs/promises';
-import path from 'path';
-const { registerTools } = require('./decorators');
-
-vi.mock('fs/promises');
-
-describe('decorators register', () => {
-  it('should throw error if folder does not exist', async () => {
-    fs.access.mockRejectedValue(new Error());
-    await expect(registerTools('invalid')).rejects.toThrow('Folder not found');
-  });
-});

package/src/core/register.js

@@ -1,37 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const yaml = require('js-yaml');
-
-const { getPackages, registerPackage } = require('./package');
-const { registerRoutes } = require('./routes');
-const { log } = console;
-
-const registerPackages = async (app) => {
-    try {
-        const packagesList = await getPackages();
-
-        for (const pkg of packagesList) {
-            const ymlPath = path.join(__dirname, '..', 'packages', pkg.folder, 'agent.yml');
-
-            const exists = fs.existsSync(ymlPath);
-            if (exists) {
-                try {
-                    const fileContents = fs.readFileSync(ymlPath, 'utf8');
-                    const ymlObject = yaml.load(fileContents);
-                    pkg.config = ymlObject;
-                    
-                    log(`Loaded YAML for package: ${JSON.stringify(pkg.config)}`);
-                } catch (err) {
-                    log(`Error reading YAML for ${pkg.folder}: ${err.message}`);
-                }
-            }
-
-            await registerRoutes(app, pkg);
-            await registerPackage(app, pkg);
-        }
-    } catch (err) {
-        log(JSON.stringify(err), "red");
-    }
-};
-
-module.exports = { registerPackages };

package/src/core/routes.js

@@ -1,89 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const { registerRoutes: routesDecorators, registerCognites, registerPredicates, registerMiddlewares } = require("./register/decorators");
-
-const { log } = console;
-
-const getRoutes = () => {
-    const routes = [];
-    const baseDir = process.env.PACKAGES_PATH || path.resolve(__dirname, '..', 'packages');
-
-    try {
-        fs.readdirSync(baseDir).forEach(packageDir => {
-            const routesPath = path.join(baseDir, packageDir, 'routes.js');
-
-            if (fs.existsSync(routesPath)) {
-                const routeModule = require(path.resolve(routesPath));
-                routeModule.map(router => router.dir = packageDir);
-
-                routes.push(...routeModule);
-            }
-        });
-    } catch (error) {
-        console.error("Error with Routes:", error);
-        return [];
-    }
-
-    return routes;
-};
-
-const registerRoutes = async (app, pkg) => {
-    const basePackagesPath = process.env.PACKAGES_PATH || path.resolve(__dirname, '..', 'packages');
-    const packageDir = path.join(basePackagesPath, pkg.folder);
-    const routesRegex = /^routes\.(js|tsx)$/;
-    const files = fs.readdirSync(packageDir);
-    const routesFile = files.find((file) => routesRegex.test(file));
-
-    const _routesDecorators = await routesDecorators(pkg.folder);
-
-    const predicates = await registerPredicates(pkg.folder);
-    const middlewares = await registerMiddlewares(pkg.folder);
-
-    let allow_middlewares = [];
-
-    middlewares.map(middleware => {
-        middleware.predicates.map(predicate => {
-            if (predicates[predicate]) {
-                try {
-                    if ( predicates[predicate]() ) {
-                        allow_middlewares.push( middleware.call );
-                    }
-                } catch(err) {
-                }
-            }
-        });
-    });
-
-    let _routesFile = [];
-
-    const allRoutes = [..._routesDecorators, ..._routesFile];
-
-    if (allRoutes.length === 0) {
-        return;
-    }
-
-    allRoutes.forEach((route) => {
-        if (route.handler && route.method && route.path) {
-            app[route.method](`/${pkg.folder}/${route.path}`, [...allow_middlewares, async (req, res, next) => {
-                try {
-                    const payload = await route.handler(req, res, next);
-                    const { status = 200, data = payload } = payload || {};
-                    res.status(status).json(data);
-                } catch (err) {
-                    next(err);
-                }
-            }]);
-
-            log(`${pkg.name ?? pkg.folder} registered decorator route [${route.method.toUpperCase()}] /${pkg.folder}/${route.path}`, 'gray');
-        } 
-        else if (route.call && route.method && route.router) {
-            app[route.method](`/${pkg.folder}/${route.router}`, route.call);
-            log(`${pkg.name} registered file route [${route.method.toUpperCase()}] /${pkg.folder}/${route.router}`, 'gray');
-        } 
-        else {
-            log(`Invalid route configuration for ${pkg.name}: ${JSON.stringify(route)}`, 'error');
-        }
-    });
-};
-
-module.exports = { getRoutes, registerRoutes }

package/src/index.ts

@@ -1,42 +0,0 @@
-import path from 'path'
-import http from 'http'
-import app from './app'
-import { dispatchEvent } from './core/event/dispatch'
-import type { BootstrapConfig, JohankitApp } from './types'
-
-export async function bootstrap(config: BootstrapConfig = {}) {
-  const customPath = config.workspace || path.join(__dirname, 'packages')
-  const resolvedWorkspace = path.isAbsolute(customPath)
-    ? customPath
-    : path.resolve(process.cwd(), customPath)
-
-  process.env.PACKAGES_PATH = resolvedWorkspace
-
-  const result: any = {}
-
-  await app.setup()
-  result.app = app as JohankitApp
-
-  if (config.mcp?.enabled) {
-    const { bootstrapMcp } = require('./core/mcp/tools-mcp')
-    result.mcp = await bootstrapMcp(resolvedWorkspace)
-  }
-
-  if (config.mcp?.http?.enabled) {
-    const { createMcpHttpServer } = require('./core/mcp/http-server')
-    result.mcpHttp = await createMcpHttpServer({
-      workspace: resolvedWorkspace,
-      port: config.mcp.http.port
-    })
-  }
-
-  if (config.http?.enabled !== false) {
-    const port = config.http?.port || (process.env.PORT ? Number(process.env.PORT) : 5040)
-    result.server = http.createServer(app)
-    result.server.listen(port)
-  }
-
-  return result
-}
-
-export { dispatchEvent }

package/src/server.ts

@@ -1,15 +0,0 @@
-import http from 'http'
-import app from './app'
-
-const port = process.env.PORT ? Number(process.env.PORT) : 5040
-
-app
-  .setup()
-  .then(() => {
-    http.createServer(app).listen(port, () => {
-      console.log(`Server is ready on port: ${port}.\n`)
-    })
-  })
-  .catch(err => {
-    console.error('Error during app setup:', err)
-  })

package/src/types.ts

@@ -1,104 +0,0 @@
-import type { Application, Request, Response, NextFunction } from 'express';
-
-export interface BootstrapConfig {
-  workspace?: string;
-  http?: {
-    enabled?: boolean;
-    port?: number;
-  };
-  mcp?: {
-    enabled?: boolean;
-    http?: {
-      enabled?: boolean;
-      port?: number;
-    };
-  };
-}
-
-export interface RoutePayload {
-  status?: number;
-  data?: any;
-}
-
-export type RouteHandler = (
-  req: Request,
-  res: Response,
-  next: NextFunction
-) => Promise<RoutePayload | any> | RoutePayload | any;
-
-export interface RegisteredRoute {
-  path: string;
-  method: string;
-  handler: RouteHandler;
-}
-
-export interface HookCondition {
-  only?: string[];
-  never?: string[];
-  when?: string[];
-}
-
-export interface RegisteredHook<T = any> {
-  event: string;
-  call: (payload: T) => Promise<T | void | null> | T | void | null;
-  condition?: HookCondition;
-}
-
-export interface RegisteredPredicate {
-  name: string;
-  call: () => boolean | Promise<boolean>;
-}
-
-export interface RegisteredMiddleware {
-  name: string;
-  call: (req: Request, res: Response, next: NextFunction) => any;
-  predicates?: string[];
-}
-
-export interface ToolParameter {
-  name: string;
-  type: string;
-  description?: string;
-  required?: boolean;
-}
-
-export interface RegisteredTool {
-  name: string;
-  description?: string;
-  parameters: {
-    type: 'object';
-    properties: Record<string, any>;
-    required?: string[];
-  };
-  call: (args: any) => any;
-  condition?: HookCondition;
-}
-
-export interface RegisteredCognite {
-  name: string;
-  execute: (...args: any[]) => any;
-  description?: string;
-  options?: Record<string, any>;
-}
-
-export interface PackageManifest {
-  name?: string;
-  version?: string;
-  entry?: string;
-  folder: string;
-  dir?: string;
-  config?: any;
-}
-
-export interface JohankitApp extends Application {
-  setup: () => Promise<void>;
-}
-
-export declare function bootstrap(
-  config?: BootstrapConfig
-): Promise<any>;
-
-export declare function dispatchEvent<T = any>(
-  eventName: string,
-  payload: T
-): Promise<T>;