osagent-core 0.1.12

package/dist/src/orchestration/dynamic-factory.d.ts

@@ -0,0 +1,204 @@
+/**
+ * @license
+ * Copyright 2025 OSAgent OC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import type { RegisteredAgent, RegisteredSkill, AgentTemplate, SkillTemplate, AgentTier, ModelPreference } from './types.js';
+/**
+ * Creates new agents dynamically based on templates or specifications
+ */
+export declare class DynamicAgentFactory {
+    private createdAgents;
+    /**
+     * Generate unique agent ID
+     */
+    private generateId;
+    /**
+     * Create agent from template
+     */
+    createFromTemplate(template: AgentTemplate, createdBy?: string): RegisteredAgent;
+    /**
+     * Create agent from natural language specification
+     */
+    createFromSpec(spec: {
+        name: string;
+        purpose: string;
+        expertise: string[];
+        tier?: AgentTier;
+        model?: ModelPreference;
+        projectPattern?: string;
+    }, createdBy?: string): RegisteredAgent;
+    /**
+     * Create project-specific agent
+     */
+    createProjectAgent(projectName: string, projectPath: string, techStack: string[], patterns: string[], createdBy?: string): RegisteredAgent;
+    /**
+     * Generate system prompt from specification
+     */
+    private generateSystemPrompt;
+    /**
+     * Extract keywords from expertise area
+     */
+    private extractKeywords;
+    /**
+     * Get default priority for tier
+     */
+    private getPriorityForTier;
+    /**
+     * Get default model for tier
+     */
+    private getDefaultModelForTier;
+    /**
+     * Get all created agents
+     */
+    getCreatedAgents(): RegisteredAgent[];
+    /**
+     * Get created agent by ID
+     */
+    getAgent(id: string): RegisteredAgent | undefined;
+    /**
+     * Delete created agent
+     */
+    deleteAgent(id: string): boolean;
+    /**
+     * Export created agents
+     */
+    export(): RegisteredAgent[];
+    /**
+     * Import agents
+     */
+    import(agents: RegisteredAgent[]): void;
+}
+/**
+ * Creates new skills dynamically based on templates or specifications
+ */
+export declare class DynamicSkillFactory {
+    private createdSkills;
+    /**
+     * Generate unique skill ID
+     */
+    private generateId;
+    /**
+     * Generate unique step ID
+     */
+    private generateStepId;
+    /**
+     * Create skill from template
+     */
+    createFromTemplate(template: SkillTemplate, createdBy?: string): RegisteredSkill;
+    /**
+     * Create skill from natural language specification
+     */
+    createFromSpec(spec: {
+        name: string;
+        description: string;
+        triggerKeywords: string[];
+        steps: Array<{
+            name: string;
+            description: string;
+            agentId?: string;
+            prompt: string;
+        }>;
+    }, createdBy?: string): RegisteredSkill;
+    /**
+     * Create simple sequential skill
+     */
+    createSequentialSkill(name: string, description: string, triggerKeywords: string[], steps: Array<{
+        name: string;
+        agentId?: string;
+        prompt: string;
+    }>, createdBy?: string): RegisteredSkill;
+    /**
+     * Create verification skill for a workflow
+     */
+    createVerificationSkill(workflowName: string, checks: Array<{
+        name: string;
+        command: string;
+    }>, createdBy?: string): RegisteredSkill;
+    /**
+     * Get all created skills
+     */
+    getCreatedSkills(): RegisteredSkill[];
+    /**
+     * Get created skill by ID
+     */
+    getSkill(id: string): RegisteredSkill | undefined;
+    /**
+     * Delete created skill
+     */
+    deleteSkill(id: string): boolean;
+    /**
+     * Export created skills
+     */
+    export(): RegisteredSkill[];
+    /**
+     * Import skills
+     */
+    import(skills: RegisteredSkill[]): void;
+}
+/**
+ * Unified factory manager for creating agents and skills
+ */
+export declare class FactoryManager {
+    private agentFactory;
+    private skillFactory;
+    private creationLog;
+    constructor();
+    /**
+     * Create agent from specification
+     */
+    createAgent(spec: Parameters<DynamicAgentFactory['createFromSpec']>[0], createdBy?: string): RegisteredAgent;
+    /**
+     * Create project agent
+     */
+    createProjectAgent(projectName: string, projectPath: string, techStack: string[], patterns: string[], createdBy?: string): RegisteredAgent;
+    /**
+     * Create skill from specification
+     */
+    createSkill(spec: Parameters<DynamicSkillFactory['createFromSpec']>[0], createdBy?: string): RegisteredSkill;
+    /**
+     * Create verification skill
+     */
+    createVerificationSkill(workflowName: string, checks: Array<{
+        name: string;
+        command: string;
+    }>, createdBy?: string): RegisteredSkill;
+    /**
+     * Get creation log
+     */
+    getCreationLog(): {
+        type: "agent" | "skill";
+        id: string;
+        name: string;
+        createdAt: number;
+        createdBy?: string;
+    }[];
+    /**
+     * Get all created items
+     */
+    getCreated(): {
+        agents: RegisteredAgent[];
+        skills: RegisteredSkill[];
+    };
+    /**
+     * Export all created items
+     */
+    export(): {
+        agents: RegisteredAgent[];
+        skills: RegisteredSkill[];
+        log: {
+            type: "agent" | "skill";
+            id: string;
+            name: string;
+            createdAt: number;
+            createdBy?: string;
+        }[];
+    };
+    /**
+     * Import created items
+     */
+    import(data: ReturnType<FactoryManager['export']>): void;
+}
+export declare const defaultAgentFactory: DynamicAgentFactory;
+export declare const defaultSkillFactory: DynamicSkillFactory;
+export declare const defaultFactoryManager: FactoryManager;

