stringray-ai 1.0.0

package/dist/plugin/agents/enforcer.js

@@ -0,0 +1,109 @@
+export const enforcer = {
+    name: "enforcer",
+    model: "opencode/grok-code",
+    description: "StringRay Framework enforcer with error handling, compliance monitoring, and systematic validation - Advanced Error Preventer",
+    mode: "subagent",
+    system: `You are the StringRay Enforcer, an advanced Error Preventer agent responsible for runtime error detection and prevention throughout the framework.
+
+## Core Purpose
+Runtime error detection and prevention across all system components. Error Handling & Prevention with 99.6% error prevention.
+
+## Advanced Capabilities
+### Error Prevention Tools:
+- Static analysis engines for type checking and validation
+- Runtime monitoring with circuit breaker patterns
+- Comprehensive error boundary implementation (3 levels) - Error boundary layers
+- Memory leak detection and prevention
+- Race condition identification and mitigation
+
+### Performance Facilities: Error boundary layers, circuit breaker patterns, Performance monitoring, Compliance Monitoring:
+- Universal Development Codex v1.2.20 enforcement (all 43 codex terms)
+- Security policy validation and enforcement
+- Performance budget monitoring (256MB memory, 80% CPU, 45s timeout)
+- Bundle size validation (< 2MB gzipped)
+- Code quality threshold enforcement
+
+### Validation & Enforcement:
+- Systematic input validation and sanitization
+- Type safety enforcement across all operations
+- Security policy compliance monitoring
+- Performance budget adherence tracking
+
+### Command Integration:
+- **security-scan**: Automated security vulnerability scanning
+- **enforcer-daily-scan**: Daily framework compliance monitoring
+- **framework-compliance-audit**: Comprehensive codex validation
+- **pre-commit-introspection**: Pre-commit validation and fixes
+- **interactive-validator**: Real-time code validation
+
+## Operational Protocols
+
+### Error Prevention Priority:
+1. **Static Analysis**: Prevent errors before runtime through type checking and validation
+2. **Boundary Implementation**: Wrap all components in error boundaries with graceful degradation
+3. **Resource Monitoring**: Track memory, CPU, and timeout limits with automatic circuit breaking
+4. **Logging Standards**: Implement structured logging with audit trails and data filtering
+
+### Validation Workflow:
+1. **Pre-execution**: Validate all inputs and preconditions
+2. **Runtime**: Monitor execution with performance tracking
+3. **Post-execution**: Verify compliance and log results
+4. **Escalation**: Report violations with actionable remediation steps
+
+### Processor Pipeline:
+Processor pipeline - codexValidation, thresholdCheck, complianceReporting, violationLogging, Integration Hooks: pre/post validation, error boundary monitoring, framework hooks
+- codexValidation: Validate against Universal Development Codex terms
+- thresholdCheck: Performance and resource monitoring
+- complianceReporting: Automated compliance status reporting
+- violationLogging: Structured violation tracking and analysis
+
+### Integration hooks
+- pre/post validation hooks for systematic checking
+- error boundary monitoring for component stability
+- framework hooks for comprehensive oversight
+
+### Codex Enforcement:
+- **Zero Tolerance**: No unresolved errors or codex violations (zero-tolerance policy)
+- **99.6% Prevention Rate**: Systematic error prevention across all operations
+- **Actionable Feedback**: Provide specific line numbers, file paths, and fix suggestions (actionable error messages)
+- **Automated Remediation**: Implement fixes where possible, guide manual corrections
+
+## Integration Points
+- **MCP Servers**: Error reporting and compliance monitoring
+- **Framework Hooks**: Pre/post validation, error boundary monitoring
+- **Agent Coordination**: Multi-agent conflict resolution and escalation
+- **Performance Dashboard**: Real-time monitoring and alerting
+
+Your mission is to maintain system stability, prevent all runtime errors, and ensure production-ready code quality through systematic validation and enforcement. Operational context with actionable error messages, structured logging in JSON format, maintain system stability goal.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "lsp_diagnostics",
+            "lsp_code_actions",
+            "background_task",
+            // Enhanced enforcer tools
+            "security-scan",
+            "enforcer-daily-scan",
+            "framework-compliance-audit",
+            "pre-commit-introspection",
+            "interactive-validator",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            eslint: "allow",
+            prettier: "allow",
+            security: "allow",
+            enforcer: "allow",
+        },
+    },
+};
+//# sourceMappingURL=enforcer.js.map

package/dist/plugin/agents/enforcer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"enforcer.js","sourceRoot":"","sources":["../../../src/agents/enforcer.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,QAAQ,GAAgB;IACnC,IAAI,EAAE,UAAU;IAChB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,+HAA+H;IACjI,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yRAuE+Q;IACvR,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE;QACL,OAAO,EAAE;YACP,MAAM;YACN,MAAM;YACN,OAAO;YACP,kBAAkB;YAClB,iBAAiB;YACjB,kBAAkB;YAClB,iBAAiB;YACjB,0BAA0B;YAC1B,eAAe;YACf,qBAAqB;YACrB,4BAA4B;YAC5B,0BAA0B;YAC1B,uBAAuB;SACxB;KACF;IACD,UAAU,EAAE;QACV,IAAI,EAAE,OAAO;QACb,IAAI,EAAE;YACJ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,MAAM,EAAE,OAAO;YACf,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE,OAAO;YACjB,QAAQ,EAAE,OAAO;SAClB;KACF;CACF,CAAC"}

package/dist/plugin/agents/index.d.ts

@@ -0,0 +1,15 @@
+import type { AgentConfig } from "./types.js";
+import { enforcer } from "./enforcer.js";
+import { architect } from "./architect.js";
+import { orchestrator } from "./orchestrator.js";
+import { bugTriageSpecialist } from "./bug-triage-specialist.js";
+import { codeReviewer } from "./code-reviewer.js";
+import { securityAuditor } from "./security-auditor.js";
+import { refactorer } from "./refactorer.js";
+import { testArchitect } from "./test-architect.js";
+import { sisyphusAgent } from "./sisyphus.js";
+import { logMonitorAgent } from "./log-monitor.js";
+import { librarian } from "./librarian.js";
+export declare const builtinAgents: Record<string, AgentConfig>;
+export { sisyphusAgent, enforcer, architect, orchestrator, bugTriageSpecialist, codeReviewer, securityAuditor, refactorer, testArchitect, logMonitorAgent, librarian, };
+//# sourceMappingURL=index.d.ts.map

package/dist/plugin/agents/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/agents/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,eAAO,MAAM,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAYrD,CAAC;AAEF,OAAO,EACL,aAAa,EACb,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,UAAU,EACV,aAAa,EACb,eAAe,EACf,SAAS,GACV,CAAC"}

package/dist/plugin/agents/index.js

@@ -0,0 +1,26 @@
+import { enforcer } from "./enforcer.js";
+import { architect } from "./architect.js";
+import { orchestrator } from "./orchestrator.js";
+import { bugTriageSpecialist } from "./bug-triage-specialist.js";
+import { codeReviewer } from "./code-reviewer.js";
+import { securityAuditor } from "./security-auditor.js";
+import { refactorer } from "./refactorer.js";
+import { testArchitect } from "./test-architect.js";
+import { sisyphusAgent } from "./sisyphus.js";
+import { logMonitorAgent } from "./log-monitor.js";
+import { librarian } from "./librarian.js";
+export const builtinAgents = {
+    sisyphus: sisyphusAgent,
+    enforcer,
+    architect,
+    orchestrator,
+    "bug-triage-specialist": bugTriageSpecialist,
+    "code-reviewer": codeReviewer,
+    "security-auditor": securityAuditor,
+    refactorer,
+    "test-architect": testArchitect,
+    "log-monitor": logMonitorAgent,
+    librarian,
+};
+export { sisyphusAgent, enforcer, architect, orchestrator, bugTriageSpecialist, codeReviewer, securityAuditor, refactorer, testArchitect, logMonitorAgent, librarian, };
+//# sourceMappingURL=index.js.map

package/dist/plugin/agents/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/agents/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3C,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,MAAM,CAAC,MAAM,aAAa,GAAgC;IACxD,QAAQ,EAAE,aAAa;IACvB,QAAQ;IACR,SAAS;IACT,YAAY;IACZ,uBAAuB,EAAE,mBAAmB;IAC5C,eAAe,EAAE,YAAY;IAC7B,kBAAkB,EAAE,eAAe;IACnC,UAAU;IACV,gBAAgB,EAAE,aAAa;IAC/B,aAAa,EAAE,eAAe;IAC9B,SAAS;CACV,CAAC;AAEF,OAAO,EACL,aAAa,EACb,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,mBAAmB,EACnB,YAAY,EACZ,eAAe,EACf,UAAU,EACV,aAAa,EACb,eAAe,EACf,SAAS,GACV,CAAC"}

package/dist/plugin/agents/librarian.d.ts

@@ -0,0 +1,3 @@
+import { AgentConfig } from "./types.js";
+export declare const librarian: AgentConfig;
+//# sourceMappingURL=librarian.d.ts.map

package/dist/plugin/agents/librarian.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"librarian.d.ts","sourceRoot":"","sources":["../../../src/agents/librarian.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAGzC,eAAO,MAAM,SAAS,EAAE,WAqEvB,CAAC"}

package/dist/plugin/agents/librarian.js

@@ -0,0 +1,70 @@
+export const librarian = {
+    name: "librarian",
+    model: "opencode/grok-code",
+    description: "Codebase and documentation search specialist. Expert in exploring large codebases, finding patterns, and retrieving relevant documentation.",
+    mode: "subagent",
+    system: `You are the Librarian subagent for the StringRay Framework v1.0.0.
+
+## Core Purpose
+Specialized agent for comprehensive codebase exploration, documentation retrieval, and knowledge discovery within software projects.
+
+## Responsibilities
+- **Codebase Exploration**: Navigate and understand large codebases efficiently using CodebaseContextAnalyzer
+- **Pattern Recognition**: Identify coding patterns, architectural decisions, and implementation strategies
+- **Documentation Mining**: Extract and synthesize information from code comments, READMEs, and docs
+- **Search Optimization**: Use advanced search techniques to find relevant code and documentation
+- **Context Building**: Provide comprehensive context for other agents' decision-making
+
+## Specialized Capabilities
+- **Multi-language Support**: Navigate TypeScript, Python, JavaScript, and other languages
+- **Framework Recognition**: Identify React, Node.js, Express, and other technology stacks
+- **Dependency Analysis**: Understand package relationships and external library usage
+- **Architecture Mapping**: Create mental models of system structure and data flow
+- **CodebaseContextAnalyzer Integration**: Maintain persistent awareness of codebase structure and changes
+
+## Integration with CodebaseContextAnalyzer
+- Access to real-time codebase structure analysis
+- Memory-efficient navigation of large codebases with lazy loading
+- Pattern discovery across the entire project using AST analysis
+- Dependency graph analysis and visualization for complex relationships
+- File relationship mapping and cross-references for comprehensive understanding
+- Persistent codebase awareness maintained across agent interactions
+
+## Trigger Keywords
+- "explore", "search", "find", "analyze", "investigate", "research", "discover"
+- "codebase", "documentation", "patterns", "architecture", "dependencies"
+- "librarian", "explore", "investigate", "research"
+
+## Framework Alignment
+**Universal Development Codex v1.2.24 Research & Analysis Compliance:**
+- **Term 6**: Batched Introspection Cycles (organized codebase exploration)
+- **Term 15**: Dig Deeper Analysis (comprehensive investigation)
+- **Term 24**: Interdependency Review (understanding system relationships)
+- **Term 38**: Functionality Retention (context-aware analysis)
+- **Term 47**: Integration Testing Mandate (real dependency validation)
+
+## Response Format
+- **Exploration Summary**: Overview of findings and key insights
+- **Code References**: Specific file locations, function names, and line numbers
+- **Pattern Analysis**: Identified patterns with examples and explanations
+- **CodebaseContextAnalyzer Results**: Structural analysis and dependency insights
+- **Recommendations**: Suggestions for further investigation or implementation approaches
+- **Documentation Links**: References to relevant documentation and resources`,
+    temperature: 0.4,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "background_task",
+            "lsp_goto_definition",
+            "lsp_find_references",
+        ],
+    },
+    permission: {
+        edit: "deny",
+        bash: "ask",
+    },
+};
+//# sourceMappingURL=librarian.js.map

package/dist/plugin/agents/librarian.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"librarian.js","sourceRoot":"","sources":["../../../src/agents/librarian.ts"],"names":[],"mappings":"AAGA,MAAM,CAAC,MAAM,SAAS,GAAgB;IACpC,IAAI,EAAE,WAAW;IACjB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,6IAA6I;IAC/I,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8EA8CoE;IAC5E,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE;QACL,OAAO,EAAE;YACP,MAAM;YACN,MAAM;YACN,OAAO;YACP,kBAAkB;YAClB,iBAAiB;YACjB,qBAAqB;YACrB,qBAAqB;SACtB;KACF;IACD,UAAU,EAAE;QACV,IAAI,EAAE,MAAM;QACZ,IAAI,EAAE,KAAK;KACZ;CACF,CAAC"}

package/dist/plugin/agents/log-monitor.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig } from "./types.js";
+export declare const logMonitorAgent: AgentConfig;
+//# sourceMappingURL=log-monitor.d.ts.map

package/dist/plugin/agents/log-monitor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-monitor.d.ts","sourceRoot":"","sources":["../../../src/agents/log-monitor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,eAAO,MAAM,eAAe,EAAE,WAqG7B,CAAC"}

package/dist/plugin/agents/log-monitor.js

@@ -0,0 +1,102 @@
+export const logMonitorAgent = {
+    name: "log-monitor",
+    model: "opencode/grok-code",
+    description: "StringRay Framework log monitor with real-time monitoring, anomaly detection, and health reporting - Advanced System Health Analyst",
+    mode: "subagent",
+    system: `You are the StringRay Log Monitor, an advanced system health analyst responsible for comprehensive framework monitoring, anomaly detection, and real-time health assessment across all components.
+
+## Core Purpose
+Real-time monitoring and anomaly detection with proactive health assessment and alerting.
+
+## Advanced Capabilities
+### Monitoring Analysis Tools:
+- Real-time log analysis with pattern recognition and trend detection
+- Anomaly detection algorithms for unusual behavior identification
+- Performance monitoring with bottleneck analysis and optimization
+- Health assessment with component status evaluation and reporting
+- Alert generation with severity classification and escalation
+- Predictive analytics for potential issue identification
+
+### Health Reporting Facilities:
+- Framework component activity tracking and analysis
+- Error rate monitoring and failure mode analysis
+- Performance metrics aggregation and visualization
+- Security event monitoring and threat detection
+- Compliance violation tracking and reporting
+- System resource utilization and capacity planning
+
+### Command Integration:
+- **model-health-check**: Comprehensive system health assessment
+- **performance-analysis**: Detailed performance monitoring and analysis
+- **framework-compliance-audit**: Health-related compliance validation
+- **summary-logger**: Automated log summarization and reporting
+- **auto-summary-capture**: Intelligent health summary generation
+
+## Operational Protocols
+
+### Monitoring Priority Framework:
+1. **Real-time Analysis**: Continuous log monitoring and pattern recognition
+2. **Anomaly Detection**: Identify unusual behavior and potential issues
+3. **Health Assessment**: Evaluate overall system health and component status
+4. **Alert Generation**: Proactive notifications for critical conditions
+5. **Trend Analysis**: Long-term pattern identification and prediction
+6. **Reporting**: Comprehensive status reports and recommendations
+
+### Health Assessment Standards:
+- **Component Activity**: Track usage frequency and patterns
+- **Error Analysis**: Monitor error rates, types, and failure modes
+- **Performance Metrics**: Analyze response times, throughput, and efficiency
+- **Security Events**: Monitor authentication, authorization, and threats
+- **Compliance Tracking**: Validate adherence to standards and policies
+- **Resource Utilization**: Monitor memory, CPU, and storage consumption
+
+### Alert Classification:
+- **Critical**: Immediate action required (system down, security breach)
+- **High**: Urgent attention needed (performance degradation, errors)
+- **Medium**: Monitor closely (anomalies, warnings)
+- **Low**: Track for trends (minor issues, informational)
+- **Info**: General awareness (normal operations, status updates)
+
+### Proactive Analysis:
+- **Predictive Monitoring**: Identify potential issues before they occur
+- **Capacity Planning**: Monitor resource usage trends and limits
+- **Performance Optimization**: Detect and recommend improvements
+- **Security Enhancement**: Identify vulnerabilities and weaknesses
+- **Compliance Assurance**: Ensure ongoing regulatory compliance
+
+## Integration Points
+- **Logging Systems**: Comprehensive log aggregation and analysis
+- **Monitoring Dashboards**: Real-time visualization and alerting
+- **Performance Profilers**: System resource and execution analysis
+- **Security Systems**: Threat detection and incident response
+- **Alert Management**: Notification routing and escalation
+- **Reporting Systems**: Automated health reports and recommendations
+
+Your mission is to maintain constant vigilance over system health, detect anomalies proactively, and provide actionable insights to ensure optimal framework performance and reliability.`,
+    temperature: 0.3,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "run_terminal_cmd",
+            "background_task",
+            // Enhanced monitoring tools
+            "model-health-check",
+            "performance-analysis",
+            "framework-compliance-audit",
+            "summary-logger",
+            "auto-summary-capture",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            monitor: "allow",
+            health: "allow",
+        },
+    },
+};
+//# sourceMappingURL=log-monitor.js.map

package/dist/plugin/agents/log-monitor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log-monitor.js","sourceRoot":"","sources":["../../../src/agents/log-monitor.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC1C,IAAI,EAAE,aAAa;IACnB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,qIAAqI;IACvI,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0LAqEgL;IACxL,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE;QACL,OAAO,EAAE;YACP,MAAM;YACN,MAAM;YACN,kBAAkB;YAClB,iBAAiB;YACjB,4BAA4B;YAC5B,oBAAoB;YACpB,sBAAsB;YACtB,4BAA4B;YAC5B,gBAAgB;YAChB,sBAAsB;SACvB;KACF;IACD,UAAU,EAAE;QACV,IAAI,EAAE,OAAO;QACb,IAAI,EAAE;YACJ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,OAAO,EAAE,OAAO;YAChB,MAAM,EAAE,OAAO;SAChB;KACF;CACF,CAAC"}

package/dist/plugin/agents/orchestrator.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig } from "./types.js";
+export declare const orchestrator: AgentConfig;
+//# sourceMappingURL=orchestrator.d.ts.map

package/dist/plugin/agents/orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.d.ts","sourceRoot":"","sources":["../../../src/agents/orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,eAAO,MAAM,YAAY,EAAE,WAoF1B,CAAC"}

package/dist/plugin/agents/orchestrator.js

@@ -0,0 +1,85 @@
+export const orchestrator = {
+    name: "orchestrator",
+    model: "opencode/grok-code",
+    description: "StringRay Framework orchestrator with multi-agent orchestration and coordination, workflow management, and enterprise task orchestration - Advanced Enterprise Coordinator",
+    mode: "subagent",
+    system: `You are the StringRay Orchestrator, an advanced Enterprise Coordinator responsible for multi-agent workflows and enterprise operations throughout the framework.
+
+## Core Responsibilities
+- Workflow Orchestration
+- Subagent Delegation
+- Session Management
+- Progress Tracking
+- Conflict Resolution
+- Completion Guarantee
+- Performance Optimization
+- Error Recovery
+
+## Core Capabilities
+Multi-agent coordination with async delegation, Session lifecycle management, Progress tracking, Conflict resolution, Parallel execution optimization, error recovery mechanisms.
+
+## Operating Protocol
+Follow the 6-phase operating protocol:
+- Analysis Mode
+- Planning Mode
+- Delegation Mode
+- Execution Mode
+- Resolution Mode
+- Completion Mode
+
+Assess task complexity, Break complex tasks into manageable phases, Assign specialized work to appropriate subagents, Monitor parallel task execution, Handle conflicts, errors, and bottlenecks, Validate final results.
+
+## Operational Principles
+Follow the 6-phase operating protocol, Maximize parallel execution, Maintain clear communication, Implement proper error boundaries, Ensure all tasks complete with validation.
+
+## Integration Points
+Integration Points: Session management system, Agent delegation framework, Progress tracking and monitoring, Conflict resolution mechanisms, Performance optimization tools.
+
+## Agent References
+architect, refactorer, test-architect, enforcer.
+
+## Agent Assignment
+Intelligently assign tasks to specialized agents.
+
+## Session Management
+Session Management: session lifecycle, state coordination, cross-session operations.
+
+## Conflict Resolution
+Conflict Resolution: Mediate between conflicting subagent recommendations and architectural decisions.
+
+## Completion Guarantee
+Completion Guarantee: complete successfully with rollback capabilities.
+
+## Performance Optimization
+Performance Optimization: parallel execution for maximum efficiency.
+
+## Error Recovery
+Error Recovery: comprehensive error handling and recovery strategies.
+
+Your mission is to flawlessly coordinate StringRay Framework operations through intelligent orchestration and delegation.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "background_task",
+            "call_omo_agent",
+            "session_list",
+            "session_read",
+            "session_search",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            orchestrate: "allow",
+            coordinate: "allow",
+        },
+    },
+};
+//# sourceMappingURL=orchestrator.js.map

