aegiscode 3.1.8 → 3.1.10

package/src/agent/SimpleAgent.ts

@@ -0,0 +1,48 @@
+/**
+ * SimpleAgent - 最简单的 LLM 交互实现
+ * 
+ * 
+ * 
+ */
+
+import OpenAI from 'openai';
+
+export interface AgentConfig {
+  apiKey: string;
+  baseURL?: string;
+  model?: string;
+}
+
+export class SimpleAgent {
+  private client: OpenAI;
+  private model: string;
+
+  constructor(config: AgentConfig) {
+    this.client = new OpenAI({
+      apiKey: config.apiKey,
+      baseURL: config.baseURL,
+    });
+    this.model = config.model || 'claude-sonnet-4-6';
+  }
+
+  /**
+   * 
+   */
+  async chat(message: string): Promise<string> {
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages: [
+        {
+          role: 'system',
+          content: 'You are a helpful coding assistant. Be concise and helpful.',
+        },
+        {
+          role: 'user',
+          content: message,
+        },
+      ],
+    });
+
+    return response.choices[0]?.message?.content || '';
+  }
+}

package/src/agent/index.ts

@@ -0,0 +1,54 @@
+/**
+ * Agent 
+ */
+
+export { Agent, default as AgentDefault } from './Agent.js';
+export { SimpleAgent } from './SimpleAgent.js';
+
+// Orchestrator (Multi-agent)
+export {
+  OrchestratorAgent,
+  createDefaultOrchestrator,
+  CouncilAgent,
+} from './orchestrator/index.js';
+
+export type {
+  SubAgentConfig,
+  TaskDelegation,
+  AgentResponse,
+  OrchestrationResult,
+  DeliberationConfig,
+  DeliberationResult,
+  VoteResult,
+  VoteValue,
+} from './orchestrator/index.js';
+
+export type {
+  // 
+  Message,
+  MessageRole,
+  ToolCall,
+  
+  // 
+  ChatContext,
+  PermissionMode,
+  ConfirmationHandler,
+  
+  // 
+  LoopOptions,
+  LoopResult,
+  LoopError,
+  LoopErrorType,
+  
+  // 
+  ToolResult,
+  ToolDefinition,
+  
+  // 
+  AgentConfig,
+  AgentOptions,
+  
+  // ChatService 
+  ChatResponse,
+  IChatService,
+} from './types.js';

package/src/agent/orchestrator/AppBuilder.ts