package/dist/src/orchestration/dynamic-factory.js

@@ -0,0 +1,496 @@
+/**
+ * @license
+ * Copyright 2025 OSAgent OC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import crypto from 'node:crypto';
+// ============================================================================
+// DYNAMIC AGENT FACTORY
+// ============================================================================
+/**
+ * Creates new agents dynamically based on templates or specifications
+ */
+export class DynamicAgentFactory {
+    createdAgents = new Map();
+    /**
+     * Generate unique agent ID
+     */
+    generateId(name) {
+        const hash = crypto.randomBytes(4).toString('hex');
+        return `${name.toLowerCase().replace(/\s+/g, '-')}-${hash}`;
+    }
+    /**
+     * Create agent from template
+     */
+    createFromTemplate(template, createdBy) {
+        const id = this.generateId(template.name);
+        const agent = {
+            id,
+            name: template.name.toLowerCase().replace(/\s+/g, '-'),
+            displayName: template.displayName,
+            description: template.description,
+            systemPrompt: template.baseSystemPrompt,
+            capabilities: template.capabilities.map(cap => ({
+                ...cap,
+                confidence: 0.85, // Default confidence for dynamic agents
+            })),
+            priority: this.getPriorityForTier(template.tier),
+            tier: template.tier,
+            model: template.model,
+            enabled: true,
+            projectPatterns: template.projectPatterns,
+            createdAt: Date.now(),
+            createdBy,
+            isBuiltin: false,
+        };
+        this.createdAgents.set(id, agent);
+        return agent;
+    }
+    /**
+     * Create agent from natural language specification
+     */
+    createFromSpec(spec, createdBy) {
+        const id = this.generateId(spec.name);
+        // Generate system prompt from purpose and expertise
+        const systemPrompt = this.generateSystemPrompt(spec.name, spec.purpose, spec.expertise);
+        // Generate capabilities from expertise
+        const capabilities = spec.expertise.map(area => ({
+            name: area.toLowerCase().replace(/\s+/g, '-'),
+            keywords: this.extractKeywords(area),
+            confidence: 0.85,
+        }));
+        const tier = spec.tier ?? 'specialist';
+        const agent = {
+            id,
+            name: spec.name.toLowerCase().replace(/\s+/g, '-'),
+            displayName: spec.name,
+            description: spec.purpose,
+            systemPrompt,
+            capabilities,
+            priority: this.getPriorityForTier(tier),
+            tier,
+            model: spec.model ?? this.getDefaultModelForTier(tier),
+            enabled: true,
+            projectPatterns: spec.projectPattern ? [spec.projectPattern] : undefined,
+            createdAt: Date.now(),
+            createdBy,
+            isBuiltin: false,
+        };
+        this.createdAgents.set(id, agent);
+        return agent;
+    }
+    /**
+     * Create project-specific agent
+     */
+    createProjectAgent(projectName, projectPath, techStack, patterns, createdBy) {
+        const name = `${projectName} Specialist`;
+        const id = this.generateId(name);
+        const systemPrompt = `You are the ${projectName} project specialist. You understand:
+${techStack.map((tech, i) => `${i + 1}. ${tech}`).join('\n')}
+
+Project patterns and conventions:
+${patterns.map((pattern, i) => `- ${pattern}`).join('\n')}
+
+You have deep knowledge of this project's codebase, architecture, and conventions.
+Always follow the established patterns when making changes.`;
+        const agent = {
+            id,
+            name: name.toLowerCase().replace(/\s+/g, '-'),
+            displayName: name,
+            description: `Specialist for ${projectName} project patterns and conventions`,
+            systemPrompt,
+            capabilities: [
+                {
+                    name: `${projectName.toLowerCase()}-specialist`,
+                    keywords: [projectName.toLowerCase(), ...techStack.map(t => t.toLowerCase())],
+                    confidence: 0.95,
+                },
+            ],
+            priority: 90,
+            tier: 'project',
+            model: 'sonnet',
+            enabled: true,
+            projectPatterns: [`**/${projectName}/**`, projectPath],
+            createdAt: Date.now(),
+            createdBy,
+            isBuiltin: false,
+        };
+        this.createdAgents.set(id, agent);
+        return agent;
+    }
+    /**
+     * Generate system prompt from specification
+     */
+    generateSystemPrompt(name, purpose, expertise) {
+        return `You are the ${name} agent. Your purpose is:
+${purpose}
+
+Your areas of expertise include:
+${expertise.map((area, i) => `${i + 1}. ${area}`).join('\n')}
+
+Best practices you follow:
+- Always verify your work before reporting completion
+- Ask clarifying questions when requirements are ambiguous
+- Consider edge cases and error handling
+- Write clean, maintainable code
+- Document important decisions`;
+    }
+    /**
+     * Extract keywords from expertise area
+     */
+    extractKeywords(area) {
+        // Simple keyword extraction - split by common separators
+        return area
+            .toLowerCase()
+            .split(/[\s,/]+/)
+            .filter(word => word.length > 2);
+    }
+    /**
+     * Get default priority for tier
+     */
+    getPriorityForTier(tier) {
+        switch (tier) {
+            case 'orchestrator': return 95;
+            case 'specialist': return 80;
+            case 'utility': return 60;
+            case 'project': return 90;
+            default: return 70;
+        }
+    }
+    /**
+     * Get default model for tier
+     */
+    getDefaultModelForTier(tier) {
+        switch (tier) {
+            case 'orchestrator': return 'opus';
+            case 'specialist': return 'sonnet';
+            case 'utility': return 'haiku';
+            case 'project': return 'sonnet';
+            default: return 'sonnet';
+        }
+    }
+    /**
+     * Get all created agents
+     */
+    getCreatedAgents() {
+        return Array.from(this.createdAgents.values());
+    }
+    /**
+     * Get created agent by ID
+     */
+    getAgent(id) {
+        return this.createdAgents.get(id);
+    }
+    /**
+     * Delete created agent
+     */
+    deleteAgent(id) {
+        return this.createdAgents.delete(id);
+    }
+    /**
+     * Export created agents
+     */
+    export() {
+        return this.getCreatedAgents();
+    }
+    /**
+     * Import agents
+     */
+    import(agents) {
+        for (const agent of agents) {
+            if (!agent.isBuiltin) {
+                this.createdAgents.set(agent.id, agent);
+            }
+        }
+    }
+}
+// ============================================================================
+// DYNAMIC SKILL FACTORY
+// ============================================================================
+/**
+ * Creates new skills dynamically based on templates or specifications
+ */
+export class DynamicSkillFactory {
+    createdSkills = new Map();
+    /**
+     * Generate unique skill ID
+     */
+    generateId(name) {
+        const hash = crypto.randomBytes(4).toString('hex');
+        return `${name.toLowerCase().replace(/\s+/g, '-')}-${hash}`;
+    }
+    /**
+     * Generate unique step ID
+     */
+    generateStepId(skillId, stepName, index) {
+        return `${skillId}-step-${index}-${stepName.toLowerCase().replace(/\s+/g, '-')}`;
+    }
+    /**
+     * Create skill from template
+     */
+    createFromTemplate(template, createdBy) {
+        const id = this.generateId(template.name);
+        const trigger = {
+            type: template.triggerType,
+            patterns: template.triggerPatterns,
+            confidence: 0.85,
+        };
+        const steps = template.steps.map((step, index) => ({
+            ...step,
+            id: this.generateStepId(id, step.name, index),
+        }));
+        const skill = {
+            id,
+            name: template.name.toLowerCase().replace(/\s+/g, '-'),
+            displayName: template.displayName,
+            description: template.description,
+            triggers: [trigger],
+            steps,
+            priority: 80,
+            enabled: true,
+            createdAt: Date.now(),
+            createdBy,
+            isBuiltin: false,
+        };
+        this.createdSkills.set(id, skill);
+        return skill;
+    }
+    /**
+     * Create skill from natural language specification
+     */
+    createFromSpec(spec, createdBy) {
+        const id = this.generateId(spec.name);
+        const trigger = {
+            type: 'keyword',
+            patterns: spec.triggerKeywords,
+            confidence: 0.85,
+        };
+        const steps = spec.steps.map((step, index) => ({
+            id: this.generateStepId(id, step.name, index),
+            name: step.name,
+            description: step.description,
+            agentId: step.agentId,
+            prompt: step.prompt,
+            dependsOn: index > 0 ? [spec.steps[index - 1].name.toLowerCase().replace(/\s+/g, '-')] : undefined,
+        }));
+        const skill = {
+            id,
+            name: spec.name.toLowerCase().replace(/\s+/g, '-'),
+            displayName: spec.name,
+            description: spec.description,
+            triggers: [trigger],
+            steps,
+            priority: 80,
+            enabled: true,
+            createdAt: Date.now(),
+            createdBy,
+            isBuiltin: false,
+        };
+        this.createdSkills.set(id, skill);
+        return skill;
+    }
+    /**
+     * Create simple sequential skill
+     */
+    createSequentialSkill(name, description, triggerKeywords, steps, createdBy) {
+        return this.createFromSpec({
+            name,
+            description,
+            triggerKeywords,
+            steps: steps.map(s => ({ ...s, description: s.prompt.slice(0, 100) })),
+        }, createdBy);
+    }
+    /**
+     * Create verification skill for a workflow
+     */
+    createVerificationSkill(workflowName, checks, createdBy) {
+        const id = this.generateId(`${workflowName}-verification`);
+        const steps = checks.map((check, index) => ({
+            id: this.generateStepId(id, check.name, index),
+            name: check.name,
+            description: `Run ${check.name} verification`,
+            prompt: `Run the verification command: ${check.command}`,
+            parallel: true,
+            verification: {
+                type: 'command',
+                command: check.command,
+            },
+        }));
+        // Add final aggregation step
+        steps.push({
+            id: this.generateStepId(id, 'aggregate', steps.length),
+            name: 'Aggregate Results',
+            description: 'Combine all verification results',
+            prompt: 'Aggregate all verification results and report overall status.',
+            dependsOn: checks.map(c => c.name.toLowerCase().replace(/\s+/g, '-')),
+        });
+        const skill = {
+            id,
+            name: `${workflowName.toLowerCase().replace(/\s+/g, '-')}-verification`,
+            displayName: `${workflowName} Verification`,
+            description: `Verification workflow for ${workflowName}`,
+            triggers: [{
+                    type: 'manual',
+                    patterns: [],
+                    confidence: 1,
+                }],
+            steps,
+            priority: 90,
+            enabled: true,
+            createdAt: Date.now(),
+            createdBy,
+            isBuiltin: false,
+        };
+        this.createdSkills.set(id, skill);
+        return skill;
+    }
+    /**
+     * Get all created skills
+     */
+    getCreatedSkills() {
+        return Array.from(this.createdSkills.values());
+    }
+    /**
+     * Get created skill by ID
+     */
+    getSkill(id) {
+        return this.createdSkills.get(id);
+    }
+    /**
+     * Delete created skill
+     */
+    deleteSkill(id) {
+        return this.createdSkills.delete(id);
+    }
+    /**
+     * Export created skills
+     */
+    export() {
+        return this.getCreatedSkills();
+    }
+    /**
+     * Import skills
+     */
+    import(skills) {
+        for (const skill of skills) {
+            if (!skill.isBuiltin) {
+                this.createdSkills.set(skill.id, skill);
+            }
+        }
+    }
+}
+// ============================================================================
+// FACTORY MANAGER
+// ============================================================================
+/**
+ * Unified factory manager for creating agents and skills
+ */
+export class FactoryManager {
+    agentFactory;
+    skillFactory;
+    creationLog = [];
+    constructor() {
+        this.agentFactory = new DynamicAgentFactory();
+        this.skillFactory = new DynamicSkillFactory();
+    }
+    /**
+     * Create agent from specification
+     */
+    createAgent(spec, createdBy) {
+        const agent = this.agentFactory.createFromSpec(spec, createdBy);
+        this.creationLog.push({
+            type: 'agent',
+            id: agent.id,
+            name: agent.displayName,
+            createdAt: agent.createdAt ?? Date.now(),
+            createdBy,
+        });
+        return agent;
+    }
+    /**
+     * Create project agent
+     */
+    createProjectAgent(projectName, projectPath, techStack, patterns, createdBy) {
+        const agent = this.agentFactory.createProjectAgent(projectName, projectPath, techStack, patterns, createdBy);
+        this.creationLog.push({
+            type: 'agent',
+            id: agent.id,
+            name: agent.displayName,
+            createdAt: agent.createdAt ?? Date.now(),
+            createdBy,
+        });
+        return agent;
+    }
+    /**
+     * Create skill from specification
+     */
+    createSkill(spec, createdBy) {
+        const skill = this.skillFactory.createFromSpec(spec, createdBy);
+        this.creationLog.push({
+            type: 'skill',
+            id: skill.id,
+            name: skill.displayName,
+            createdAt: skill.createdAt ?? Date.now(),
+            createdBy,
+        });
+        return skill;
+    }
+    /**
+     * Create verification skill
+     */
+    createVerificationSkill(workflowName, checks, createdBy) {
+        const skill = this.skillFactory.createVerificationSkill(workflowName, checks, createdBy);
+        this.creationLog.push({
+            type: 'skill',
+            id: skill.id,
+            name: skill.displayName,
+            createdAt: skill.createdAt ?? Date.now(),
+            createdBy,
+        });
+        return skill;
+    }
+    /**
+     * Get creation log
+     */
+    getCreationLog() {
+        return [...this.creationLog];
+    }
+    /**
+     * Get all created items
+     */
+    getCreated() {
+        return {
+            agents: this.agentFactory.getCreatedAgents(),
+            skills: this.skillFactory.getCreatedSkills(),
+        };
+    }
+    /**
+     * Export all created items
+     */
+    export() {
+        return {
+            agents: this.agentFactory.export(),
+            skills: this.skillFactory.export(),
+            log: this.creationLog,
+        };
+    }
+    /**
+     * Import created items
+     */
+    import(data) {
+        if (data.agents) {
+            this.agentFactory.import(data.agents);
+        }
+        if (data.skills) {
+            this.skillFactory.import(data.skills);
+        }
+        if (data.log) {
+            this.creationLog = data.log;
+        }
+    }
+}
+// Default singleton instances
+export const defaultAgentFactory = new DynamicAgentFactory();
+export const defaultSkillFactory = new DynamicSkillFactory();
+export const defaultFactoryManager = new FactoryManager();
+//# sourceMappingURL=dynamic-factory.js.map