@friggframework/ai-agents 2.0.0--canary.522.cbd3d5a.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) 2022 Left Hook Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice (including the next paragraph) shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/jest.config.js

@@ -0,0 +1,8 @@
+module.exports = {
+    testEnvironment: 'node',
+    testMatch: ['**/tests/**/*.test.js'],
+    collectCoverageFrom: ['src/**/*.js'],
+    coverageDirectory: 'coverage',
+    coverageReporters: ['text', 'lcov'],
+    verbose: true
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@friggframework/ai-agents",
+  "version": "2.0.0--canary.522.cbd3d5a.0",
+  "description": "AI agent integration for Frigg Framework",
+  "main": "src/index.js",
+  "author": "",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/friggframework/frigg.git"
+  },
+  "bugs": {
+    "url": "https://github.com/friggframework/frigg/issues"
+  },
+  "homepage": "https://github.com/friggframework/frigg#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint:fix": "prettier --write --loglevel error . && eslint . --fix"
+  },
+  "keywords": [
+    "frigg",
+    "ai",
+    "agents",
+    "mcp",
+    "llm"
+  ],
+  "dependencies": {
+    "@friggframework/schemas": "2.0.0--canary.522.cbd3d5a.0"
+  },
+  "peerDependencies": {
+    "@ai-sdk/openai": ">=1.0.0",
+    "@anthropic-ai/claude-agent-sdk": ">=0.1.0",
+    "ai": ">=4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "ai": {
+      "optional": true
+    },
+    "@ai-sdk/openai": {
+      "optional": true
+    },
+    "@anthropic-ai/claude-agent-sdk": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@friggframework/eslint-config": "2.0.0--canary.522.cbd3d5a.0",
+    "@friggframework/prettier-config": "2.0.0--canary.522.cbd3d5a.0",
+    "eslint": "^8.22.0",
+    "jest": "^29.7.0",
+    "prettier": "^2.7.1"
+  },
+  "prettier": "@friggframework/prettier-config",
+  "gitHead": "cbd3d5a81315519842f308fc0bd786a3f8786b79"
+}

package/src/domain/entities/agent-event.js

@@ -0,0 +1,55 @@
+const AgentEventType = {
+    CONTENT: 'content',
+    TOOL_CALL: 'tool_call',
+    TOOL_RESULT: 'tool_result',
+    USAGE: 'usage',
+    DONE: 'done',
+    ERROR: 'error'
+};
+
+class AgentEvent {
+    constructor({ type, timestamp = new Date(), ...data }) {
+        this.type = type;
+        this.timestamp = timestamp;
+        Object.assign(this, data);
+    }
+
+    static content(text) {
+        return new AgentEvent({ type: AgentEventType.CONTENT, content: text });
+    }
+
+    static toolCall(name, args) {
+        return new AgentEvent({ type: AgentEventType.TOOL_CALL, name, args });
+    }
+
+    static toolResult(name, result) {
+        return new AgentEvent({ type: AgentEventType.TOOL_RESULT, name, result });
+    }
+
+    static usage(usage) {
+        return new AgentEvent({ type: AgentEventType.USAGE, usage });
+    }
+
+    static done() {
+        return new AgentEvent({ type: AgentEventType.DONE });
+    }
+
+    static error(error) {
+        return new AgentEvent({ type: AgentEventType.ERROR, error });
+    }
+
+    toJSON() {
+        return {
+            type: this.type,
+            timestamp: this.timestamp.toISOString(),
+            ...(this.content && { content: this.content }),
+            ...(this.name && { name: this.name }),
+            ...(this.args && { args: this.args }),
+            ...(this.result && { result: this.result }),
+            ...(this.usage && { usage: this.usage }),
+            ...(this.error && { error: this.error.message || String(this.error) })
+        };
+    }
+}
+
+module.exports = { AgentEvent, AgentEventType };

package/src/domain/entities/agent-proposal.js

