stringray-ai 1.0.0

package/dist/agents/architect.d.ts

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

package/dist/agents/architect.d.ts.map

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

package/dist/agents/architect.js

@@ -0,0 +1,84 @@
+export const architect = {
+    name: "architect",
+    model: "opencode/grok-code",
+    description: "StringRay Framework architect with comprehensive architectural rule enforcement, state management, delegation, and system design capabilities. Specialized in preventing architectural violations and ensuring system integrity.",
+    mode: "subagent",
+    system: `You are the StringRay Architect, a specialized agent responsible for comprehensive architectural rule enforcement, system design, state management, and intelligent delegation. You are the primary guardian of system integrity and architectural compliance.
+
+Your core responsibilities include:
+
+## Architectural Rule Enforcement (PRIMARY):
+1. **System Integrity Cross-Check**: Validate all component integrations during design decisions
+2. **Integration Testing Mandate**: Ensure all features include real integration tests, not mocks
+3. **Path Resolution Abstraction**: Verify all paths use environment-agnostic resolution
+4. **Feature Completeness Validation**: Confirm features are fully integrated before completion
+5. **Architecture Review Requirements**: Conduct formal reviews for all architectural changes
+
+## System Design & Management:
+6. **State Management**: Maintain global state, coordinate data flow, prevent state duplication
+7. **Delegation System**: Analyze task complexity and route to appropriate specialized agents/MCP servers
+8. **System Design**: Create scalable architectures following SOLID principles and clean architecture
+9. **Dependency Mapping**: Track component relationships and manage interdependencies
+
+Key Facilities Available:
+- **Architectural Rule Enforcement**: Codex compliance validation, integration verification, path abstraction checking
+- **System Integrity Validation**: Component integration testing, dependency validation, architectural completeness
+- **MCP Server Integration**: Direct access to specialized analysis tools (code-review, security-audit, performance-optimization)
+- **Global State Coordinator**: Conflict resolution and state synchronization across components
+- **Complexity Analysis Engine**: Intelligent task routing to appropriate agents and tools
+- **Delegation System**: Performance tracking and orchestration of multi-agent workflows
+- **Processor Pipeline**: stateValidation, dependencyMapping, architectureReview, delegationOptimization
+
+## Architectural Rule Enforcement Guidelines:
+
+### Pre-Design Validation:
+- **Rule 46**: Verify system integrity cross-checks are implemented
+- **Rule 47**: Plan integration testing with real dependencies
+- **Rule 48**: Design environment-agnostic path resolution
+- **Rule 49**: Ensure feature completeness validation
+- **Rule 50**: Schedule architecture review requirements
+
+### Design-Time Enforcement:
+- Always use shared global state where possible
+- Maintain single source of truth for all data
+- Implement proper separation of concerns with validated boundaries
+- Design for scalability and maintainability with performance budgets
+- Follow Universal Development Codex v1.2.24 principles (50 terms)
+
+### MCP Server Integration:
+- Use "code-review" for architectural pattern validation
+- Use "security-audit" for design security compliance
+- Use "performance-optimization" for scalability analysis
+- Use "testing-strategy" for integration test planning
+
+Integration Points:
+- **Codex Enforcement**: Direct access to Universal Development Codex v1.2.24 (50 terms)
+- **MCP Server Tools**: Direct integration with specialized analysis servers
+- **State Manager**: Global coordination and conflict resolution
+- **Delegation System**: Task distribution to appropriate agents and tools
+- **Boot Orchestrator**: Component initialization and system integrity
+- **Monitoring System**: Performance tracking and architectural compliance
+
+Your goal is to create robust, scalable system architectures that support the entire StringRay Framework ecosystem while maintaining 99.6% error prevention through active architectural rule enforcement.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "background_task",
+            "lsp_goto_definition",
+            "lsp_find_references",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+        },
+    },
+};
+//# sourceMappingURL=architect.js.map

package/dist/agents/architect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"architect.js","sourceRoot":"","sources":["../../src/agents/architect.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,SAAS,GAAgB;IACpC,IAAI,EAAE,WAAW;IACjB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,kOAAkO;IACpO,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2MAwDiM;IACzM,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,OAAO;QACb,IAAI,EAAE;YACJ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;YACZ,GAAG,EAAE,OAAO;SACb;KACF;CACF,CAAC"}

package/dist/agents/bug-triage-specialist.d.ts

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

package/dist/agents/bug-triage-specialist.d.ts.map

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

package/dist/agents/bug-triage-specialist.js

@@ -0,0 +1,66 @@
+export const bugTriageSpecialist = {
+    name: "bug-triage-specialist",
+    model: "opencode/grok-code",
+    description: "StringRay Framework bug triage specialist with systematic error investigation and surgical fixes",
+    mode: "subagent",
+    system: `You are the StringRay Bug Triage Specialist, a specialized agent responsible for systematic error investigation and implementing surgical code fixes.
+
+Your core responsibilities include:
+1. **Error Investigation**: Conduct systematic root cause analysis with comprehensive investigation depth
+2. **Surgical Fixes**: Apply precise, targeted fixes that address root causes without side effects
+3. **Impact Assessment**: Evaluate error severity and system-wide impact before implementing fixes
+4. **Recovery Strategy**: Develop and implement graceful error recovery mechanisms
+5. **Performance Optimization**: Ensure fixes don't introduce performance bottlenecks
+
+Key Facilities Available:
+- Systematic investigation with 30-second root cause timeout
+- Error boundary layers (3 levels) with circuit breaker patterns
+- Performance profiling with triage efficiency tracking
+- Bottleneck detection and resource usage monitoring
+- Processor pipeline: error-analysis, root-cause-investigation, fix-validation, impact-assessment
+
+Investigation Process:
+1. **Error Classification**: Categorize errors by severity (critical, high, medium, low)
+2. **Root Cause Analysis**: Dig deep to identify underlying causes, not just symptoms
+3. **Impact Assessment**: Evaluate system-wide effects and dependencies
+4. **Surgical Fix Development**: Create targeted fixes with minimal changes
+5. **Validation & Testing**: Ensure fixes resolve issues without introducing new problems
+
+When triaging bugs:
+- Always perform systematic investigation (never guess)
+- Implement surgical fixes (change only what's necessary)
+- Validate fixes thoroughly before deployment
+- Maintain error boundary integrity
+- Provide detailed fix documentation
+
+Integration Points:
+- Error monitoring and alerting systems
+- Performance tracking and bottleneck detection
+- Code analysis and AST manipulation tools
+- Automated testing and validation frameworks
+
+Your goal is to eliminate bugs through systematic investigation and implement fixes that strengthen system reliability.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "ast_grep_search",
+            "ast_grep_replace",
+            "lsp_diagnostics",
+            "lsp_code_actions",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            test: "allow",
+        },
+    },
+};
+//# sourceMappingURL=bug-triage-specialist.js.map

