jay-code
Version:
Streamlined AI CLI orchestration engine with mathematical rigor and enterprise-grade reliability
312 lines (298 loc) • 9.38 kB
text/typescript
// init/claude-config.ts - Claude configuration creation
import type { InitOptions } from './index.js';
export async function createClaudeConfig(options: InitOptions): Promise<void> {
const fs = await import('fs/promises');
const path = await import('path');
// Create base configuration
const claudeConfig = {
version: '1.0.71',
project: {
name: path.basename(process.cwd()),
type: 'jay-code',
created: new Date().toISOString(),
},
features: {
swarm: true,
sparc: options.sparc || false,
memory: true,
terminal: true,
mcp: true,
batchTools: true,
orchestration: true,
},
batchTools: {
enabled: true,
maxConcurrentTasks: 10,
memoryCoordination: true,
taskOrchestration: true,
parallelExecution: true,
},
swarmConfig: {
defaultStrategy: 'auto',
defaultMode: 'centralized',
defaultMaxAgents: 5,
defaultTimeout: 60,
enableMonitoring: true,
enableParallel: true,
outputFormats: ['json', 'sqlite', 'csv', 'html'],
defaultOutputDir: './reports',
},
coordination: {
todoIntegration: true,
memorySharing: true,
crossAgentCommunication: true,
taskDependencyTracking: true,
progressMonitoring: true,
},
};
await fs.writeFile('.claude/config.json', JSON.stringify(claudeConfig, null, 2));
console.log(' ✅ Created .claude/config.json with batch tools configuration');
// Create additional configuration files
await createBatchToolsConfig();
await createSwarmConfig();
await createCoordinationConfig();
}
async function createBatchToolsConfig(): Promise<void> {
const fs = await import('fs/promises');
const batchConfig = {
version: '1.0.71',
description: 'Batch tools configuration for Claude Code orchestration',
tools: {
todoWrite: {
enabled: true,
features: [
'task_breakdown',
'dependency_tracking',
'priority_management',
'progress_monitoring',
],
maxTasks: 50,
defaultPriority: 'medium',
},
todoRead: {
enabled: true,
features: ['progress_tracking', 'status_monitoring', 'task_filtering'],
autoRefresh: true,
refreshInterval: 30,
},
task: {
enabled: true,
features: ['parallel_execution', 'agent_coordination', 'load_balancing'],
maxConcurrentTasks: 10,
timeoutDefault: 300,
retryAttempts: 3,
},
memory: {
enabled: true,
features: ['cross_agent_sharing', 'persistent_storage', 'knowledge_coordination'],
maxEntries: 1000,
compressionEnabled: true,
encryptionEnabled: false,
},
fileOperations: {
batchRead: {
enabled: true,
maxConcurrentReads: 10,
timeoutPerFile: 30,
},
batchWrite: {
enabled: true,
maxConcurrentWrites: 5,
backupEnabled: true,
},
batchEdit: {
enabled: true,
maxConcurrentEdits: 5,
validationEnabled: true,
},
},
search: {
batchGlob: {
enabled: true,
maxConcurrentSearches: 5,
cacheResults: true,
},
batchGrep: {
enabled: true,
maxConcurrentSearches: 5,
regexOptimization: true,
},
},
},
performance: {
monitoring: {
enabled: true,
metricsCollection: true,
performanceAlerts: true,
},
optimization: {
resourcePooling: true,
intelligentBatching: true,
loadBalancing: true,
},
},
};
await fs.writeFile('.claude/configs/batch-tools.json', JSON.stringify(batchConfig, null, 2));
console.log(' ✅ Created batch tools configuration');
}
async function createSwarmConfig(): Promise<void> {
const fs = await import('fs/promises');
const swarmConfig = {
version: '1.0.71',
description: 'Swarm orchestration configuration for Jay-Code',
strategies: {
research: {
description: 'Multi-agent research coordination',
defaultMode: 'distributed',
defaultAgents: 6,
phases: ['planning', 'execution', 'synthesis', 'reporting'],
tools: ['WebSearch', 'WebFetch', 'Memory', 'TodoWrite', 'Task'],
coordination: 'memory_based',
},
development: {
description: 'Coordinated software development',
defaultMode: 'hierarchical',
defaultAgents: 8,
phases: ['architecture', 'implementation', 'testing', 'integration'],
tools: ['Read', 'Write', 'Edit', 'Bash', 'Memory', 'TodoWrite', 'Task'],
coordination: 'hierarchical_teams',
},
analysis: {
description: 'Data analysis and insights generation',
defaultMode: 'mesh',
defaultAgents: 10,
phases: ['collection', 'processing', 'analysis', 'visualization'],
tools: ['Read', 'Bash', 'Memory', 'TodoWrite', 'Task'],
coordination: 'peer_to_peer',
},
testing: {
description: 'Comprehensive testing coordination',
defaultMode: 'distributed',
defaultAgents: 12,
phases: ['planning', 'execution', 'validation', 'reporting'],
tools: ['Read', 'Write', 'Bash', 'TodoWrite', 'Task'],
coordination: 'distributed_validation',
},
optimization: {
description: 'Performance optimization coordination',
defaultMode: 'hybrid',
defaultAgents: 6,
phases: ['profiling', 'analysis', 'optimization', 'validation'],
tools: ['Read', 'Edit', 'Bash', 'Memory', 'TodoWrite'],
coordination: 'adaptive_hybrid',
},
maintenance: {
description: 'System maintenance coordination',
defaultMode: 'centralized',
defaultAgents: 4,
phases: ['assessment', 'planning', 'execution', 'verification'],
tools: ['Read', 'Write', 'Bash', 'TodoWrite', 'Memory'],
coordination: 'centralized_safety',
},
},
coordinationModes: {
centralized: {
description: 'Single coordinator manages all agents',
useCases: ['maintenance', 'safety_critical', 'simple_tasks'],
coordination: 'master_slave',
communication: 'hub_spoke',
},
distributed: {
description: 'Multiple coordinators manage agent groups',
useCases: ['research', 'testing', 'large_scale'],
coordination: 'multi_master',
communication: 'federated',
},
hierarchical: {
description: 'Tree-like organization with team leads',
useCases: ['development', 'structured_workflows', 'large_teams'],
coordination: 'tree_structure',
communication: 'hierarchical_reporting',
},
mesh: {
description: 'Peer-to-peer agent communication',
useCases: ['analysis', 'dynamic_tasks', 'adaptive_workflows'],
coordination: 'peer_to_peer',
communication: 'mesh_network',
},
hybrid: {
description: 'Adaptive coordination based on task phase',
useCases: ['optimization', 'complex_workflows', 'multi_phase'],
coordination: 'adaptive_mixed',
communication: 'dynamic_topology',
},
},
};
await fs.writeFile('.claude/configs/swarm.json', JSON.stringify(swarmConfig, null, 2));
console.log(' ✅ Created swarm orchestration configuration');
}
async function createCoordinationConfig(): Promise<void> {
const fs = await import('fs/promises');
const coordinationConfig = {
version: '1.0.71',
description: 'Agent coordination and orchestration configuration',
coordination: {
taskManagement: {
todoIntegration: {
enabled: true,
autoBreakdown: true,
dependencyTracking: true,
progressMonitoring: true,
priorityManagement: true,
},
taskDistribution: {
algorithm: 'intelligent_balancing',
loadBalancing: true,
skillMatching: true,
resourceOptimization: true,
},
},
communication: {
memorySharing: {
enabled: true,
crossAgentAccess: true,
knowledgeSync: true,
conflictResolution: 'timestamp_priority',
},
coordination: {
realTimeUpdates: true,
statusBroadcasting: true,
emergencySignaling: true,
},
},
monitoring: {
progressTracking: {
enabled: true,
realTimeUpdates: true,
milestoneTracking: true,
performanceMetrics: true,
},
healthMonitoring: {
agentHealth: true,
taskHealth: true,
systemHealth: true,
alerting: true,
},
},
},
optimization: {
resourceManagement: {
pooling: true,
allocation: 'dynamic',
recycling: true,
monitoring: true,
},
performance: {
batchOptimization: true,
parallelExecution: true,
caching: true,
compression: true,
},
},
};
await fs.writeFile(
'.claude/configs/coordination.json',
JSON.stringify(coordinationConfig, null, 2),
);
console.log(' ✅ Created coordination configuration');
}