@kadi.build/core 0.0.1-alpha.2 → 0.0.1-alpha.3

package/src/utils/agentUtils.js

@@ -0,0 +1,137 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Define the paths (these were missing from your agentUtils.js)
+const rootDir = process.cwd();
+const abilitiesDir = path.join(rootDir, 'abilities');
+const projectAgentPath = path.join(rootDir, 'agent.json');
+const kadiCoreAgentPath = path.join(__dirname, '..', 'agent.json');
+
+// You'll need to get these from pathUtils or define them here
+// For now, I'll import them from pathUtils
+import { kadiAgentPath, kadiExecDir, kadiRootDir } from './pathUtils.js';
+
+//Gets the agent.json for the ability, so dependencies can be installed
+export function getAbilityJSON(abilityName, abilityVersion) {
+  //Get the agent.json for the ability
+  let abilityPath = path.join(
+    rootDir,
+    'abilities',
+    abilityName,
+    abilityVersion,
+    'agent.json'
+  );
+  let abilityJSON = fs.readFileSync(abilityPath, 'utf8');
+  abilityJSON = JSON.parse(abilityJSON);
+  return abilityJSON;
+}
+
+//Gets the file path for the ability agent.json
+export function getAbilityJSONPath(abilityName, abilityVersion) {
+  return path.join(
+    rootDir,
+    'abilities',
+    abilityName,
+    abilityVersion,
+    'agent.json'
+  );
+}
+
+//Gets the abilities directory
+export function getAbilitiesDir() {
+  return abilitiesDir;
+}
+
+//Gets the agent.json for the ability, so dependencies can be installed
+export function getProjectJSON() {
+  //Get the agent.json for kadi
+  let projectJSON = fs.readFileSync(projectAgentPath, 'utf8');
+  projectJSON = JSON.parse(projectJSON);
+  return projectJSON;
+}
+
+//Get the file path for the project agent.json
+export function getProjectJSONPath() {
+  return projectAgentPath;
+}
+
+//Get Kadi Core agent.json
+export function getKadiCoreJSON() {
+  //Get the agent.json for kadi
+  let kadiCoreJSON = fs.readFileSync(kadiCoreAgentPath, 'utf8');
+  kadiCoreJSON = JSON.parse(kadiCoreJSON);
+  return kadiCoreJSON;
+}
+
+//Get the file path for the KADI Core Agent.json
+export function getKadiCoreJSONPath() {
+  return kadiCoreAgentPath;
+}
+
+//Gets the agent.json for KADI system
+export function getKadiJSON() {
+  //Get the agent.json for kadi
+  let kadiJSON = fs.readFileSync(kadiAgentPath, 'utf8');
+  kadiJSON = JSON.parse(kadiJSON);
+  return kadiJSON;
+}
+
+//Gets the file path for the KADI Agent.json
+export function getKadiJSONPath() {
+  return kadiAgentPath;
+}
+
+//Get the exec path of the KADI system
+export function getKadiExecPath() {
+  return kadiExecDir;
+}
+
+//Get the Install directory of KADI system
+export function getKadiInstallPath() {
+  return kadiRootDir;
+}
+
+//Save agent.json file
+export async function saveAgentJSON(agentJSON, agentJSONPath) {
+  // Convert the JSON object to a string with pretty-print formatting
+  const jsonString = JSON.stringify(agentJSON, null, 2);
+
+  // Write the JSON string to the specified file
+  fs.writeFile(agentJSONPath, jsonString, 'utf8', (err) => {
+    if (err) {
+      console.error('Error saving JSON to file:', err);
+    }
+    // else {
+    //     console.log('JSON saved successfully to', filePath);
+    // }
+  });
+}
+
+export function getAbilityVersionFromArray(abilities, name) {
+  // Handle both array and object formats for backward compatibility
+  if (Array.isArray(abilities)) {
+    // Old format: abilities is an array of objects with name/version
+    const ability = abilities.find((ability) => ability.name === name);
+    if (ability) {
+      return ability.version;
+    }
+  } else if (abilities && typeof abilities === 'object') {
+    // New format: abilities is an object with name as key and version as value
+    if (name in abilities) {
+      return abilities[name];
+    }
+  }
+  return null;
+}
+
+// Get the API URL from the agent.json
+let kadijson = getKadiJSON();
+
+// Define the API URL (Adjust according to your API)
+export const KADI_API_URL = kadijson.api;
+export const SEARCH_API_URL = kadijson.api + '/search';
+export const GET_API_URL = kadijson.api + '/get';

