npm - claude-flow-novice - Versions diffs - 2.18.6 → 2.18.8 - Mend

claude-flow-novice 2.18.6 → 2.18.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1000) hide show

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/validation/README.md DELETED Viewed

@@ -1,256 +0,0 @@
-# CFN Loop Validation Skill
-## Overview
-Advanced validation framework for iterative development workflows with dynamic consensus calculation, multi-mode validation, and adaptive quality assurance.
-## Status
-**OPERATIONAL** - Agent-accessible via CLI wrapper
-## Dependencies
-### Required
-- **Node.js** >= 18.0.0 (Runtime for consensus calculator)
-- **Bash** >= 4.0 (Shell wrapper scripts)
-- **jq** (JSON parsing and processing)
-- **SQLite3** (Evidence chain persistence)
-- **bc** (Basic calculator for threshold comparisons)
-### Optional (for enhanced features)
-- **Redis** (For distributed validation coordination)
-  - Package: `redis-server` and `redis-cli`
-  - Purpose: Publishing validation events to swarm
-## Installation
-### Install Required Dependencies
-```bash
-# Check Node.js version
-node --version  # Should be >= 18.0.0
-# Install jq (JSON processor)
-# Ubuntu/Debian
-sudo apt-get install jq bc sqlite3
-# macOS
-brew install jq bc sqlite3
-# Windows (WSL)
-sudo apt-get install jq bc sqlite3
-```
-### Install Optional Dependencies
-```bash
-# Install Redis for distributed coordination
-# Ubuntu/Debian
-sudo apt-get install redis-server redis-tools
-# macOS
-brew install redis
-# Start Redis
-redis-server &
-```
-### Verify Installation
-```bash
-# Check Node.js
-node --version  # Should be >= 18.0.0
-# Check jq
-jq --version  # Should show version info
-# Check bc
-bc --version  # Should show version info
-# Check SQLite
-sqlite3 --version  # Should show version info
-# Check Redis (optional)
-redis-cli ping  # Should return "PONG"
-# Test CFN validation CLI
-./.claude/skills/cfn-loop-validation/validate-iteration.sh --help
-```
-## Quick Start
-### Validate Loop 3 Confidence Gate
-```bash
-# MVP mode (low threshold, fast iteration)
-./.claude/skills/cfn-loop-validation/validate-iteration.sh \
-  --mode mvp \
-  --iteration 1 \
-  --confidence 0.75 \
-  --task-id feature-auth
-# Standard mode (balanced quality)
-./.claude/skills/cfn-loop-validation/validate-iteration.sh \
-  --mode standard \
-  --iteration 2 \
-  --confidence 0.85 \
-  --task-id feature-auth
-# Enterprise mode (high quality, strict validation)
-./.claude/skills/cfn-loop-validation/validate-iteration.sh \
-  --mode enterprise \
-  --iteration 1 \
-  --confidence 0.92 \
-  --task-id compliance-system
-```
-### Validate Loop 2 Consensus
-```bash
-# Validate consensus from validator swarm
-./.claude/skills/cfn-loop-validation/validate-iteration.sh \
-  --mode standard \
-  --iteration 2 \
-  --confidence 0.85 \
-  --consensus 0.92 \
-  --task-id feature-auth \
-  --json
-```
-### JSON Output for Agent Parsing
-```bash
-# Get JSON output for programmatic use
-RESULT=$(./.claude/skills/cfn-loop-validation/validate-iteration.sh \
-  --mode standard \
-  --iteration 1 \
-  --confidence 0.85 \
-  --json)
-# Parse result
-echo "$RESULT" | jq -r '.passed'  # true/false
-echo "$RESULT" | jq -r '.status'  # PASS/FAIL/MAX_ITERATIONS_EXCEEDED
-```
-## Validation Modes
-| Mode | Gate Threshold | Consensus | Max Iterations | Validators |
-|------|----------------|-----------|----------------|------------|
-| **MVP** | ≥0.70 | ≥0.85 | 5 | 2 |
-| **Standard** | ≥0.80 | ≥0.90 | 10 | 4 |
-| **Enterprise** | ≥0.90 | ≥0.95 | 15 | 5-8 |
-### Mode Selection Guide
-**MVP Mode:**
-- Proof of concepts
-- Rapid prototyping
-- Learning and experimentation
-**Standard Mode:**
-- Production applications
-- Team collaboration
-- Quality-focused development
-**Enterprise Mode:**
-- Financial systems
-- Healthcare applications
-- Compliance-critical systems
-## Exit Codes
-| Code | Status | Meaning | Action |
-|------|--------|---------|--------|
-| 0 | PASS | Validation passed | Continue workflow |
-| 1 | FAIL | Score below threshold | Inject feedback, retry |
-| 2 | MAX_ITERATIONS_EXCEEDED | Too many attempts | Escalate to human |
-| 3 | Invalid arguments | Bad CLI input | Fix arguments |
-| 4 | Configuration error | Config file issue | Check config.json |
-## Common Issues
-### Issue: "jq: command not found"
-**Solution:** Install jq
-```bash
-# Ubuntu/Debian
-sudo apt-get install jq
-# macOS
-brew install jq
-```
-### Issue: "bc: command not found"
-**Solution:** Install bc (basic calculator)
-```bash
-# Ubuntu/Debian
-sudo apt-get install bc
-# macOS
-brew install bc
-```
-### Issue: "Config file not found"
-**Solution:** Verify config.json exists
-```bash
-ls -la ./.claude/skills/cfn-loop-validation/config.json
-```
-### Issue: "Permission denied"
-**Solution:** Make script executable
-```bash
-chmod +x ./.claude/skills/cfn-loop-validation/validate-iteration.sh
-```
-### Issue: SQLite database errors
-**Solution:** Ensure SQLite3 is installed and database directory exists
-```bash
-# Install SQLite3
-sudo apt-get install sqlite3  # Ubuntu/Debian
-brew install sqlite3          # macOS
-# Create database directory
-mkdir -p ./.claude/skills/cfn-loop-validation/
-# Verify database can be accessed
-sqlite3 ./.claude/skills/cfn-loop-validation/evidence-chain.db "SELECT 1;"
-```
-## Evidence Chain Persistence
-Validation results are automatically stored in SQLite for audit trails:
-```bash
-# Query validation history
-sqlite3 ./.claude/skills/cfn-loop-validation/evidence-chain.db \
-  "SELECT task_id, iteration, confidence, status, timestamp
-   FROM validation_evidence
-   WHERE task_id = 'feature-auth'
-   ORDER BY timestamp DESC;"
-```
-## Documentation
-See `SKILL.md` for comprehensive documentation including:
-- Validation workflow patterns
-- Integration with coordinator agents
-- Evidence chain schema
-- Redis integration for async validation
-- Performance targets and telemetry
-## Performance Targets
-- Average execution time: <500ms
-- Memory footprint: <50MB
-- Consensus accuracy: >90%
-- SQLite write latency: <20ms
-## Related Skills
-- **Agent Spawning** - `.claude/skills/agent-spawning/SKILL.md`
-- **Redis Coordination** - `.claude/skills/redis-coordination/SKILL.md`
-- **Hook Pipeline** - `.claude/skills/hook-pipeline/SKILL.md`
----
-**Version:** 2.0.0
-**Last Updated:** 2025-10-18
-**Maintainer:** Claude Flow Novice Team

