@deimoscloud/coreai 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deimoscloud/coreai",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "A configurable, team-ready AI agent orchestration platform",
   "type": "module",
   "main": "dist/index.js",

package/src/agents/compiler.ts

@@ -8,6 +8,7 @@ import { existsSync, mkdirSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import type { CoreAIConfig } from '../config/types.js';
 import type { AgentDefinition, AgentMetadata, AgentSource } from './types.js';
+import { DEFAULT_AGENT_TOOLS } from './types.js';
 import { loadAgentsFromDirectory } from './loader.js';
 import { resolveAgentDefinition } from './resolver.js';
 
@@ -44,6 +45,13 @@ export interface CompileOptions {
    * Returns true to include the agent, false to exclude.
    */
   filter?: (agent: AgentDefinition) => boolean;
+
+  /**
+   * MCP server names to include as tools.
+   * These will be added to the agent's tools as mcp__<server-name>.
+   * Example: ['github', 'postgres'] -> 'mcp__github, mcp__postgres'
+   */
+  mcpServers?: string[];
 }
 
 /**
@@ -69,12 +77,53 @@ export interface CompileResult {
   }[];
 }
 
+/**
+ * Build the tools string for agent frontmatter
+ *
+ * @param agent - Agent definition (may have custom tools)
+ * @param mcpServers - Optional MCP server names to include
+ * @returns Comma-separated list of tools
+ */
+export function buildAgentTools(agent: AgentDefinition, mcpServers?: string[]): string {
+  // Start with agent-specific tools or defaults
+  const tools: string[] = agent.tools
+    ? [...agent.tools]
+    : [...DEFAULT_AGENT_TOOLS];
+
+  // Add MCP tools if servers are specified
+  if (mcpServers && mcpServers.length > 0) {
+    for (const server of mcpServers) {
+      tools.push(`mcp__${server}`);
+    }
+  }
+
+  return tools.join(', ');
+}
+
 /**
  * Generate markdown content from a resolved agent definition
+ *
+ * The output includes YAML frontmatter required by Claude Code for subagent detection.
+ * See: https://code.claude.com/docs/en/sub-agents
+ *
+ * @param agent - Resolved agent definition
+ * @param mcpServers - Optional MCP server names to include as tools
  */
-export function generateAgentMarkdown(agent: AgentDefinition): string {
+export function generateAgentMarkdown(agent: AgentDefinition, mcpServers?: string[]): string {
   const lines: string[] = [];
 
+  // Build tools string
+  const tools = buildAgentTools(agent, mcpServers);
+
+  // YAML frontmatter (required by Claude Code for subagent detection)
+  lines.push('---');
+  lines.push(`name: ${agent.role}`);
+  // Flatten description to single line for YAML frontmatter
+  lines.push(`description: ${agent.description.replace(/\n/g, ' ').trim()}`);
+  lines.push(`tools: ${tools}`);
+  lines.push('---');
+  lines.push('');
+
   // Header
   lines.push(`# ${agent.display_name}`);
   lines.push('');
@@ -235,10 +284,18 @@ function formatTitle(str: string): string {
 
 /**
  * Compile a single agent to markdown
+ *
+ * @param agent - Agent definition to compile
+ * @param config - Optional CoreAI config for variable resolution
+ * @param mcpServers - Optional MCP server names to include as tools
  */
-export function compileAgent(agent: AgentDefinition, config?: CoreAIConfig): string {
+export function compileAgent(
+  agent: AgentDefinition,
+  config?: CoreAIConfig,
+  mcpServers?: string[]
+): string {
   const resolved = resolveAgentDefinition(agent, config);
-  return generateAgentMarkdown(resolved);
+  return generateAgentMarkdown(resolved, mcpServers);
 }
 
 /**
@@ -328,7 +385,7 @@ export function compileAgents(config?: CoreAIConfig, options: CompileOptions = {
     }
 
     try {
-      const markdown = compileAgent(metadata.definition, config);
+      const markdown = compileAgent(metadata.definition, config, options.mcpServers);
       const outputPath = join(outputDir, `${role}.md`);
 
       writeFileSync(outputPath, markdown, 'utf-8');

package/src/agents/index.ts

@@ -25,6 +25,7 @@ export {
   type ResolutionOptions,
 } from './resolver.js';
 export {
+  buildAgentTools,
   generateAgentMarkdown,
   compileAgent,
   compileAgents,

package/src/agents/types.ts

@@ -42,6 +42,11 @@ export interface AgentCommunication {
   outbox?: string;
 }
 
+/**
+ * Default Claude Code tools available to agents
+ */
+export const DEFAULT_AGENT_TOOLS = ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep'] as const;
+
 /**
  * Raw agent definition as loaded from YAML (before variable resolution)
  */
@@ -57,6 +62,11 @@ export interface AgentDefinition {
   behaviors?: AgentBehaviors;
   context_sources?: AgentContextSources;
   communication?: AgentCommunication;
+  /**
+   * Claude Code tools available to this agent.
+   * If not specified, defaults to: Read, Write, Edit, Bash, Glob, Grep
+   */
+  tools?: string[];
 }
 
 /**

package/src/cli/commands/build.ts

@@ -8,6 +8,7 @@ import { configExists, loadConfig, ConfigError } from '../../config/loader.js';
 import type { ResolvedCoreAIConfig } from '../../config/types.js';
 import { compileAgents, type CompileOptions, type CompileResult } from '../../agents/index.js';
 import { initAgentKnowledgeLibrary } from '../../knowledge-library/index.js';
+import { discoverMcpServers } from '../../adapters/mcp/index.js';
 
 /**
  * Options for build command
@@ -47,6 +48,14 @@ export interface BuildCommandOptions {
    * Initialize KnowledgeLibrary directories for agents
    */
   initKnowledgeLibrary?: boolean;
+
+  /**
+   * Include MCP servers as agent tools.
+   * If true, discovers MCP servers from config files.
+   * If an array, uses the specified server names.
+   * Default: true (auto-discover)
+   */
+  mcpServers?: boolean | string[];
 }
 
 /**
@@ -59,6 +68,7 @@ export interface BuildCommandResult {
   error?: string;
   warnings?: string[];
   knowledgeLibraryInitialized?: string[];
+  mcpServers?: string[];
 }
 
 /**
@@ -108,6 +118,29 @@ export function build(options: BuildCommandOptions = {}): BuildCommandResult {
     compileOptions.filter = (agent) => agentsList.includes(agent.role);
   }
 
+  // Discover MCP servers for tools
+  const includeMcpServers = options.mcpServers ?? true;
+  if (includeMcpServers !== false) {
+    try {
+      if (Array.isArray(includeMcpServers)) {
+        // Use explicitly provided server names
+        compileOptions.mcpServers = includeMcpServers;
+      } else {
+        // Auto-discover from config files
+        const discoveredServers = discoverMcpServers({
+          projectRoot,
+          includeGlobal: false, // Only use project-level MCP config
+        });
+        if (discoveredServers.length > 0) {
+          compileOptions.mcpServers = discoveredServers.map((s) => s.name);
+        }
+      }
+    } catch {
+      // MCP discovery failed, continue without MCP tools
+      // This is non-fatal - agents will just use default tools
+    }
+  }
+
   // Compile agents
   try {
     const result = compileAgents(config, compileOptions);
@@ -144,6 +177,7 @@ export function build(options: BuildCommandOptions = {}): BuildCommandResult {
       config,
       warnings: warnings.length > 0 ? warnings : undefined,
       knowledgeLibraryInitialized,
+      mcpServers: compileOptions.mcpServers,
     };
   } catch (error) {
     return {
@@ -227,6 +261,12 @@ export function formatBuildResult(result: BuildCommandResult): string {
     lines.push('');
   }
 
+  // MCP servers included
+  if (result.mcpServers && result.mcpServers.length > 0) {
+    lines.push(`MCP tools included: ${result.mcpServers.map((s) => `mcp__${s}`).join(', ')}`);
+    lines.push('');
+  }
+
   // KnowledgeLibrary initialization
   if (result.knowledgeLibraryInitialized && result.knowledgeLibraryInitialized.length > 0) {
     lines.push(