@@ -0,0 +1,81 @@
+const ProposalStatus = {
+    PENDING: 'pending',
+    APPROVED: 'approved',
+    REJECTED: 'rejected',
+    MODIFIED: 'modified'
+};
+
+class AgentProposal {
+    constructor({ id, files, validation, checkpointId = null }) {
+        this.id = id;
+        this.files = files;
+        this.validation = validation;
+        this.checkpointId = checkpointId;
+        this.status = ProposalStatus.PENDING;
+        this.createdAt = new Date();
+        this.approvedAt = null;
+        this.rejectedAt = null;
+        this.rejectionReason = null;
+    }
+
+    getSummary() {
+        let linesAdded = 0;
+        let createdFiles = 0;
+        let modifiedFiles = 0;
+
+        for (const file of this.files) {
+            if (file.action === 'create') {
+                createdFiles++;
+                if (file.content) {
+                    linesAdded += file.content.split('\n').length;
+                }
+            } else if (file.action === 'modify') {
+                modifiedFiles++;
+            }
+        }
+
+        return {
+            fileCount: this.files.length,
+            createdFiles,
+            modifiedFiles,
+            linesAdded,
+            confidence: this.validation?.confidence,
+            recommendation: this.validation?.recommendation
+        };
+    }
+
+    approve() {
+        if (this.status === ProposalStatus.REJECTED) {
+            throw new Error('Cannot approve rejected proposal');
+        }
+        this.status = ProposalStatus.APPROVED;
+        this.approvedAt = new Date();
+    }
+
+    reject(reason) {
+        this.status = ProposalStatus.REJECTED;
+        this.rejectedAt = new Date();
+        this.rejectionReason = reason;
+    }
+
+    canRollback() {
+        return this.checkpointId !== null;
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            status: this.status,
+            files: this.files.map(f => ({ path: f.path, action: f.action })),
+            validation: this.validation,
+            checkpointId: this.checkpointId,
+            summary: this.getSummary(),
+            createdAt: this.createdAt.toISOString(),
+            approvedAt: this.approvedAt?.toISOString(),
+            rejectedAt: this.rejectedAt?.toISOString(),
+            rejectionReason: this.rejectionReason
+        };
+    }
+}
+
+module.exports = { AgentProposal, ProposalStatus };

package/src/domain/entities/index.js

@@ -0,0 +1,9 @@
+const { AgentEvent, AgentEventType } = require('./agent-event');
+const { AgentProposal, ProposalStatus } = require('./agent-proposal');
+
+module.exports = {
+    AgentEvent,
+    AgentEventType,
+    AgentProposal,
+    ProposalStatus
+};

package/src/domain/index.js

@@ -0,0 +1,7 @@
+const interfaces = require('./interfaces');
+const entities = require('./entities');
+
+module.exports = {
+    ...interfaces,
+    ...entities
+};

package/src/domain/interfaces/agent-framework.js

@@ -0,0 +1,29 @@
+class NotImplementedError extends Error {
+    constructor(method) {
+        super(`Not implemented: ${method}`);
+        this.name = 'NotImplementedError';
+    }
+}
+
+class IAgentFramework {
+    async runAgent(_params) {
+        throw new NotImplementedError('runAgent');
+    }
+
+    async loadMcpTools(_serverConfig) {
+        throw new NotImplementedError('loadMcpTools');
+    }
+
+    getCapabilities() {
+        throw new NotImplementedError('getCapabilities');
+    }
+
+    async validateRunParams(params) {
+        if (!params.prompt) {
+            throw new Error('prompt is required');
+        }
+        return true;
+    }
+}
+
+module.exports = { IAgentFramework, NotImplementedError };

package/src/domain/interfaces/index.js

@@ -0,0 +1,10 @@
+const { IAgentFramework, NotImplementedError } = require('./agent-framework');
+const { IValidationPipeline, WEIGHTS, THRESHOLDS } = require('./validation-pipeline');
+
+module.exports = {
+    IAgentFramework,
+    IValidationPipeline,
+    NotImplementedError,
+    WEIGHTS,
+    THRESHOLDS
+};

package/src/domain/interfaces/validation-pipeline.js