package/claude-assets/skills/cfn-loop-orchestration-v2/lib/validation/README_TYPESCRIPT.md DELETED Viewed

@@ -1,454 +0,0 @@
-# CFN Loop Validation - TypeScript Module
-Complete TypeScript validation framework for CFN Loop critical path with comprehensive type safety, vapor detection, and production-ready implementation.
-**Status:** Production Ready | **Coverage:** 90%+ | **Version:** 1.0.0
-## Quick Start
-### Installation
-```bash
-cd .claude/skills/cfn-loop-validation
-npm install
-npm run build
-npm test -- --coverage
-```
-### Basic Usage
-```typescript
-import { CFNValidator } from './src/validator';
-const validator = new CFNValidator({
-  mode: 'standard',
-  taskId: 'my-task'
-});
-// Check deliverables exist
-const deliverables = await validator.validateDeliverables([
-  'src/auth.ts',
-  'dist/auth.js'
-]);
-if (!deliverables.allExist) {
-  console.log('Missing:', deliverables.missingFiles);
-}
-// Detect vapor (claims without deliverables)
-const vapor = await validator.detectConsensusOnVapor(
-  agentOutput,
-  expectedFiles
-);
-if (vapor.detected) {
-  console.log('VAPOR DETECTED:', vapor.missingDeliverables);
-}
-```
-## Core Features
-### 1. Deliverable Validation
-Verify that expected output files exist and are accessible.
-```bash
-./validate-deliverables.sh --paths "file1.js,file2.js" --json
-```
-### 2. Gate Validation
-Check if test pass rate meets mode-specific thresholds.
-```bash
-./validate-gate.sh --pass-rate 0.96 --mode standard --json
-```
-### 3. Vapor Detection
-Detect when agents claim completion but deliverables don't exist.
-```bash
-./detect-vapor.sh \
-  --output "Task completed" \
-  --deliverables "src/auth.ts,tests/auth.test.ts" \
-  --json
-```
-### 4. Success Criteria Validation
-Verify custom success conditions (file exists, tests pass, etc.).
-```typescript
-const criteria: SuccessCriteria[] = [
-  {
-    type: 'file_exists',
-    paths: ['src/index.ts'],
-    description: 'Main file exists'
-  }
-];
-const result = await validator.checkSuccessCriteria(criteria);
-```
-### 5. Consensus Validation
-Check if validator consensus scores meet threshold.
-```typescript
-const scores = [0.97, 0.98, 0.96];
-const consensus = await validator.validateConsensus(scores, 'standard');
-```
-## Mode Thresholds
-| Mode | Gate | Consensus | Use Case |
-|------|------|-----------|----------|
-| MVP | 70% | 80% | Prototyping |
-| Standard | 95% | 90% | Production |
-| Enterprise | 98% | 95% | Critical systems |
-## Vapor Detection
-**Most Important:** Prevents agents claiming completion without deliverables.
-### What is Vapor?
-When an agent claims "Task completed successfully" but the expected files don't exist.
-### Detection Algorithm
-```
-1. Check if output claims completion
-   → Recognizes: "complete", "done", "finished", "success", etc.
-2. Validate deliverables exist
-   → File system check for all expected paths
-3. Calculate confidence
-   → Missing ratio (1 of 3 = 33% confidence)
-4. Result
-   → Detected = claims AND missing
-```
-### Example
-```typescript
-// Agent output
-const output = 'Task completed. Created auth.ts and tests.test.ts';
-// Expected files
-const expected = ['src/auth.ts', 'tests/auth.test.ts'];
-// Detect
-const vapor = await validator.detectConsensusOnVapor(output, expected);
-if (vapor.detected) {
-  console.log('VAPOR DETECTED!');
-  console.log('Claims:', output.substring(0, 50));
-  console.log('Missing:', vapor.missingDeliverables);
-  console.log('Confidence:', (vapor.confidence * 100).toFixed(0) + '%');
-}
-```
-## Architecture
-```
-src/
-├── types.ts              # Type definitions and guards
-├── validator.ts          # Main CFNValidator class
-└── cli/
-    ├── validate-deliverables.ts   # CLI for deliverables
-    ├── validate-gate.ts            # CLI for gate check
-    └── detect-vapor.ts             # CLI for vapor detection
-```
-### Type Safety
-- 100% strict TypeScript (no `any` types)
-- Discriminated unions for error handling
-- Custom error types (ValidationError, ConsensusOnVaporError)
-- Complete type coverage
-### Testing
-```bash
-npm test                    # Run all tests
-npm test -- --coverage      # With coverage report
-npm test -- --watch         # Watch mode
-```
-**Coverage:** 90%+ lines, statements, functions, 85%+ branches
-## API Reference
-### CFNValidator
-```typescript
-class CFNValidator {
-  constructor(config: ValidationConfig)
-  // Deliverables
-  validateDeliverables(paths: string[]): Promise<DeliverableValidationResult>
-  // Success Criteria
-  checkSuccessCriteria(criteria: SuccessCriteria[]): Promise<SuccessCriteriaValidationResult>
-  // Gate
-  validateGatePass(passRate: number, mode?: ExecutionMode): Promise<GateValidationResult>
-  // Consensus
-  validateConsensus(scores: number[], mode?: ExecutionMode): Promise<ConsensusValidationResult>
-  // Vapor (Most Important)
-  detectConsensusOnVapor(agentOutput: string, expectedDeliverables: string[]): Promise<VaporDetectionResult>
-  // Comprehensive
-  performValidation(options: ValidationOptions): Promise<ValidationResult>
-}
-```
-## CLI Usage
-### Validate Deliverables
-```bash
-# Check files exist
-./validate-deliverables.sh --paths "file1.js,file2.js"
-# Load from file
-./validate-deliverables.sh --file-list deliverables.txt
-# JSON output
-./validate-deliverables.sh --paths "file1.js,file2.js" --json
-# Exit codes:
-# 0 = all files exist
-# 1 = some missing
-```
-### Validate Gate
-```bash
-# Check pass rate (standard mode = 0.95 threshold)
-./validate-gate.sh --pass-rate 0.96 --mode standard
-# Custom threshold
-./validate-gate.sh --pass-rate 0.96 --threshold 0.90
-# JSON output
-./validate-gate.sh --pass-rate 0.96 --mode enterprise --json
-# Exit codes:
-# 0 = gate passed
-# 1 = gate failed
-```
-### Detect Vapor
-```bash
-# Detect claims without deliverables
-./detect-vapor.sh \
-  --output "Task completed" \
-  --deliverables "file1.js,file2.js"
-# Load output from file
-./detect-vapor.sh \
-  --output-file agent_output.log \
-  --deliverables "file1.js,file2.js"
-# JSON output
-./detect-vapor.sh \
-  --output "Completed" \
-  --deliverables "file1.js,file2.js" \
-  --json
-# Exit codes:
-# 0 = no vapor
-# 1 = vapor detected
-```
-## Integration Examples
-### Loop 3 Agent Completion
-```typescript
-const validator = new CFNValidator({
-  mode: 'standard',
-  taskId,
-  agentId: process.env.AGENT_ID
-});
-const result = await validator.performValidation({
-  deliverables: expectedFiles,
-  passRate: calculatePassRate(tests),
-  agentOutput: executionLog,
-  successCriteria: successCriteria
-});
-if (!result.passed) {
-  if (result.vapor?.detected) {
-    // Provide feedback on missing files
-    feedback.missingDeliverables = result.vapor.missingDeliverables;
-  }
-  reportConfidence(0.50, 'ITERATE');
-} else {
-  reportConfidence(0.95, 'PROCEED');
-}
-```
-### Orchestrator Vapor Check
-```bash
-VAPOR=$(./.claude/skills/cfn-loop-validation/detect-vapor.sh \
-  --output "$LOOP3_OUTPUT" \
-  --deliverables "$(echo ${FILES[@]} | tr ' ' ',')" \
-  --json)
-if [ "$(echo "$VAPOR" | jq '.detected')" = "true" ]; then
-  echo "Vapor detected, requesting iteration:"
-  echo "$VAPOR" | jq '.missingDeliverables[]'
-  redis-cli lpush "swarm:${TASK_ID}:proceed" "false"
-fi
-```
-## Error Handling
-```typescript
-import { ValidationError, ConsensusOnVaporError } from './src/types';
-try {
-  const result = await validator.performValidation({...});
-  if (!result.passed) {
-    for (const error of result.errors) {
-      if (error instanceof ConsensusOnVaporError) {
-        console.error('Vapor detected:', error.details?.missingDeliverables);
-      } else if (error instanceof ValidationError) {
-        console.error(`${error.code}: ${error.message}`);
-      }
-    }
-  }
-} catch (error) {
-  console.error('Unexpected error:', error);
-}
-```
-## Performance
-| Operation | Time | Note |
-|-----------|------|------|
-| Validate 10 files | ~10ms | Filesystem I/O |
-| Check 5 criteria | ~100ms | Command execution |
-| Gate check | <1ms | Math only |
-| Consensus check | <1ms | Math only |
-| Vapor detection | ~10ms | File I/O + string matching |
-| Full validation | ~200ms | Combined |
-## File Structure
-```
-.claude/skills/cfn-loop-validation/
-├── src/
-│   ├── types.ts                    # Type definitions
-│   ├── validator.ts                # Core validator
-│   └── cli/
-│       ├── validate-deliverables.ts
-│       ├── validate-gate.ts
-│       └── detect-vapor.ts
-├── tests/
-│   └── validator.test.ts           # 35+ test cases
-├── dist/                           # Compiled JavaScript
-├── package.json
-├── tsconfig.json
-├── validate-*.sh                   # Bash wrappers
-├── SKILL_TYPESCRIPT.md             # Complete documentation
-├── IMPLEMENTATION_SUMMARY.md       # Implementation details
-└── README_TYPESCRIPT.md            # This file
-```
-## Building
-```bash
-# Build TypeScript
-npm run build
-# Type check only
-npm run type-check
-# Clean and rebuild
-npm run clean && npm run build
-# Watch mode (rebuild on changes)
-npm run build:watch
-```
-## Testing
-```bash
-# Run all tests
-npm test
-# Run with coverage
-npm test -- --coverage
-# Watch mode
-npm test -- --watch
-# Specific test
-npm test -- --testNamePattern="vapor"
-# Verbose output
-npm test -- --verbose
-```
-## Documentation
-- **Complete API:** `SKILL_TYPESCRIPT.md` (2,000+ lines)
-- **Implementation Details:** `IMPLEMENTATION_SUMMARY.md`
-- **Code Comments:** All functions documented with JSDoc
-## Dependencies
-**Runtime:** None (pure Node.js)
-**Development:**
-- TypeScript 5.0+
-- Jest 29.5+
-- ESLint 8+
-- Prettier 3+
-## Troubleshooting
-### Build Issues
-```bash
-npm run clean && npm install && npm run build
-npm run type-check  # Check for TS errors
-```
-### Test Failures
-```bash
-npm test -- --verbose --testNamePattern="failing-test"
-```
-### CLI Issues
-```bash
-node dist/cli/validate-deliverables.js --help
-```
-## Related Documentation
-- CFN Loop Orchestration: `.claude/skills/cfn-loop-orchestration/SKILL.md`
-- Gate Checker: `src/gate-checker/gate-checker.ts`
-- Orchestrator Integration: `.claude/skills/cfn-loop-orchestration/orchestrate.sh`
-## Support
-For issues or questions:
-1. Check `SKILL_TYPESCRIPT.md` for complete documentation
-2. Review test cases in `tests/validator.test.ts`
-3. Check error messages and codes in `src/types.ts`
-## License
-MIT
----
-**Ready for production deployment with 90%+ test coverage and comprehensive vapor detection.**