package/src/utils/commandUtils.js

@@ -0,0 +1,64 @@
+import { exec, spawn } from 'child_process';
+import path from 'path';
+
+// Import rootDir from pathUtils
+import { rootDir } from './pathUtils.js';
+
+//Runs a command line string, used for abilities init functions
+export async function runExecCommand(name, version, command) {
+  let execDirectory;
+  if (name === '' || version === '') {
+    execDirectory = path.join(rootDir);
+  } else {
+    execDirectory = path.join(rootDir, 'abilities', name, version);
+  }
+  console.log('execDirectory: ', execDirectory);
+  return new Promise((resolve, reject) => {
+    exec(
+      command,
+      { cwd: execDirectory, maxBuffer: 1024 * 1024 },
+      (error, stdout, stderr) => {
+        if (error) {
+          console.error(`exec error: ${error}`);
+          reject(error); // Reject the promise on error
+          return;
+        }
+        if (stderr.trim()) {
+          console.error(stderr);
+        }
+        resolve(stdout.trim()); // Resolve the promise when exec completes successfully
+      }
+    );
+  });
+}
+
+export async function runSpawnCommand(name, version, command) {
+  let execDirectory;
+  if (name === '' || version === '') {
+    execDirectory = path.join(rootDir);
+  } else {
+    execDirectory = path.join(rootDir, 'abilities', name, version);
+  }
+  console.log('execDirectory: ', execDirectory);
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, {
+      cwd: execDirectory,
+      stdio: 'inherit', // This pipes the child process's stdio to the parent
+      shell: true // This ensures that the command is run within a shell
+    });
+
+    child.on('error', (error) => {
+      console.error(`Error: ${error}`);
+      reject(error);
+    });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        console.error(`Process exited with code: ${code}`);
+        reject(new Error(`Process exited with code: ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}

package/src/utils/configUtils.js

@@ -0,0 +1,72 @@
+import { getKadiJSON } from './agentUtils.js';
+
+// Get the API URL from the agent.json
+let kadijson = getKadiJSON();
+
+// Export all broker URLs
+const brokers = {};
+if (kadijson.brokers && typeof kadijson.brokers === 'object') {
+  for (const [name, url] of Object.entries(kadijson.brokers)) {
+    const brokerUrl = new URL(url);
+    brokers[name] =
+      `${brokerUrl.hostname}:${brokerUrl.port}${brokerUrl.pathname}`;
+  }
+}
+
+export const KADI_BROKERS = brokers;
+
+// Get default broker (first one defined)
+const defaultBrokerName = kadijson.brokers
+  ? Object.keys(kadijson.brokers)[0]
+  : null;
+export const KADI_BROKER_URL = brokers[defaultBrokerName]; // Backward compatibility
+
+// Utility functions
+export function getBrokerUrl(brokerName) {
+  return brokers[brokerName] || null;
+}
+
+export function getBrokerNames() {
+  return Object.keys(brokers);
+}
+
+export function getDefaultBrokerName() {
+  return defaultBrokerName;
+}
+
+// Active broker selection
+let activeBrokerName = defaultBrokerName;
+
+export function setActiveBroker(brokerName) {
+  if (brokers[brokerName]) {
+    activeBrokerName = brokerName;
+    return true;
+  }
+  return false;
+}
+
+export function getActiveBrokerName() {
+  return activeBrokerName;
+}
+
+export function getActiveBrokerUrl() {
+  return brokers[activeBrokerName];
+}
+
+// Function to find the version of an ability by name
+export function findAbilityVersionByName(abilities, name) {
+  // Handle both array and object formats for backward compatibility
+  if (Array.isArray(abilities)) {
+    // Old format: abilities is an array of objects with name/version
+    const ability = abilities.find((ability) => ability.name === name);
+    if (ability) {
+      return ability.version;
+    }
+  } else if (abilities && typeof abilities === 'object') {
+    // New format: abilities is an object with name as key and version as value
+    if (name in abilities) {
+      return abilities[name];
+    }
+  }
+  return 'No ability found with the specified name.';
+}

package/src/utils/logger.js

@@ -0,0 +1,161 @@
+// src/utils/logger.js
+import debug from 'debug';
+import chalk from 'chalk';
+
+/**
+ * Create namespaced debug loggers for KADI core library
+ *
+ * Namespace structure:
+ * kadi:core:component:subcomponent
+ */
+export const loggers = {
+  // General core functionality
+  core: debug('kadi:core'),
+
+  // Ability-related loggers
+  ability: debug('kadi:core:ability'),
+  abilityLoader: debug('kadi:core:abilityLoader'),
+
+  // Server loggers
+  serverBase: debug('kadi:core:server:base'),
+  serverStdio: debug('kadi:core:server:stdio'),
+  serverBroker: debug('kadi:core:server:broker'),
+
+  // Transport loggers
+  transportStdio: debug('kadi:core:transport:stdio'),
+  transportBroker: debug('kadi:core:transport:broker'),
+  transportIpc: debug('kadi:core:transport:ipc'),
+
+  // Legacy namespaces for backward compatibility
+  loader: debug('kadi:core:abilityLoader'),
+  transport: debug('kadi:core:transport'),
+  broker: debug('kadi:broker'),
+  stdio: debug('kadi:stdio'),
+  server: debug('kadi:core:server')
+};
+
+/**
+ * Create a logger for a specific namespace with color support
+ * @param {string} namespace - The namespace key from loggers object
+ * @returns {Object} Enhanced logger with colored methods
+ */
+export function createLogger(namespace) {
+  // Get the base debug instance - support both new and legacy namespaces
+  const baseLogger = loggers[namespace] || debug(`kadi:core:${namespace}`);
+
+  // Return enhanced logger with colored methods
+  return {
+    // Original debug function
+    debug: baseLogger,
+
+    // Colored log methods
+    log: (...args) => baseLogger(...args),
+    info: (msg, ...args) => baseLogger(chalk.blue('ℹ ' + msg), ...args),
+    success: (msg, ...args) => baseLogger(chalk.green('✓ ' + msg), ...args),
+    warn: (msg, ...args) => baseLogger(chalk.yellow('⚠ ' + msg), ...args),
+    error: (msg, ...args) => baseLogger(chalk.red('✗ ' + msg), ...args),
+    trace: (msg, ...args) => baseLogger(chalk.gray('→ ' + msg), ...args),
+
+    // Special formatting
+    highlight: (msg, ...args) => baseLogger(chalk.cyan(msg), ...args),
+    dim: (msg, ...args) => baseLogger(chalk.dim(msg), ...args),
+    bold: (msg, ...args) => baseLogger(chalk.bold(msg), ...args),
+
+    // Method-specific formatting
+    methodCall: (method, ...args) =>
+      baseLogger(chalk.magenta(`[${method}]`), ...args),
+    lifecycle: (event, ...args) =>
+      baseLogger(chalk.yellow(`◯ ${event}`), ...args),
+    request: (id, method, ...args) =>
+      baseLogger(chalk.cyan(`→ [${id}] ${method}`), ...args),
+    response: (id, status, ...args) => {
+      const color = status === 'success' ? chalk.green : chalk.red;
+      baseLogger(color(`← [${id}] ${status}`), ...args);
+    },
+
+    // Check if enabled
+    enabled: baseLogger.enabled,
+    namespace: baseLogger.namespace
+  };
+}
+
+/**
+ * Create a logger for a specific component
+ * Maps component names to their appropriate namespace
+ *
+ * @param {string} component - Component name (e.g., 'KadiAbility', 'StdioRpcServer')
+ * @returns {Object} Enhanced logger
+ */
+export function createComponentLogger(component) {
+  const componentMap = {
+    KadiAbility: 'ability',
+    loadAbility: 'abilityLoader',
+    BaseRpcServer: 'serverBase',
+    StdioRpcServer: 'serverStdio',
+    BrokerRpcServer: 'serverBroker',
+    StdioTransport: 'transportStdio',
+    BrokerTransport: 'transportBroker',
+    IpcServer: 'transportIpc',
+    StdioFrameReader: 'transportStdio',
+    StdioFrameWriter: 'transportStdio',
+    BrokerMessageBuilder: 'transportBroker'
+  };
+
+  const namespace = componentMap[component] || 'core';
+  return createLogger(namespace);
+}
+
+/**
+ * Utility to check if debug is enabled for a namespace
+ * Useful for expensive operations that should only run when debugging
+ *
+ * @param {string} namespace
+ * @returns {boolean}
+ */
+export function isDebugEnabled(namespace) {
+  const logger = loggers[namespace] || createLogger(namespace);
+  return logger.enabled;
+}
+
+/**
+ * Format an object for debug output
+ * @param {any} obj - Object to format
+ * @param {string} label - Optional label
+ * @returns {string}
+ */
+export function formatObject(obj, label = '') {
+  if (typeof obj !== 'object' || obj === null) {
+    return label ? `${label}: ${obj}` : String(obj);
+  }
+
+  try {
+    const json = JSON.stringify(obj, null, 2);
+    return label ? `${label}:\n${json}` : json;
+  } catch (err) {
+    return label
+      ? `${label}: [Circular or non-serializable object]`
+      : '[Circular object]';
+  }
+}
+
+/**
+ * Create a child logger with additional context
+ * Useful for adding request IDs or session context
+ *
+ * @param {debug.Debugger} parentLogger
+ * @param {string} context
+ * @returns {debug.Debugger}
+ */
+export function createChildLogger(parentLogger, context) {
+  const namespace = parentLogger.namespace;
+  return debug(`${namespace}:${context}`);
+}
+
+export default {
+  loggers,
+  createLogger,
+  createComponentLogger,
+  isDebugEnabled,
+  formatObject,
+  createChildLogger
+};

package/src/utils/pathUtils.js

@@ -0,0 +1,86 @@
+import path from 'path';
+import fs from 'fs';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+export function resolveKadiExecPath() {
+  const command = process.platform === 'win32' ? 'where kadi' : 'which kadi';
+
+  try {
+    const kadiPath = execSync(command, { encoding: 'utf8' }).trim();
+    if (kadiPath) {
+      return kadiPath;
+    } else {
+      throw new Error('Kadi CLI tool not found in the system PATH');
+    }
+  } catch (error) {
+    console.error('Error resolving Kadi path:', error);
+    return null;
+  }
+}
+
+export function resolveKadiInstallPath() {
+  /* 1 - production / normal install -------------------------------- */
+  try {
+    if (typeof import.meta.resolve === 'function') {
+      const p = import.meta.resolve('@kadi.build/cli/package.json');
+      if (p) return path.dirname(new URL(p).pathname);
+    }
+  } catch {
+    /* ignore – fall through */
+  }
+
+  /* 2 - legacy strategy – follow the kadi executable --------------- */
+  try {
+    const cmd = process.platform === 'win32' ? 'where kadi' : 'which kadi';
+    const kadiBinaryPath = execSync(cmd, { encoding: 'utf8' }).trim();
+    if (!kadiBinaryPath) {
+      throw new Error('Kadi CLI tool not found in the system PATH');
+    }
+    const realKadiBinaryPath = fs.realpathSync(kadiBinaryPath); // resolve symlink
+    let kadiDir = path.dirname(realKadiBinaryPath); // start alongside the binary
+
+    const kadiPackageJsonPath = path.join(kadiDir, 'package.json');
+    if (fs.existsSync(kadiPackageJsonPath)) {
+      const kadiPackageJson = JSON.parse(
+        fs.readFileSync(kadiPackageJsonPath, 'utf8')
+      );
+      if (
+        kadiPackageJson.name === '@kadi.build/cli' ||
+        (kadiPackageJson.bin && kadiPackageJson.bin.kadi)
+      ) {
+        return kadiDir;
+      } else {
+        throw new Error(
+          'Package.json found, but it is not for @kadi.build/cli'
+        );
+      }
+    } else {
+      throw new Error(
+        '@kadi.build/cli package.json not found in the resolved path.'
+      );
+    }
+  } catch {
+    /* ignore – fall through */
+  }
+
+  /* 3 - give up ----------------------------------------------------- */
+  throw new Error(
+    'Could not locate @kadi.build/cli installation. ' +
+      'Make sure the CLI is installed (`npm i -g @kadi.build/cli`) ' +
+      'or run commands from inside the CLI repository during development.'
+  );
+}
+
+// Export the resolved paths
+export const kadiExecDir = resolveKadiExecPath();
+export const kadiRootDir = resolveKadiInstallPath();
+export const kadiAgentPath = path.join(kadiRootDir, 'agent.json');
+
+export const rootDir = process.cwd();
+export const abilitiesDir = path.join(rootDir, 'abilities');
+export const projectAgentPath = path.join(rootDir, 'agent.json');
+export const kadiCoreAgentPath = path.join(__dirname, '..', 'agent.json');