@@ -0,0 +1,443 @@
+/**
+ * AppBuilder — Declarative multi-agent app framework
+ *
+ * Makes it trivial to build new CLI "apps" that orchestrate multiple AI agents.
+ *
+ * Usage:
+ * ```ts
+ * const auditApp = new AppBuilder('audit', 'Security Auditor')
+ *   .describe('Audit codebase for security vulnerabilities')
+ *   .agent('scanner', 'Vulnerability Scanner', scannerPrompt, ['Read', 'Grep', 'Glob'])
+ *   .agent('analyzer', 'Risk Analyzer', analyzerPrompt, ['Read'])
+ *   .agent('reporter', 'Report Generator', reporterPrompt)
+ *   .register();
+ * ```
+ */
+
+import type { AgentConfig, Message } from '../types.js';
+import { OrchestratorAgent, type SubAgentConfig } from './OrchestratorAgent.js';
+import { requireModelConfig, type ResolvedModelConfig } from './utils.js';
+import { configManager } from '../../config/ConfigManager.js';
+
+// ─── Types ────────────────────────────────────────────────────────
+
+export interface AppDefinition {
+  /** Unique app ID (used to reference in slash commands) */
+  id: string;
+  /** Human-readable app name */
+  name: string;
+  /** Short description (shown in /help) */
+  description: string;
+  /** Detailed usage instructions */
+  usage?: string;
+  /** Example usages */
+  examples?: string[];
+  /** Model config (resolved lazily at run time) */
+  modelConfig: () => ResolvedModelConfig;
+  /** Sub-agent configurations */
+  agents: SubAgentConfig[];
+  /** Synthesizer agent name (defaults to first registered) */
+  synthesizer?: string;
+  /** Max parallel agent executions */
+  concurrency?: number;
+}
+
+export interface AppRunOptions {
+  /** The user's high-level task */
+  task: string;
+  /** Optional sub-task overrides (agentName → custom task) */
+  subTasks?: Record<string, string>;
+  /** Session ID for memory context sharing */
+  sessionId?: string;
+  /** Abort signal */
+  signal?: AbortSignal;
+  /** Permission mode for tool execution */
+  permissionMode?: string;
+  /** Confirmation handler for interactive tool approval */
+  confirmationHandler?: { requestConfirmation: (details: any) => Promise<any> };
+}
+
+export interface AppRunResult {
+  /** Per-agent responses */
+  responses: Array<{
+    agentName: string;
+    content: string;
+    toolCallsCount?: number;
+    durationMs?: number;
+  }>;
+  /** Synthesized summary */
+  summary: string;
+  /** Total duration */
+  totalDurationMs: number;
+  /** Number of agents that reported errors */
+  errorCount: number;
+}
+
+// ─── Built-in app prompts ──────────────────────────────────────────
+
+const BUILTIN_APP_TEMPLATES: Record<string, {
+  name: string;
+  description: string;
+  subtitle: string;
+  agents: Array<{
+    name: string;
+    role: string;
+    prompt: string;
+    tools?: string[];
+  }>;
+  instructions: string;
+}> = {
+  audit: {
+    name: 'Code Security Auditor',
+    description: 'Audit the codebase for security vulnerabilities, hardcoded secrets, and unsafe patterns',
+    subtitle: 'Security Audit',
+    instructions: 'Provide a comprehensive security audit with severity ratings and remediation steps.',
+    agents: [
+      {
+        name: 'scanner',
+        role: 'Vulnerability Scanner',
+        tools: ['Read', 'Grep', 'Glob'],
+        prompt: `You are a Security Vulnerability Scanner.
+Scan the codebase for: hardcoded API keys/secrets, SQL injection, XSS, unsafe eval/exec, path traversal, command injection.
+Use Grep with targeted patterns to find issues. Report every finding with file path, severity (CRITICAL/HIGH/MEDIUM/LOW), and line number.`,
+      },
+      {
+        name: 'analyzer',
+        role: 'Risk Analyzer',
+        tools: ['Read', 'Grep', 'Glob'],
+        prompt: `You are a Security Risk Analyzer.
+Review the dependency/package files, configuration files, and environment setup.
+Check for: outdated packages with known CVEs, misconfigured CORS, permissive file permissions, weak auth.
+Use Read on package.json, tsconfig, Dockerfiles, CI configs. Report risks with actionable fixes.`,
+      },
+      {
+        name: 'reporter',
+        role: 'Report Generator',
+        prompt: `You are a Security Report Generator. Given the scanner and analyzer findings, produce a final report.
+Structure: Executive Summary, Critical Findings, High, Medium, Low, Recommendations.
+Always include CVE references where applicable. Be concise and actionable.`,
+      },
+    ],
+  },
+  refactor: {
+    name: 'Code Refactoring Engine',
+    description: 'Analyze and refactor code for better structure, performance, and maintainability',
+    subtitle: 'Refactoring',
+    instructions: 'Execute the refactoring plan. Write the actual code changes.',
+    agents: [
+      {
+        name: 'analyzer',
+        role: 'Code Analyzer',
+        tools: ['Read', 'Grep', 'Glob'],
+        prompt: `You are a Code Analyzer. Analyze the codebase for refactoring opportunities.
+Look for: duplicate code, long functions, complex conditionals, unused imports, circular dependencies, inconsistent patterns.
+Use Grep and Read to find specific examples. Provide file paths and line numbers.`,
+      },
+      {
+        name: 'planner',
+        role: 'Refactoring Planner',
+        tools: ['Read'],
+        prompt: `You are a Refactoring Planner. Given the analyzer findings, create a step-by-step refactoring plan.
+Each step should specify: which file to modify, what to change, why, and the risk level (LOW/MEDIUM/HIGH).
+Order by impact (highest value first). Be concrete — include before/after code snippets.`,
+      },
+      {
+        name: 'implementer',
+        role: 'Implementation Engineer',
+        tools: ['Read', 'Edit', 'Write', 'Grep'],
+        prompt: `You are an Implementation Engineer. Execute the refactoring plan.
+Make the actual code changes using Edit and Write tools.
+After each change, use Read to verify the result. Keep the existing code style.`,
+      },
+    ],
+  },
+  'test-gen': {
+    name: 'Test Generator',
+    description: 'Generate comprehensive test suites for your code',
+    subtitle: 'Test Generation',
+    instructions: 'Generate the test files. Use existing test patterns in the project.',
+    agents: [
+      {
+        name: 'explorer',
+        role: 'Code Explorer',
+        tools: ['Read', 'Grep', 'Glob'],
+        prompt: `You are a Code Explorer. Find testable units in the codebase.
+For each module: list exported functions/classes, their parameters, return types, and side effects.
+Check for existing test files and test patterns used in the project.
+Report: which test framework is used, where tests live, existing test patterns.`,
+      },
+      {
+        name: 'designer',
+        role: 'Test Designer',
+        tools: ['Read'],
+        prompt: `You are a Test Designer. Given the explorer findings, design test cases.
+For each function/module: describe the happy path, error cases, edge cases, and any setup/teardown needed.
+Prioritize: critical business logic > utilities > edge cases. Be specific about assertions.`,
+      },
+      {
+        name: 'writer',
+        role: 'Test Writer',
+        tools: ['Read', 'Write', 'Edit', 'Grep'],
+        prompt: `You are a Test Writer. Generate the actual test files following the test designer's plan.
+Match the project's existing test patterns (framework, naming, directory structure).
+Write complete, runnable tests. Use Write to create new test files.`,
+      },
+    ],
+  },
+};
+
+// ─── AppBuilder ────────────────────────────────────────────────────
+
+export class AppBuilder {
+  private def: Partial<AppDefinition> = {};
+  private agents: SubAgentConfig[] = [];
+  private _prompts?: {
+    template: string;
+    subTaskTemplates: Record<string, string>;
+  };
+
+  constructor(id: string, name: string) {
+    this.def.id = id;
+    this.def.name = name;
+    this.def.modelConfig = requireModelConfig;
+    this.def.concurrency = 4;
+  }
+
+  /** Set short description (shown in /help) */
+  describe(description: string): this {
+    this.def.description = description;
+    return this;
+  }
+
+  /** Set usage instructions */
+  use(usage: string): this {
+    this.def.usage = usage;
+    return this;
+  }
+
+  /** Add example usages */
+  examples(examples: string[]): this {
+    this.def.examples = examples;
+    return this;
+  }
+
+  /** Set custom model resolver */
+  model(resolver: () => ResolvedModelConfig): this {
+    this.def.modelConfig = resolver;
+    return this;
+  }
+
+  /** Set max parallelism */
+  concurrency(n: number): this {
+    this.def.concurrency = n;
+    return this;
+  }
+
+  /** Set synthesizer agent name (default: first registered) */
+  synthesizer(name: string): this {
+    this.def.synthesizer = name;
+    return this;
+  }
+
+  /**
+   * Register a sub-agent.
+   *
+   * @param name - Agent identifier (used in delegation)
+   * @param role - Human-readable role name
+   * @param systemPrompt - System prompt for this agent
+   * @param tools - Tool names this agent can use (e.g. ['Read', 'Grep'])
+   */
+  agent(
+    name: string,
+    role: string,
+    systemPrompt: string,
+    tools?: string[],
+  ): this {
+    this.agents.push({ name, role, systemPrompt, config: {} as AgentConfig, tools });
+    return this;
+  }
+
+  /**
+   * Load a built-in app template and customize it.
+   * Available: 'audit', 'refactor', 'test-gen'
+   */
+  fromTemplate(templateId: string, overrides?: {
+    name?: string;
+    description?: string;
+    agentPrompts?: Record<string, string>;
+  }): this {
+    const template = BUILTIN_APP_TEMPLATES[templateId];
+    if (!template) {
+      throw new Error(`Unknown app template: "${templateId}". Available: ${Object.keys(BUILTIN_APP_TEMPLATES).join(', ')}`);
+    }
+
+    this.def.name = overrides?.name || template.name;
+    this.def.description = overrides?.description || template.description;
+    this.def.usage = `/${this.def.id || templateId} <task>`;
+    this.def.examples = [
+      `/${this.def.id || templateId} Audit the login module`,
+      `/${this.def.id || templateId} Check package.json for vulnerabilities`,
+    ];
+
+    this._prompts = {
+      template: templateId,
+      subTaskTemplates: {},
+    };
+
+    for (const agent of template.agents) {
+      const userPrompt = overrides?.agentPrompts?.[agent.name];
+      this.agent(
+        agent.name,
+        agent.role,
+        userPrompt || agent.prompt,
+        agent.tools,
+      );
+    }
+
+    return this;
+  }
+
+  /**
+   * Build and register the app, returning the definition.
+   * This also makes the app available via the slash-command system.
+   */
+  register(): AppDefinition {
+    if (!this.def.id) throw new Error('AppBuilder: id is required');
+    if (!this.def.description) this.def.description = '';
+    if (this.agents.length === 0) throw new Error('AppBuilder: at least one agent required');
+
+    const definition: AppDefinition = {
+      id: this.def.id,
+      name: this.def.name || this.def.id,
+      description: this.def.description,
+      usage: this.def.usage || `/${this.def.id} <task>`,
+      examples: this.def.examples || [`/${this.def.id} ...`],
+      modelConfig: this.def.modelConfig || requireModelConfig,
+      agents: this.agents,
+      synthesizer: this.def.synthesizer || this.agents[this.agents.length - 1]?.name,
+      concurrency: this.def.concurrency || 4,
+    };
+
+    // Register globally so slash commands can find it
+    registeredApps.set(definition.id, definition);
+    return definition;
+  }
+}
+
+// ─── Global App Registry ──────────────────────────────────────────
+
+/** Map of appId → AppDefinition */
+const registeredApps = new Map<string, AppDefinition>();
+
+/**
+ * Get all registered apps.
+ */
+export function getRegisteredApps(): AppDefinition[] {
+  return Array.from(registeredApps.values());
+}
+
+/**
+ * Get a specific app by ID.
+ */
+export function getApp(id: string): AppDefinition | undefined {
+  return registeredApps.get(id);
+}
+
+/**
+ * Run an app by its registered ID.
+ */
+export async function runApp(
+  appId: string,
+  options: AppRunOptions,
+): Promise<AppRunResult> {
+  const app = registeredApps.get(appId);
+  if (!app) {
+    throw new Error(`App "${appId}" not found. Available: ${Array.from(registeredApps.keys()).join(', ')}`);
+  }
+
+  const startTime = Date.now();
+  const modelCfg = app.modelConfig();
+  const agentConfig: AgentConfig = {
+    apiKey: modelCfg.apiKey,
+    baseURL: modelCfg.baseURL,
+    model: modelCfg.model,
+    timeout: modelCfg.timeout,
+  };
+
+  // Resolve permission mode
+  let permissionMode: string = options.permissionMode || 'default';
+  try {
+    const mode = configManager.getDefaultPermissionMode();
+    if (mode) permissionMode = mode;
+  } catch { /* use default */ }
+
+  const orchestrator = new OrchestratorAgent(
+    `App-${appId}`,
+    `You are ${app.name}. ${app.description}`,
+  );
+
+  // Register agents with resolved config
+  for (const agent of app.agents) {
+    orchestrator.registerAgent({
+      ...agent,
+      config: { ...agentConfig, ...agent.config },
+      confirmationHandler: options.confirmationHandler,
+      permissionMode: permissionMode as any,
+    });
+  }
+
+  // Build sub-tasks
+  const subTasks: Record<string, string> = {};
+  if (options.subTasks) {
+    Object.assign(subTasks, options.subTasks);
+  } else {
+    // Generate default sub-tasks from agent descriptions
+    for (const agent of app.agents) {
+      subTasks[agent.name] = agent.systemPrompt.split('\n')[0];
+    }
+  }
+
+  // Run orchestration
+  const result = await orchestrator.orchestrate(
+    options.task,
+    subTasks,
+    app.synthesizer,
+    options.sessionId,
+  );
+
+  const errorCount = result.responses.filter(
+    r => r.content.startsWith('[Error:') || r.content.startsWith('[Fatal:')
+  ).length;
+
+  return {
+    responses: result.responses.map(r => ({
+      agentName: r.agentName,
+      content: r.content,
+      toolCallsCount: r.metadata?.toolCallsCount,
+      durationMs: r.metadata?.durationMs,
+    })),
+    summary: result.summary,
+    totalDurationMs: Date.now() - startTime,
+    errorCount,
+  };
+}
+
+// ─── Auto-register built-in apps ───────────────────────────────────
+
+/** Create default built-in apps */
+export function createBuiltinApps(): AppDefinition[] {
+  return Object.entries(BUILTIN_APP_TEMPLATES).map(([id, template]) => {
+    const builder = new AppBuilder(id, template.name)
+      .describe(template.description)
+      .use(`/${id} <task>`)
+      .examples([
+        `/${id} ...`,
+      ]);
+
+    for (const agent of template.agents) {
+      builder.agent(agent.name, agent.role, agent.prompt, agent.tools);
+    }
+
+    return builder.register();
+  });
+}