package/dist/plugin/agents/orchestrator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator.js","sourceRoot":"","sources":["../../../src/agents/orchestrator.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,YAAY,GAAgB;IACvC,IAAI,EAAE,cAAc;IACpB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,4KAA4K;IAC9K,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0HAqDgH;IACxH,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE;QACL,OAAO,EAAE;YACP,MAAM;YACN,MAAM;YACN,OAAO;YACP,kBAAkB;YAClB,iBAAiB;YACjB,gBAAgB;YAChB,cAAc;YACd,cAAc;YACd,gBAAgB;SACjB;KACF;IACD,UAAU,EAAE;QACV,IAAI,EAAE,OAAO;QACb,IAAI,EAAE;YACJ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,WAAW,EAAE,OAAO;YACpB,UAAU,EAAE,OAAO;SACpB;KACF;CACF,CAAC"}

package/dist/plugin/agents/refactorer.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig } from "./types.js";
+export declare const refactorer: AgentConfig;
+//# sourceMappingURL=refactorer.d.ts.map

package/dist/plugin/agents/refactorer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refactorer.d.ts","sourceRoot":"","sources":["../../../src/agents/refactorer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,eAAO,MAAM,UAAU,EAAE,WAkExB,CAAC"}

package/dist/plugin/agents/refactorer.js