@@ -0,0 +1,61 @@
+const { NotImplementedError } = require('./agent-framework');
+
+const WEIGHTS = {
+    schema: 0.30,
+    patterns: 0.25,
+    security: 0.15,
+    tests: 0.20,
+    lint: 0.10
+};
+
+const THRESHOLDS = {
+    autoApprove: 95,
+    requireReview: 80
+};
+
+class IValidationPipeline {
+    async validate(_files) {
+        throw new NotImplementedError('validate');
+    }
+
+    calculateConfidence(layerResults) {
+        let totalScore = 0;
+
+        for (const [layer, weight] of Object.entries(WEIGHTS)) {
+            const result = layerResults[layer];
+            if (result && typeof result.score === 'number') {
+                totalScore += result.score * weight;
+            }
+        }
+
+        return Math.round(totalScore);
+    }
+
+    getRecommendation(confidence, thresholds = THRESHOLDS) {
+        if (confidence >= thresholds.autoApprove) {
+            return 'auto_approve';
+        }
+        if (confidence >= thresholds.requireReview) {
+            return 'require_review';
+        }
+        return 'manual_approval';
+    }
+
+    generateFeedback(layerResults) {
+        const feedback = [];
+
+        for (const [layer, result] of Object.entries(layerResults)) {
+            if (!result.passed) {
+                feedback.push({
+                    layer,
+                    score: result.score,
+                    issues: result.errors || result.violations || result.vulnerabilities || result.failures || []
+                });
+            }
+        }
+
+        return feedback;
+    }
+}
+
+module.exports = { IValidationPipeline, WEIGHTS, THRESHOLDS };

package/src/index.js

@@ -0,0 +1,41 @@
+const { IAgentFramework, NotImplementedError } = require('./domain/interfaces/agent-framework');
+const { IValidationPipeline } = require('./domain/interfaces/validation-pipeline');
+
+const { AgentEvent, AgentEventType } = require('./domain/entities/agent-event');
+const { AgentProposal, ProposalStatus } = require('./domain/entities/agent-proposal');
+
+const { VercelAIAdapter, SUPPORTED_PROVIDERS } = require('./infrastructure/adapters/vercel-ai-adapter');
+const { ClaudeAgentAdapter } = require('./infrastructure/adapters/claude-agent-adapter');
+
+const { ValidationPipeline, ValidationLayer, LAYER_WEIGHTS } = require('./infrastructure/validation/validation-pipeline');
+
+const { createFriggMcpTools, KNOWN_MODULES } = require('./infrastructure/mcp/frigg-tools');
+
+const { GitCheckpointService } = require('./infrastructure/git/git-checkpoint-service');
+
+const { AgentStreamHandler } = require('./infrastructure/streaming/agent-stream-handler');
+
+module.exports = {
+    IAgentFramework,
+    IValidationPipeline,
+    NotImplementedError,
+
+    AgentEvent,
+    AgentEventType,
+    AgentProposal,
+    ProposalStatus,
+
+    VercelAIAdapter,
+    ClaudeAgentAdapter,
+    SUPPORTED_PROVIDERS,
+
+    ValidationPipeline,
+    ValidationLayer,
+    LAYER_WEIGHTS,
+
+    createFriggMcpTools,
+    KNOWN_MODULES,
+
+    GitCheckpointService,
+    AgentStreamHandler
+};

package/src/infrastructure/adapters/claude-agent-adapter.js

