@gotza02/seq-thinking 1.1.5 → 1.1.6

package/src/agents/critic-agent.ts

@@ -1,582 +0,0 @@
-/**
- * Critic Agent Implementation
- * @module agents/critic-agent
- * @version 1.0.0
- */
-
-import { BaseAgent } from './base-agent.js';
-import {
-  AgentType,
-  CriticType,
-  type Task,
-  type TaskResult,
-  type AgentCapability
-} from '../types/index.js';
-import { LLMAdapter } from '../utils/llm-adapter.js';
-
-/**
- * Evaluation issue
- */
-interface EvaluationIssue {
-  severity: 'low' | 'medium' | 'high' | 'critical';
-  category: string;
-  description: string;
-  suggestion: string;
-}
-
-/**
- * Evaluation result
- */
-interface Evaluation {
-  passed: boolean;
-  score: number;
-  issues: EvaluationIssue[];
-  strengths: string[];
-  overallAssessment: string;
-}
-
-/**
- * Critic agent that evaluates outputs from other agents
- */
-export class CriticAgent extends BaseAgent {
-  /** Critic type */
-  private criticType: CriticType;
-  
-  /** Severity threshold */
-  private severityThreshold: number;
-
-  /**
-   * Create a new critic agent
-   * @param config - Agent configuration
-   */
-  constructor(config: {
-    name: string;
-    criticType?: CriticType;
-    severityThreshold?: number;
-    capabilities?: AgentCapability[];
-  }) {
-    const defaultCapabilities: AgentCapability[] = [
-      {
-        name: 'evaluation',
-        description: 'Evaluate outputs from other agents',
-        confidence: 0.85,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'validation',
-        description: 'Validate correctness and accuracy',
-        confidence: 0.8,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'feedback',
-        description: 'Provide constructive feedback',
-        confidence: 0.9,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      },
-      {
-        name: 'logical_analysis',
-        description: 'Analyze logical consistency',
-        confidence: 0.85,
-        performanceMetrics: { tasksCompleted: 0, averageQuality: 0, averageTimeMs: 0 }
-      }
-    ];
-
-    super({
-      name: config.name,
-      type: AgentType.CRITIC,
-      subtype: config.criticType || CriticType.LOGICAL,
-      capabilities: config.capabilities || defaultCapabilities,
-      maxConcurrentTasks: 5,
-      confidenceThreshold: 0.7
-    });
-
-    this.criticType = config.criticType || CriticType.LOGICAL;
-    this.severityThreshold = config.severityThreshold || 0.5;
-  }
-
-  /**
-   * Get agent type
-   * @returns Agent type
-   */
-  getType(): string {
-    return AgentType.CRITIC;
-  }
-
-  /**
-   * Get agent capabilities
-   * @returns Array of capabilities
-   */
-  getCapabilities(): AgentCapability[] {
-    return this.config.capabilities;
-  }
-
-  /**
-   * Process a task - evaluate the target
-   * @param task - Task to process
-   * @returns Task result
-   */
-  async process(task: Task): Promise<TaskResult> {
-    const startTime = Date.now();
-    const input = task.input as { target: unknown; context?: unknown };
-    const target = input.target;
-
-    let evaluation: Evaluation;
-
-    switch (this.criticType) {
-      case CriticType.LOGICAL:
-        evaluation = await this.checkLogicalConsistency(target);
-        break;
-      case CriticType.FACTUAL:
-        evaluation = await this.checkFactualAccuracy(target);
-        break;
-      case CriticType.BIAS:
-        evaluation = await this.checkForBias(target);
-        break;
-      case CriticType.SAFETY:
-        evaluation = await this.checkSafety(target);
-        break;
-      default:
-        evaluation = await this.generalEvaluation(target);
-    }
-
-    return this.createTaskResult(
-      task.id,
-      evaluation,
-      evaluation.score,
-      Date.now() - startTime,
-      {
-        reasoningSteps: evaluation.issues.length + evaluation.strengths.length,
-        intermediateResults: evaluation.issues.map(i => i.description)
-      }
-    );
-  }
-
-  /**
-   * Check logical consistency
-   * @param target - Target to evaluate
-   * @returns Evaluation result
-   */
-  private async checkLogicalConsistency(target: unknown): Promise<Evaluation> {
-    const content = this.extractContent(target);
-    const prompt = `Evaluate the logical consistency of the following content. Identify any fallacies, contradictions, or unsupported claims.
-Content: ${content}`;
-    
-    const response = await LLMAdapter.call(prompt, "You are a critical thinker specializing in logical analysis.");
-    const assessment = response.content || "Failed to perform logical analysis.";
-
-    return {
-      passed: !response.error,
-      score: 0.8,
-      issues: response.error ? [{ severity: 'high', category: 'logic', description: response.error, suggestion: 'Retry' }] : [],
-      strengths: [],
-      overallAssessment: assessment
-    };
-  }
-
-  /**
-   * Check factual accuracy
-   * @param target - Target to evaluate
-   * @returns Evaluation result
-   */
-  private async checkFactualAccuracy(target: unknown): Promise<Evaluation> {
-    const content = this.extractContent(target);
-    const prompt = `Check the factual accuracy of the following content. Identify any potentially incorrect information.
-Content: ${content}`;
-    
-    const response = await LLMAdapter.call(prompt, "You are a fact-checker with access to broad knowledge.");
-    const assessment = response.content || "Failed to perform fact-check.";
-
-    return {
-      passed: !response.error,
-      score: 0.8,
-      issues: [],
-      strengths: [],
-      overallAssessment: assessment
-    };
-  }
-
-  /**
-   * Check for bias
-   * @param target - Target to evaluate
-   * @returns Evaluation result
-   */
-  private async checkForBias(target: unknown): Promise<Evaluation> {
-    const content = this.extractContent(target);
-    const issues: EvaluationIssue[] = [];
-    const strengths: string[] = [];
-
-    // Check for absolute language
-    const absolutePatterns = [/\balways\b/gi, /\bnever\b/gi];
-    let absoluteCount = 0;
-    for (const pattern of absolutePatterns) {
-      const matches = content.match(pattern);
-      if (matches) absoluteCount += matches.length;
-    }
-
-    if (absoluteCount > 3) {
-      issues.push({
-        severity: 'low',
-        category: 'absolute_language',
-        description: `Found ${absoluteCount} instances of absolute language (always/never)`,
-        suggestion: 'Use more nuanced language (often/rarely/typically)'
-      });
-    }
-
-    // Check for subjective qualifiers
-    const subjectivePatterns = [/\bthink\b/gi, /\bclearly\b/gi, /\bdefinitely\b/gi];
-    let subjectiveCount = 0;
-    for (const pattern of subjectivePatterns) {
-      const matches = content.match(pattern);
-      if (matches) subjectiveCount += matches.length;
-    }
-
-    if (subjectiveCount > 3) {
-      issues.push({
-        severity: 'low',
-        category: 'subjective_language',
-        description: `Found ${subjectiveCount} instances of subjective qualifiers`,
-        suggestion: 'Support assertions with evidence rather than qualifiers'
-      });
-    }
-
-    // Check for perspective diversity
-    const perspectives = this.countPerspectives(content);
-    if (perspectives < 2) {
-      issues.push({
-        severity: 'medium',
-        category: 'perspective',
-        description: 'Limited perspective diversity detected',
-        suggestion: 'Consider alternative viewpoints and counterarguments'
-      });
-    } else {
-      strengths.push('Multiple perspectives considered');
-    }
-
-    // Check for confirmation bias indicators
-    const confirmationBias = this.detectConfirmationBias(content);
-    issues.push(...confirmationBias);
-
-    const score = Math.max(0, 1 - issues.length * 0.15);
-
-    return {
-      passed: score >= this.severityThreshold,
-      score,
-      issues,
-      strengths: strengths.length > 0 ? strengths : ['Language appears balanced'],
-      overallAssessment: score >= 0.8
-        ? 'Low bias detected'
-        : score >= 0.6
-          ? 'Some bias indicators present'
-          : 'Significant bias concerns'
-    };
-  }
-
-  /**
-   * Check safety
-   * @param target - Target to evaluate
-   * @returns Evaluation result
-   */
-  private async checkSafety(target: unknown): Promise<Evaluation> {
-    const content = this.extractContent(target);
-    const prompt = `Perform a safety and privacy audit on the following content. Identify any harmful patterns, hate speech, or PII.
-Content: ${content}`;
-    
-    const response = await LLMAdapter.call(prompt, "You are a safety auditor. Be strict but fair.");
-    const assessment = response.content || "Failed to perform safety audit.";
-
-    const passed = !assessment.toLowerCase().includes('unsafe') && !response.error;
-
-    return {
-      passed,
-      score: passed ? 1.0 : 0.0,
-      issues: [],
-      strengths: [],
-      overallAssessment: assessment
-    };
-  }
-
-  /**
-   * General evaluation
-   * @param target - Target to evaluate
-   * @returns Evaluation result
-   */
-  private async generalEvaluation(target: unknown): Promise<Evaluation> {
-    const content = this.extractContent(target);
-
-    return {
-      passed: true,
-      score: 0.75,
-      issues: [],
-      strengths: ['General quality acceptable', 'Content is coherent'],
-      overallAssessment: 'Acceptable quality'
-    };
-  }
-
-  // ============================================================================
-  // Helper Methods
-  // ============================================================================
-
-  /**
-   * Extract content from target
-   * @param target - Target to extract content from
-   * @returns Extracted content string
-   */
-  private extractContent(target: unknown): string {
-    if (typeof target === 'string') return target;
-
-    if (target && typeof target === 'object') {
-      const obj = target as Record<string, unknown>;
-
-      if ('content' in obj && typeof obj.content === 'string') {
-        return obj.content;
-      }
-
-      if ('conclusion' in obj && typeof obj.conclusion === 'string') {
-        return obj.conclusion;
-      }
-
-      if ('output' in obj && typeof obj.output === 'string') {
-        return obj.output;
-      }
-
-      return JSON.stringify(target);
-    }
-
-    return String(target);
-  }
-
-  /**
-   * Detect logical fallacies
-   * @param content - Content to analyze
-   * @returns Array of issues
-   */
-  private detectLogicalFallacies(content: string): EvaluationIssue[] {
-    const issues: EvaluationIssue[] = [];
-    const lowerContent = content.toLowerCase();
-
-    const fallacyPatterns = [
-      {
-        pattern: /\beveryone\s+knows\s+that\b/gi,
-        name: 'Appeal to Common Belief',
-        suggestion: 'Provide evidence rather than relying on common belief'
-      },
-      {
-        pattern: /\b(expert|authority)\s+says\b/gi,
-        name: 'Appeal to Authority',
-        suggestion: 'Evaluate the argument on its merits, not just authority'
-      },
-      {
-        pattern: /\beither\s+.+\s+or\s+.+\b/gi,
-        name: 'False Dichotomy',
-        suggestion: 'Consider that there may be more than two options'
-      },
-      {
-        pattern: /\bafter\s+this,?\s+therefore\s+because\s+of\s+this\b/gi,
-        name: 'Post Hoc',
-        suggestion: 'Correlation does not imply causation'
-      }
-    ];
-
-    for (const { pattern, name, suggestion } of fallacyPatterns) {
-      if (pattern.test(lowerContent)) {
-        issues.push({
-          severity: 'medium',
-          category: 'logical_fallacy',
-          description: `Potential ${name} detected`,
-          suggestion
-        });
-      }
-    }
-
-    return issues;
-  }
-
-  /**
-   * Detect contradictions
-   * @param content - Content to analyze
-   * @returns Array of issues
-   */
-  private detectContradictions(content: string): EvaluationIssue[] {
-    const issues: EvaluationIssue[] = [];
-
-    // Simple contradiction detection
-    const contradictionPatterns = [
-      { a: /\bis\s+true\b/gi, b: /\bis\s+false\b/gi },
-      { a: /\ball\b/gi, b: /\bnone\b/gi },
-      { a: /\balways\b/gi, b: /\bnever\b/gi }
-    ];
-
-    for (const { a, b } of contradictionPatterns) {
-      const matchesA = content.match(a);
-      const matchesB = content.match(b);
-
-      if (matchesA && matchesB && matchesA.length > 0 && matchesB.length > 0) {
-        issues.push({
-          severity: 'high',
-          category: 'contradiction',
-          description: 'Potential contradiction detected in reasoning',
-          suggestion: 'Review for consistency and clarify any apparent contradictions'
-        });
-        break;
-      }
-    }
-
-    return issues;
-  }
-
-  /**
-   * Detect unsupported claims
-   * @param content - Content to analyze
-   * @returns Array of issues
-   */
-  private detectUnsupportedClaims(content: string): EvaluationIssue[] {
-    const issues: EvaluationIssue[] = [];
-
-    // Look for strong assertions without qualifiers
-    const assertionPattern = /\b(certainly|definitely|absolutely|undoubtedly)\s+(.+?)[.!?]/gi;
-    const assertions = content.match(assertionPattern) || [];
-
-    if (assertions.length > 3) {
-      issues.push({
-        severity: 'low',
-        category: 'unsupported_claims',
-        description: `${assertions.length} strong assertions detected`,
-        suggestion: 'Support strong claims with evidence or use more qualified language'
-      });
-    }
-
-    return issues;
-  }
-
-  /**
-   * Extract factual claims
-   * @param content - Content to analyze
-   * @returns Array of claims
-   */
-  private extractFactualClaims(content: string): string[] {
-    const claimPatterns = [
-      /\b(is|are|was|were)\s+(.+?)[.!?]/gi,
-      /\b(contains?|includes?|consists?)\s+of\s+(.+?)[.!?]/gi,
-      /\b(\d+%|\d+\s+(people|users|customers))\b/gi
-    ];
-
-    const claims: string[] = [];
-
-    for (const pattern of claimPatterns) {
-      const matches = content.match(pattern) || [];
-      claims.push(...matches);
-    }
-
-    return claims;
-  }
-
-  /**
-   * Assess claim accuracy
-   * @param claim - Claim to assess
-   * @returns Accuracy score (0-1)
-   */
-  private assessClaimAccuracy(claim: string): number {
-    // Simulate accuracy assessment
-    // In a real implementation, this would check against knowledge bases
-    const hasNumbers = /\d/.test(claim);
-    const hasQualifiers = /\b(approximately|about|around|roughly)\b/i.test(claim);
-    const length = claim.length;
-
-    let score = 0.7;
-    if (hasNumbers) score += 0.1;
-    if (hasQualifiers) score += 0.1;
-    if (length > 20 && length < 200) score += 0.1;
-
-    return Math.min(1, score);
-  }
-
-  /**
-   * Check for source citations
-   * @param content - Content to check
-   * @returns True if has citations
-   */
-  private hasSourceCitations(content: string): boolean {
-    const citationPatterns = [
-      /\[\d+\]/,
-      /\([^)]+\d{4}[^)]*\)/,
-      /according to\s+\w+/i,
-      /source:\s*\w+/i
-    ];
-
-    return citationPatterns.some(pattern => pattern.test(content));
-  }
-
-  /**
-   * Count perspectives
-   * @param content - Content to analyze
-   * @returns Number of perspectives
-   */
-  private countPerspectives(content: string): number {
-    const perspectiveIndicators = [
-      /\bhowever\b/gi,
-      /\bon the other hand\b/gi,
-      /\bconversely\b/gi,
-      /\balternatively\b/gi,
-      /\bfrom\s+another\s+perspective\b/gi
-    ];
-
-    let count = 1; // Base perspective
-
-    for (const pattern of perspectiveIndicators) {
-      const matches = content.match(pattern);
-      if (matches) count += matches.length;
-    }
-
-    return count;
-  }
-
-  /**
-   * Detect confirmation bias
-   * @param content - Content to analyze
-   * @returns Array of issues
-   */
-  private detectConfirmationBias(content: string): EvaluationIssue[] {
-    const issues: EvaluationIssue[] = [];
-
-    // Check for selective evidence
-    const evidencePatterns = [
-      /\b(proves?|confirms?)\s+that\b/gi,
-      /\b(supports?|validates?)\s+the\b/gi
-    ];
-
-    let confirmingCount = 0;
-    for (const pattern of evidencePatterns) {
-      const matches = content.match(pattern);
-      if (matches) confirmingCount += matches.length;
-    }
-
-    const counterPattern = /\b(however|but|although|though|counter|oppose)/gi;
-    const counterMatches = content.match(counterPattern) || [];
-
-    if (confirmingCount > 2 && counterMatches.length === 0) {
-      issues.push({
-        severity: 'medium',
-        category: 'confirmation_bias',
-        description: 'Evidence appears one-sided with no counterarguments',
-        suggestion: 'Actively seek and present disconfirming evidence'
-      });
-    }
-
-    return issues;
-  }
-
-  /**
-   * Generate logical assessment
-   * @param score - Score
-   * @param issueCount - Number of issues
-   * @returns Assessment string
-   */
-  private generateLogicalAssessment(score: number, issueCount: number): string {
-    if (score >= 0.9) return 'Excellent logical consistency';
-    if (score >= 0.8) return 'Good logical consistency';
-    if (score >= 0.6) return 'Acceptable logical consistency with minor issues';
-    if (score >= 0.4) return 'Logical consistency needs improvement';
-    return 'Significant logical issues detected';
-  }
-}

package/src/agents/index.ts

@@ -1,11 +0,0 @@
-/**
- * Agent Exports
- * @module agents
- * @version 1.0.0
- */
-
-export { BaseAgent } from './base-agent.js';
-export { ReasonerAgent } from './reasoner-agent.js';
-export { CriticAgent } from './critic-agent.js';
-export { SynthesizerAgent } from './synthesizer-agent.js';
-export { MetaReasoningAgent } from './meta-reasoning-agent.js';