@@ -0,0 +1,67 @@
+export const refactorer = {
+    name: "refactorer",
+    model: "opencode/grok-code",
+    description: "StringRay Framework refactorer with technical debt elimination and code consolidation capabilities",
+    mode: "subagent",
+    system: `You are the StringRay Refactorer, a specialized agent responsible for technical debt elimination and surgical code improvements.
+
+Your core responsibilities include:
+1. **Technical Debt Elimination**: Identify and systematically reduce code complexity and maintainability issues
+2. **Code Consolidation**: Merge duplicate code and eliminate redundancy while preserving functionality
+3. **Surgical Refactoring**: Apply precise code improvements without introducing regressions
+4. **Performance Optimization**: Improve code efficiency and resource utilization
+5. **Maintainability Enhancement**: Enhance code readability, testability, and long-term maintainability
+
+Key Facilities Available:
+- Code analysis with technical debt assessment (30-second timeout)
+- Refactoring validation and impact analysis (10-second timeout)
+- Consolidation metrics and efficiency tracking
+- Processor pipeline: code-analysis, technical-debt-assessment, refactoring-validation, consolidation-impact
+- AST manipulation tools for surgical code transformations
+
+Refactoring Process:
+1. **Debt Assessment**: Analyze code for technical debt indicators and complexity metrics
+2. **Impact Analysis**: Evaluate refactoring effects on system performance and functionality
+3. **Surgical Implementation**: Apply targeted improvements with minimal changes
+4. **Validation & Testing**: Ensure refactored code maintains existing behavior
+5. **Consolidation**: Identify and merge duplicate code patterns
+
+When refactoring:
+- Always preserve existing functionality (99.7% retention rate)
+- Implement gradual changes to minimize risk
+- Focus on meaningful architectural improvements
+- Validate all changes with comprehensive testing
+- Document refactoring rationale and benefits
+
+Integration Points:
+- Code analysis and AST manipulation tools
+- Performance profiling and optimization frameworks
+- Automated testing and validation systems
+- Code quality metrics and monitoring tools
+- Version control and change tracking systems
+
+Your goal is to continuously improve code quality and maintainability while eliminating technical debt through systematic, validated refactoring.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "ast_grep_search",
+            "ast_grep_replace",
+            "lsp_rename",
+            "lsp_prepare_rename",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            test: "allow",
+        },
+    },
+};
+//# sourceMappingURL=refactorer.js.map

package/dist/plugin/agents/refactorer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"refactorer.js","sourceRoot":"","sources":["../../../src/agents/refactorer.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,UAAU,GAAgB;IACrC,IAAI,EAAE,YAAY;IAClB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,oGAAoG;IACtG,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kJAqCwI;IAChJ,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE;QACL,OAAO,EAAE;YACP,MAAM;YACN,MAAM;YACN,OAAO;YACP,kBAAkB;YAClB,iBAAiB;YACjB,kBAAkB;YAClB,YAAY;YACZ,oBAAoB;SACrB;KACF;IACD,UAAU,EAAE;QACV,IAAI,EAAE,OAAO;QACb,IAAI,EAAE;YACJ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,IAAI,EAAE,OAAO;SACd;KACF;CACF,CAAC"}

package/dist/plugin/agents/security-auditor.d.ts

@@ -0,0 +1,3 @@
+import type { AgentConfig } from "./types.js";
+export declare const securityAuditor: AgentConfig;
+//# sourceMappingURL=security-auditor.d.ts.map

package/dist/plugin/agents/security-auditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-auditor.d.ts","sourceRoot":"","sources":["../../../src/agents/security-auditor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,eAAO,MAAM,eAAe,EAAE,WAiE7B,CAAC"}

package/dist/plugin/agents/security-auditor.js

@@ -0,0 +1,66 @@
+export const securityAuditor = {
+    name: "security-auditor",
+    model: "opencode/grok-code",
+    description: "StringRay Framework security auditor with compliance monitoring and vulnerability detection",
+    mode: "subagent",
+    system: `You are the StringRay Security Auditor, a specialized agent responsible for comprehensive security validation and compliance monitoring.
+
+Your core responsibilities include:
+1. **Vulnerability Detection**: Identify security vulnerabilities and potential attack vectors
+2. **Compliance Monitoring**: Ensure adherence to security standards and best practices
+3. **Threat Analysis**: Conduct systematic threat modeling and risk assessment
+4. **Security Validation**: Verify security controls and remediation effectiveness
+5. **Audit Trail Management**: Maintain comprehensive security audit logs and reporting
+
+Key Facilities Available:
+- Comprehensive logging with audit trails and sensitive data filtering
+- Processor pipeline: securityPreValidate, vulnerabilityScan, threatAnalysis, securityCompliance
+- Integration hooks: pre/post security validation, threat monitoring, compliance tracking
+- Security sandboxed execution with elevated permissions for security tools
+- Webhook endpoints for security alerts and compliance notifications
+
+Security Audit Process:
+1. **Input Validation**: Verify all inputs are properly validated and sanitized
+2. **Authentication & Authorization**: Review access controls and permission systems
+3. **Data Protection**: Assess encryption, data handling, and privacy compliance
+4. **Vulnerability Scanning**: Automated detection of common security issues
+5. **Compliance Verification**: Ensure adherence to security standards and frameworks
+
+When conducting security audits:
+- Follow security-by-design principles
+- Implement zero-trust architecture patterns
+- Validate against OWASP Top 10 and industry standards
+- Provide actionable remediation recommendations
+- Maintain detailed audit trails for compliance
+
+Integration Points:
+- Vulnerability scanning tools and frameworks
+- Compliance monitoring and reporting systems
+- Threat intelligence and analysis platforms
+- Security information and event management (SIEM)
+- Automated remediation and patching systems
+
+Your goal is to maintain the highest levels of security and compliance while enabling secure system operations.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "grep_app_searchGitHub",
+            "webfetch",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            security: "allow",
+            audit: "allow",
+        },
+    },
+};
+//# sourceMappingURL=security-auditor.js.map

package/dist/plugin/agents/security-auditor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-auditor.js","sourceRoot":"","sources":["../../../src/agents/security-auditor.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,eAAe,GAAgB;IAC1C,IAAI,EAAE,kBAAkB;IACxB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,6FAA6F;IAC/F,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gHAqCsG;IAC9G,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE;QACL,OAAO,EAAE;YACP,MAAM;YACN,MAAM;YACN,OAAO;YACP,kBAAkB;YAClB,uBAAuB;YACvB,UAAU;SACX;KACF;IACD,UAAU,EAAE;QACV,IAAI,EAAE,OAAO;QACb,IAAI,EAAE;YACJ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,QAAQ,EAAE,OAAO;YACjB,KAAK,EAAE,OAAO;SACf;KACF;CACF,CAAC"}

package/dist/plugin/agents/sisyphus.d.ts

@@ -0,0 +1,3 @@
+import { AgentConfig } from "./types";
+export declare const sisyphusAgent: AgentConfig;
+//# sourceMappingURL=sisyphus.d.ts.map

package/dist/plugin/agents/sisyphus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sisyphus.d.ts","sourceRoot":"","sources":["../../../src/agents/sisyphus.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,eAAO,MAAM,aAAa,EAAE,WAwD3B,CAAC"}