@@ -0,0 +1,148 @@
+const { IAgentFramework } = require('../../domain/interfaces/agent-framework');
+const { AgentEvent } = require('../../domain/entities/agent-event');
+
+const DEFAULT_CONFIG = {
+    model: 'claude-3-5-sonnet-20241022',
+    maxTokens: 4096,
+    temperature: 0.7
+};
+
+class ClaudeAgentAdapter extends IAgentFramework {
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.tools = [];
+        this.approvalConfig = {
+            requireApproval: true,
+            confidenceThreshold: 80
+        };
+        this._paused = false;
+    }
+
+    getCapabilities() {
+        return {
+            streaming: true,
+            toolCalling: true,
+            mcpSupport: true,
+            nativeMcp: true,
+            multiProvider: false,
+            providers: ['anthropic'],
+            subagentOrchestration: true,
+            contextWindow: 200000
+        };
+    }
+
+    async loadMcpTools(serverConfig) {
+        const { tools = [] } = serverConfig;
+
+        this.tools = tools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema || { type: 'object', properties: {} },
+            execute: tool.handler
+        }));
+
+        return this.tools;
+    }
+
+    createStreamingHandler(onEvent) {
+        return {
+            onContent: (text) => {
+                onEvent(AgentEvent.content(text));
+            },
+            onToolCall: (name, args) => {
+                onEvent(AgentEvent.toolCall(name, args));
+            },
+            onToolResult: (name, result) => {
+                onEvent(AgentEvent.toolResult(name, result));
+            },
+            onFinish: (result) => {
+                if (result?.usage) {
+                    onEvent(AgentEvent.usage(result.usage));
+                }
+                onEvent(AgentEvent.done());
+            },
+            onError: (error) => {
+                onEvent(AgentEvent.error(error));
+            }
+        };
+    }
+
+    buildSystemPrompt(context = {}) {
+        const { integrationContext = '' } = context;
+
+        return `You are an AI agent specialized in building integrations with the Frigg Framework.
+
+You have access to Frigg-specific MCP tools that help you generate valid, secure code:
+
+## Available Tools
+
+- **frigg_validate_schema**: Validate JSON against Frigg schemas (app-definition, integration-definition, api-module-definition)
+- **frigg_get_template**: Get starter templates for OAuth2, API key, or webhook integrations
+- **frigg_check_patterns**: Verify code follows hexagonal architecture and IntegrationBase patterns
+- **frigg_list_modules**: List available pre-built API modules (HubSpot, Salesforce, Slack, etc.)
+- **frigg_security_scan**: Scan for hardcoded credentials, SQL injection, and other vulnerabilities
+- **frigg_git_checkpoint**: Create rollback points before making changes
+- **frigg_get_example**: Get working examples of common patterns
+
+${integrationContext ? `\nCurrent context: ${integrationContext}` : ''}
+
+## Required Patterns
+
+All integrations must:
+1. Extend IntegrationBase from @friggframework/core
+2. Have static Definition property with name, version, modules, display
+3. Implement: onCreate, onUpdate, onDelete, getConfigOptions, testAuth
+4. Follow hexagonal architecture (ports and adapters)
+5. Use environment variables for credentials
+
+## Workflow
+
+1. Start with frigg_git_checkpoint to enable rollback
+2. Use frigg_get_template for initial structure
+3. Customize based on requirements
+4. Run frigg_check_patterns to verify structure
+5. Run frigg_security_scan before finalizing
+6. Run frigg_validate_schema for any JSON configs
+
+Human approval is required for all generated code. Present proposals clearly with file paths, content, and confidence scores.`;
+    }
+
+    async runAgent(params) {
+        await this.validateRunParams(params);
+
+        const { prompt, context = {}, onEvent } = params;
+
+        if (params.mock) {
+            return {
+                stream: this._mockResponse ? this._mockResponse() : this._createMockStream(),
+                cancel: () => {}
+            };
+        }
+
+        throw new Error('Claude Agent SDK not configured. Install "@anthropic-ai/claude-agent-sdk" and set ANTHROPIC_API_KEY.');
+    }
+
+    async *_createMockStream() {
+        yield AgentEvent.content('Mock response - Claude Agent SDK not initialized');
+        yield AgentEvent.done();
+    }
+
+    configureHumanApproval(config) {
+        this.approvalConfig = { ...this.approvalConfig, ...config };
+    }
+
+    pause() {
+        this._paused = true;
+    }
+
+    resume() {
+        this._paused = false;
+    }
+
+    isPaused() {
+        return this._paused;
+    }
+}
+
+module.exports = { ClaudeAgentAdapter, DEFAULT_CONFIG };

package/src/infrastructure/adapters/index.js

@@ -0,0 +1,10 @@
+const { VercelAIAdapter, DEFAULT_CONFIG: VERCEL_DEFAULT_CONFIG, SUPPORTED_PROVIDERS } = require('./vercel-ai-adapter');
+const { ClaudeAgentAdapter, DEFAULT_CONFIG: CLAUDE_DEFAULT_CONFIG } = require('./claude-agent-adapter');
+
+module.exports = {
+    VercelAIAdapter,
+    ClaudeAgentAdapter,
+    VERCEL_DEFAULT_CONFIG,
+    CLAUDE_DEFAULT_CONFIG,
+    SUPPORTED_PROVIDERS
+};