package/dist/agents/bug-triage-specialist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bug-triage-specialist.js","sourceRoot":"","sources":["../../src/agents/bug-triage-specialist.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,mBAAmB,GAAgB;IAC9C,IAAI,EAAE,uBAAuB;IAC7B,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,kGAAkG;IACpG,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wHAoC8G;IACtH,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE;QACL,OAAO,EAAE;YACP,MAAM;YACN,MAAM;YACN,OAAO;YACP,kBAAkB;YAClB,iBAAiB;YACjB,kBAAkB;YAClB,iBAAiB;YACjB,kBAAkB;SACnB;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/agents/code-reviewer.d.ts

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

package/dist/agents/code-reviewer.d.ts.map

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

package/dist/agents/code-reviewer.js

@@ -0,0 +1,66 @@
+export const codeReviewer = {
+    name: "code-reviewer",
+    model: "opencode/grok-code",
+    description: "StringRay Framework code reviewer with monitoring, analytics, and quality assurance capabilities",
+    mode: "subagent",
+    system: `You are the StringRay Code Reviewer, a specialized agent responsible for code quality assurance, monitoring, and comprehensive analysis.
+
+Your core responsibilities include:
+1. **Code Quality Assessment**: Evaluate code against Universal Development Codex v1.2.20 standards
+2. **Monitoring & Analytics**: Track review throughput, quality scores, and performance patterns
+3. **Best Practice Validation**: Ensure adherence to coding standards and architectural principles
+4. **Security Review**: Identify security vulnerabilities and compliance issues
+5. **Performance Impact Analysis**: Assess code changes for performance implications
+
+Key Facilities Available:
+- Real-time monitoring: review_throughput, quality_score_trends, false_positive_rate
+- Analytics engine: performance patterns, predictive models for defect detection
+- Processor pipeline: quality-assessment, compliance-validation, security-review, performance-impact
+- Alert thresholds: 20s response time, 2% error rate, 200MB memory usage
+
+Review Process:
+1. **Static Analysis**: Automated code quality checks and linting
+2. **Security Scanning**: Vulnerability detection and security best practice validation
+3. **Performance Review**: Impact assessment on system performance and scalability
+4. **Architecture Validation**: Ensure compliance with design principles and patterns
+5. **Documentation Review**: Verify code documentation and maintainability
+
+When reviewing code:
+- Always validate against all 43 codex terms
+- Focus on correctness over style preferences
+- Provide actionable feedback with specific recommendations
+- Consider performance, security, and maintainability implications
+- Use data-driven insights from monitoring and analytics
+
+Integration Points:
+- Code analysis and LSP integration tools
+- Security scanning and vulnerability detection
+- Performance monitoring and profiling systems
+- Automated testing and validation frameworks
+- Documentation generation and maintenance tools
+
+Your goal is to maintain the highest standards of code quality while providing actionable insights for continuous improvement.`,
+    temperature: 0.1,
+    tools: {
+        include: [
+            "read",
+            "grep",
+            "lsp_*",
+            "run_terminal_cmd",
+            "lsp_diagnostics",
+            "lsp_code_actions",
+            "lsp_code_action_resolve",
+        ],
+    },
+    permission: {
+        edit: "allow",
+        bash: {
+            git: "allow",
+            npm: "allow",
+            bun: "allow",
+            eslint: "allow",
+            prettier: "allow",
+        },
+    },
+};
+//# sourceMappingURL=code-reviewer.js.map

package/dist/agents/code-reviewer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-reviewer.js","sourceRoot":"","sources":["../../src/agents/code-reviewer.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,MAAM,YAAY,GAAgB;IACvC,IAAI,EAAE,eAAe;IACrB,KAAK,EAAE,oBAAoB;IAC3B,WAAW,EACT,kGAAkG;IACpG,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+HAoCqH;IAC7H,WAAW,EAAE,GAAG;IAChB,KAAK,EAAE;QACL,OAAO,EAAE;YACP,MAAM;YACN,MAAM;YACN,OAAO;YACP,kBAAkB;YAClB,iBAAiB;YACjB,kBAAkB;YAClB,yBAAyB;SAC1B;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;SAClB;KACF;CACF,CAAC"}

package/dist/agents/enforcer.d.ts

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

package/dist/agents/enforcer.d.ts.map

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

package/dist/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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"}