@agentrix/shared 2.2.4 → 2.2.5

package/dist/node.cjs

@@ -0,0 +1,254 @@
+'use strict';
+
+var node_fs = require('node:fs');
+var node_path = require('node:path');
+var errors = require('./errors-myQvpVrM.cjs');
+var os = require('node:os');
+require('zod');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var os__namespace = /*#__PURE__*/_interopNamespaceDefault(os);
+
+function validateAgentDirectory(agentDir) {
+  const errors = [];
+  const warnings = [];
+  if (!node_fs.existsSync(agentDir)) {
+    errors.push(`Agent directory does not exist: ${agentDir}`);
+    return { valid: false, errors, warnings };
+  }
+  if (!node_fs.statSync(agentDir).isDirectory()) {
+    errors.push(`Path is not a directory: ${agentDir}`);
+    return { valid: false, errors, warnings };
+  }
+  const agentJsonPath = node_path.join(agentDir, "agent.json");
+  if (!node_fs.existsSync(agentJsonPath)) {
+    errors.push("Missing required file: agent.json");
+  }
+  const readmePath = node_path.join(agentDir, "README.md");
+  if (!node_fs.existsSync(readmePath)) {
+    warnings.push("Missing README.md (recommended)");
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function validateFrameworkDirectory(frameworkDir, framework) {
+  const errors = [];
+  const warnings = [];
+  if (!node_fs.existsSync(frameworkDir)) {
+    errors.push(`Framework directory does not exist: ${frameworkDir}`);
+    return { valid: false, errors, warnings };
+  }
+  const configPath = node_path.join(frameworkDir, "config.json");
+  if (!node_fs.existsSync(configPath)) {
+    errors.push(`Missing required file: ${framework}/config.json`);
+  }
+  if (framework === "claude") {
+    const mcpServersDir = node_path.join(frameworkDir, "mcp-servers");
+    if (!node_fs.existsSync(mcpServersDir)) {
+      warnings.push("Missing mcp-servers directory (optional)");
+    }
+    const skillsDir = node_path.join(frameworkDir, "skills");
+    if (!node_fs.existsSync(skillsDir)) {
+      warnings.push("Missing skills directory (optional)");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings
+  };
+}
+function assertFileExists(filePath, description) {
+  if (!node_fs.existsSync(filePath)) {
+    throw new errors.MissingAgentFileError(description || filePath);
+  }
+}
+function assertAgentExists(agentDir, agentId) {
+  if (!node_fs.existsSync(agentDir)) {
+    throw new errors.AgentNotFoundError(agentId);
+  }
+}
+
+function discoverPlugins(pluginsDir) {
+  if (!node_fs.existsSync(pluginsDir)) {
+    return [];
+  }
+  return node_fs.readdirSync(pluginsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => node_path.join(pluginsDir, dirent.name)).filter((pluginPath) => isValidPluginDirectory(pluginPath));
+}
+function isValidPluginDirectory(pluginDir) {
+  const manifestPath = node_path.join(pluginDir, ".claude-plugin", "plugin.json");
+  return node_fs.existsSync(manifestPath);
+}
+
+async function loadAgentConfig(options) {
+  const { agentId, framework, validateOnly = false, agentDir: providedAgentDir } = options;
+  const agentContext = errors.getAgentContext();
+  const agentDir = providedAgentDir || agentContext.resolveAgentDir(agentId);
+  assertAgentExists(agentDir, agentId);
+  const validation = validateAgentDirectory(agentDir);
+  if (!validation.valid) {
+    throw new errors.AgentConfigValidationError(
+      `Agent directory validation failed for "${agentId}"`,
+      validation.errors
+    );
+  }
+  if (validation.warnings.length > 0) {
+    console.warn(`[AGENT] Warnings for agent "${agentId}":`, validation.warnings);
+  }
+  const metadata = await loadAgentMetadata(agentDir);
+  const frameworkDirName = framework === "claude" ? "claude" : `.${framework}`;
+  const frameworkDir = node_path.join(agentDir, frameworkDirName);
+  if (!node_fs.existsSync(frameworkDir)) {
+    throw new errors.FrameworkNotSupportedError(agentId, framework);
+  }
+  if (validateOnly) {
+    return {
+      metadata,
+      framework
+    };
+  }
+  if (framework === "claude") {
+    const claudeConfig = await loadClaudeConfiguration(agentDir);
+    return {
+      metadata,
+      framework,
+      claude: claudeConfig
+    };
+  }
+  throw new errors.AgentLoadError(`Framework "${framework}" loader not implemented`);
+}
+async function loadAgentMetadata(agentDir) {
+  const agentJsonPath = node_path.join(agentDir, "agent.json");
+  assertFileExists(agentJsonPath, "agent.json");
+  try {
+    const content = node_fs.readFileSync(agentJsonPath, "utf-8");
+    const rawData = JSON.parse(content);
+    const metadata = errors.AgentMetadataSchema.parse(rawData);
+    return metadata;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new errors.AgentConfigValidationError("Invalid JSON in agent.json");
+    }
+    throw new errors.AgentConfigValidationError(
+      `Invalid agent metadata: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function loadClaudeConfiguration(agentDir, metadata) {
+  const claudeDir = node_path.join(agentDir, "claude");
+  const validation = validateFrameworkDirectory(claudeDir, "claude");
+  if (!validation.valid) {
+    throw new errors.AgentConfigValidationError(
+      "Claude framework directory validation failed",
+      validation.errors
+    );
+  }
+  const config = await loadClaudeConfig(claudeDir);
+  let systemPrompt;
+  if (config.systemPrompt) {
+    systemPrompt = await loadSystemPrompt(claudeDir, config.systemPrompt.path);
+  }
+  let prPromptTemplate;
+  if (config.pullRequestPrompt) {
+    prPromptTemplate = await loadSystemPrompt(claudeDir, config.pullRequestPrompt.path);
+  }
+  const pluginsDir = node_path.join(claudeDir, "plugins");
+  const plugins = discoverPlugins(pluginsDir);
+  return {
+    config,
+    systemPrompt,
+    prPromptTemplate,
+    plugins
+  };
+}
+async function loadClaudeConfig(claudeDir) {
+  const configPath = node_path.join(claudeDir, "config.json");
+  assertFileExists(configPath, "claude/config.json");
+  try {
+    const content = node_fs.readFileSync(configPath, "utf-8");
+    const rawConfig = JSON.parse(content);
+    const config = errors.ClaudeConfigSchema.parse(rawConfig);
+    return config;
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new errors.AgentConfigValidationError(
+        "Invalid JSON in claude/config.json"
+      );
+    }
+    throw new errors.AgentConfigValidationError(
+      `Invalid Claude configuration: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function loadSystemPrompt(claudeDir, promptFile) {
+  const promptPath = node_path.join(claudeDir, promptFile);
+  if (!node_fs.existsSync(promptPath)) {
+    throw new errors.MissingAgentFileError(`claude/${promptFile}`);
+  }
+  try {
+    return node_fs.readFileSync(promptPath, "utf-8");
+  } catch (error) {
+    throw new errors.AgentLoadError(
+      `Failed to read system prompt: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function replacePromptPlaceholders(template, cwd, extra) {
+  const vars = {
+    WORKING_DIR: cwd,
+    PLATFORM: process.platform,
+    OS_VERSION: `${os__namespace.type()} ${os__namespace.release()}`,
+    DATE: (/* @__PURE__ */ new Date()).toISOString().split("T")[0],
+    ...extra
+  };
+  let result = template.replace(
+    /\{\{#if\s+(\w+)\s*(==|!=)\s*(\w+)\}\}([\s\S]*?)\{\{\/if\}\}/g,
+    (_match, key, op, expected, content) => {
+      const actual = vars[key] ?? "";
+      const matches = op === "==" ? actual === expected : actual !== expected;
+      return matches ? content : "";
+    }
+  );
+  for (const [key, value] of Object.entries(vars)) {
+    result = result.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value);
+  }
+  return result;
+}
+
+exports.AgentConfigValidationError = errors.AgentConfigValidationError;
+exports.AgentError = errors.AgentError;
+exports.AgentLoadError = errors.AgentLoadError;
+exports.AgentMetadataSchema = errors.AgentMetadataSchema;
+exports.AgentNotFoundError = errors.AgentNotFoundError;
+exports.ClaudeConfigSchema = errors.ClaudeConfigSchema;
+exports.FRAMEWORK_TYPES = errors.FRAMEWORK_TYPES;
+exports.FrameworkNotSupportedError = errors.FrameworkNotSupportedError;
+exports.MissingAgentFileError = errors.MissingAgentFileError;
+exports.getAgentContext = errors.getAgentContext;
+exports.setAgentContext = errors.setAgentContext;
+exports.assertAgentExists = assertAgentExists;
+exports.assertFileExists = assertFileExists;
+exports.discoverPlugins = discoverPlugins;
+exports.loadAgentConfig = loadAgentConfig;
+exports.replacePromptPlaceholders = replacePromptPlaceholders;
+exports.validateAgentDirectory = validateAgentDirectory;
+exports.validateFrameworkDirectory = validateFrameworkDirectory;

package/dist/node.d.cts

@@ -0,0 +1,52 @@
+import { aT as LoadAgentOptions, b as AgentConfig, cH as ValidationResult, aD as FrameworkType } from './errors-vTk-66-R.cjs';
+export { c as AgentConfigValidationError, d as AgentContext, e as AgentError, f as AgentLoadError, g as AgentMetadata, h as AgentMetadataSchema, i as AgentNotFoundError, j as AgentrixContext, X as ClaudeAgentConfig, Y as ClaudeConfigSchema, au as FRAMEWORK_TYPES, aC as FrameworkNotSupportedError, aG as HookFactory, b3 as MissingAgentFileError, bn as RepositoryInitHookInput, d7 as getAgentContext, di as setAgentContext } from './errors-vTk-66-R.cjs';
+import '@anthropic-ai/claude-agent-sdk';
+import 'zod';
+
+/**
+ * Agent configuration loader - main entry point for loading agent configurations
+ */
+
+declare function loadAgentConfig(options: LoadAgentOptions): Promise<AgentConfig>;
+declare function replacePromptPlaceholders(template: string, cwd: string, extra?: Record<string, string>): string;
+
+/**
+ * Agent directory structure and configuration validation
+ */
+
+/**
+ * Validate that agent directory exists and has basic structure
+ */
+declare function validateAgentDirectory(agentDir: string): ValidationResult;
+/**
+ * Validate framework-specific directory structure
+ */
+declare function validateFrameworkDirectory(frameworkDir: string, framework: FrameworkType): ValidationResult;
+/**
+ * Assert that a file exists, throw error if not
+ */
+declare function assertFileExists(filePath: string, description?: string): void;
+/**
+ * Assert that agent directory exists
+ */
+declare function assertAgentExists(agentDir: string, agentId: string): void;
+
+/**
+ * Plugin loader for agent system
+ *
+ * Auto-discovers plugins in the plugins directory by looking for
+ * directories containing .claude-plugin/plugin.json manifest files.
+ * The SDK handles manifest parsing - we only need to verify existence.
+ */
+/**
+ * Discover plugins in the plugins directory
+ *
+ * Scans the plugins directory for subdirectories containing valid plugin manifests
+ * (.claude-plugin/plugin.json). Returns absolute paths to valid plugin directories.
+ *
+ * @param pluginsDir - Path to claude/plugins/ directory
+ * @returns Array of absolute paths to valid plugin directories
+ */
+declare function discoverPlugins(pluginsDir: string): string[];
+
+export { AgentConfig, FrameworkType, LoadAgentOptions, ValidationResult, assertAgentExists, assertFileExists, discoverPlugins, loadAgentConfig, replacePromptPlaceholders, validateAgentDirectory, validateFrameworkDirectory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentrix/shared",
-  "version": "2.2.4",
+  "version": "2.2.5",
   "description": "Shared types and schemas for Agentrix projects",
   "main": "./dist/index.cjs",
   "types": "./dist/index.d.cts",
@@ -8,6 +8,10 @@
     ".": {
       "types": "./dist/index.d.cts",
       "default": "./dist/index.cjs"
+    },
+    "./node": {
+      "types": "./dist/node.d.cts",
+      "default": "./dist/node.cjs"
     }
   },
   "scripts": {
@@ -17,7 +21,9 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.31",
     "@anthropic-ai/sdk": "^0.71.2",
+    "@types/crypto-js": "^4.2.2",
     "base64-js": "^1.5.1",
+    "crypto-js": "^4.2.0",
     "tweetnacl": "^1.0.3",
     "zod": "^4.0.0"
   },