package/src/infrastructure/adapters/vercel-ai-adapter.js

@@ -0,0 +1,135 @@
+const { IAgentFramework } = require('../../domain/interfaces/agent-framework');
+const { AgentEvent } = require('../../domain/entities/agent-event');
+
+const DEFAULT_CONFIG = {
+    model: 'gpt-4-turbo',
+    provider: 'openai',
+    maxTokens: 4096,
+    temperature: 0.7
+};
+
+const SUPPORTED_PROVIDERS = ['openai', 'anthropic', 'google', 'azure', 'amazon-bedrock'];
+
+class VercelAIAdapter extends IAgentFramework {
+    constructor(config = {}) {
+        super();
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.tools = [];
+        this.approvalConfig = {
+            requireApproval: true,
+            confidenceThreshold: 80
+        };
+        this._paused = false;
+    }
+
+    getCapabilities() {
+        return {
+            streaming: true,
+            toolCalling: true,
+            mcpSupport: true,
+            multiProvider: true,
+            providers: SUPPORTED_PROVIDERS,
+            nativeMcp: false,
+            subagentOrchestration: false
+        };
+    }
+
+    async loadMcpTools(serverConfig) {
+        const { tools = [] } = serverConfig;
+
+        this.tools = tools.map(tool => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema || { type: 'object', properties: {} },
+            execute: tool.handler
+        }));
+
+        return this.tools;
+    }
+
+    createStreamingHandler(onEvent) {
+        return {
+            onContent: (text) => {
+                onEvent(AgentEvent.content(text));
+            },
+            onToolCall: (name, args) => {
+                onEvent(AgentEvent.toolCall(name, args));
+            },
+            onToolResult: (name, result) => {
+                onEvent(AgentEvent.toolResult(name, result));
+            },
+            onFinish: (result) => {
+                if (result?.usage) {
+                    onEvent(AgentEvent.usage(result.usage));
+                }
+                onEvent(AgentEvent.done());
+            },
+            onError: (error) => {
+                onEvent(AgentEvent.error(error));
+            }
+        };
+    }
+
+    buildSystemPrompt(context = {}) {
+        const { integrationContext = '' } = context;
+
+        return `You are an AI agent specialized in building integrations with the Frigg Framework.
+
+Your role is to help developers create, modify, and maintain integrations following Frigg's hexagonal architecture patterns.
+
+${integrationContext ? `Current context: ${integrationContext}` : ''}
+
+Key patterns to follow:
+- Always extend IntegrationBase for integration classes
+- Implement required methods: onCreate, onUpdate, onDelete, getConfigOptions, testAuth
+- Use static Definition property for integration metadata
+- Follow OAuth2 patterns for authentication
+- Use environment variables for credentials, never hardcode
+
+When generating code:
+1. Use frigg_validate_schema to validate JSON definitions
+2. Use frigg_check_patterns to verify code follows Frigg patterns
+3. Use frigg_security_scan to check for vulnerabilities
+4. Always include test files for generated code
+
+Validation is critical - run validation tools after every code generation step.`;
+    }
+
+    async runAgent(params) {
+        await this.validateRunParams(params);
+
+        const { prompt, context = {}, onEvent } = params;
+
+        if (params.mock) {
+            return {
+                stream: this._mockResponse ? this._mockResponse() : this._createMockStream(),
+                cancel: () => {}
+            };
+        }
+
+        throw new Error('Vercel AI SDK not configured. Install "ai" package and set API keys.');
+    }
+
+    async *_createMockStream() {
+        yield AgentEvent.content('Mock response - Vercel AI SDK not initialized');
+        yield AgentEvent.done();
+    }
+
+    configureHumanApproval(config) {
+        this.approvalConfig = { ...this.approvalConfig, ...config };
+    }
+
+    pause() {
+        this._paused = true;
+    }
+
+    resume() {
+        this._paused = false;
+    }
+
+    isPaused() {
+        return this._paused;
+    }
+}
+
+module.exports = { VercelAIAdapter, DEFAULT_CONFIG, SUPPORTED_PROVIDERS };