Agent Creation from Natural Language

/**
 * GitHub Urgent Issue Monitor Agent
 * Generated by AgentOS Copilot Extension
 */

import { KernelSpace, Policy, Agent } from '@agent-os/core';
import { GitHubClient, SlackClient } from '@agent-os/integrations';
import { SentimentAnalyzer } from '@agent-os/analysis';

interface Issue {
  number: number;
  title: string;
  body: string;
  url: string;
  user: { login: string };
}

interface MonitorResult {
  status: 'success' | 'error';
  issuesProcessed: number;
  alertsSent: number;
}

// Initialize kernel with security policies
const kernel = new KernelSpace({
  policy: Policy.load('standard'),
  auditLogging: true,
});

// Configure integrations
const github = new GitHubClient({ scope: 'repo:read' });
const slack = new SlackClient({ channel: '#engineering' });
const sentiment = new SentimentAnalyzer({ model: 'roberta-base' });

@Agent({
  name: 'UrgentIssueMonitor',
  schedule: '*/15 * * * *', // Every 15 minutes
  description: 'Monitors urgent GitHub issues and alerts on negative sentiment',
})
class UrgentIssueMonitorAgent {
  
  async execute(repos: string[]): Promise {
    let alertsSent = 0;
    let processed = 0;

    for (const repo of repos) {
      // Fetch issues with "urgent" label (policy-checked)
      const issues = await github.issues.list({
        repo,
        labels: ['urgent'],
        state: 'open',
      });

      for (const issue of issues) {
        processed++;

        // Analyze sentiment (rate-limited by policy)
        const analysis = await sentiment.analyze({
          text: ${issue.title} ,
          returnScore: true,
        });

        // Alert if sentiment is negative
        if (analysis.sentiment === 'negative' && analysis.score > 0.7) {
          await slack.send({
            text: [
              '⚠️ *Urgent Issue Alert*',
              Repo: \${repo}\`,
              Issue: <|# >,
              Sentiment:  (%),
              Author: @,
            ].join('\n'),
            priority: 'high',
          });
          alertsSent++;
        }
      }
    }

    return {
      status: 'success',
      issuesProcessed: processed,
      alertsSent,
    };
  }
}

// Execute agent
const agent = new UrgentIssueMonitorAgent();
kernel.register(agent);

kernel.execute(agent, {
  repos: ['my-org/api', 'my-org/frontend', 'my-org/backend'],
}).then((result) => {
  console.log(Processed  issues, sent  alerts);
});

// GitHub Urgent Issue Monitor Agent
// Generated by AgentOS Copilot Extension

package main

import (
    "context"
    "fmt"
    "log"

    "github.com/agent-os/sdk-go/kernel"
    "github.com/agent-os/sdk-go/integrations/github"
    "github.com/agent-os/sdk-go/integrations/slack"
    "github.com/agent-os/sdk-go/analysis/sentiment"
)

// MonitorResult holds the execution results
type MonitorResult struct {
    Status          string json:"status"
    IssuesProcessed int    json:"issues_processed"
    AlertsSent      int    json:"alerts_sent"
}

// UrgentIssueMonitor monitors GitHub issues for negative sentiment
type UrgentIssueMonitor struct {
    kernel    *kernel.KernelSpace
    github    *github.Client
    slack     *slack.Client
    sentiment *sentiment.Analyzer
}

// NewUrgentIssueMonitor creates a new monitor agent
func NewUrgentIssueMonitor() *UrgentIssueMonitor {
    k := kernel.New(kernel.Config{
        Policy:       kernel.PolicyLoad("standard"),
        AuditLogging: true,
    })

    return &UrgentIssueMonitor{
        kernel:    k,
        github:    github.NewClient(github.WithScope("repo:read")),
        slack:     slack.NewClient(slack.WithChannel("#engineering")),
        sentiment: sentiment.NewAnalyzer(sentiment.WithModel("roberta-base")),
    }
}

// Execute runs the monitoring task
func (m *UrgentIssueMonitor) Execute(ctx context.Context, repos []string) (*MonitorResult, error) {
    var alertsSent, processed int

    for _, repo := range repos {
        // Fetch issues with "urgent" label (policy-checked)
        issues, err := m.github.Issues.List(ctx, github.IssueFilter{
            Repo:   repo,
            Labels: []string{"urgent"},
            State:  "open",
        })
        if err != nil {
            return nil, fmt.Errorf("failed to fetch issues for %s: %w", repo, err)
        }

        for _, issue := range issues {
            processed++

            // Analyze sentiment (rate-limited by policy)
            analysis, err := m.sentiment.Analyze(ctx, sentiment.Input{
                Text:        fmt.Sprintf("%s %s", issue.Title, issue.Body),
                ReturnScore: true,
            })
            if err != nil {
                log.Printf("Sentiment analysis failed for issue #%d: %v", issue.Number, err)
                continue
            }

            // Alert if sentiment is negative
            if analysis.Sentiment == "negative" && analysis.Score > 0.7 {
                msg := fmt.Sprintf(
                    "⚠️ *Urgent Issue Alert*\nRepo: %s\nIssue: <%s|#%d %s>\nSentiment: %s (%.0f%%)\nAuthor: @%s",
                    repo, issue.URL, issue.Number, issue.Title,
                    analysis.Sentiment, analysis.Score*100, issue.User.Login,
                )

                if err := m.slack.Send(ctx, slack.Message{
                    Text:     msg,
                    Priority: slack.PriorityHigh,
                }); err != nil {
                    log.Printf("Failed to send Slack alert: %v", err)
                    continue
                }
                alertsSent++
            }
        }
    }

    return &MonitorResult{
        Status:          "success",
        IssuesProcessed: processed,
        AlertsSent:      alertsSent,
    }, nil
}

func main() {
    monitor := NewUrgentIssueMonitor()
    
    repos := []string{"my-org/api", "my-org/frontend", "my-org/backend"}
    
    result, err := monitor.Execute(context.Background(), repos)
    if err != nil {
        log.Fatalf("Monitor execution failed: %v", err)
    }

    fmt.Printf("Processed %d issues, sent %d alerts\n", 
        result.IssuesProcessed, result.AlertsSent)
}