claude-flow-novice 2.15.4 → 2.15.6

package/claude-assets/skills/cfn-skill-propagation/tests/skill-propagator.test.ts

@@ -0,0 +1,209 @@
+/**
+ * Integration tests for Skill Propagator
+ */
+
+import { SkillPropagator } from '../src/skill-propagator';
+import { MockFileSystemAdapter } from '../src/file-system-adapter';
+import { MockDatabaseAdapter } from '../src/database-adapter';
+import { NoOpLogger } from '../src/logger';
+import type { SkillPropagationOptions } from '../src/types';
+
+describe('SkillPropagator', () => {
+  let propagator: SkillPropagator;
+  let fs: MockFileSystemAdapter;
+  let db: MockDatabaseAdapter;
+
+  beforeEach(() => {
+    fs = new MockFileSystemAdapter();
+    db = new MockDatabaseAdapter();
+    const logger = new NoOpLogger();
+    propagator = new SkillPropagator(fs, db, logger);
+  });
+
+  afterEach(() => {
+    fs.clear();
+    db.clear();
+  });
+
+  describe('propagate', () => {
+    it('should propagate skill update successfully', async () => {
+      // Setup mock data
+      const skillContent = `---
+name: test-skill
+version: 2.0.0
+description: Updated skill
+tags: [tag1, tag2]
+category: utilities
+owner: team
+approval_level: high
+---
+Skill content`;
+
+      fs.setFile('/path/to/skill-v2.0.0.md', skillContent);
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+      fs.setHash('/path/to/skill-v2.0.0.md', 'newhash123');
+
+      // Mock database responses
+      db.setTableData('skills', [{
+        id: 1,
+        name: 'test-skill',
+        version: '1.0.0',
+        content_hash: 'oldhash456',
+        content_path: '/path/to/skill-v1.0.0.md',
+        tags: '["old"]',
+        category: 'old-cat',
+        owner: 'old-owner',
+        approval_level: 'low',
+      }]);
+
+      const options: SkillPropagationOptions = {
+        skillName: 'test-skill',
+        newVersion: '2.0.0',
+        updatePath: '/path/to/skill-v2.0.0.md',
+        changeType: 'major',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await propagator.propagate(options);
+
+      expect(result.success).toBe(true);
+      expect(result.skillName).toBe('test-skill');
+      expect(result.newVersion).toBe('2.0.0');
+      expect(result.oldVersion).toBe('1.0.0');
+      expect(result.changeType).toBe('major');
+      expect(result.contentHash).toBe('newhash123');
+    });
+
+    it('should throw on validation failure', async () => {
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+
+      const options: SkillPropagationOptions = {
+        skillName: 'test-skill',
+        newVersion: '1.0', // Invalid version
+        updatePath: '/path/to/skill.md',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      await expect(propagator.propagate(options)).rejects.toThrow();
+    });
+
+    it('should throw on missing skill in database', async () => {
+      fs.setFile('/path/to/skill.md', 'content');
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+      db.setTableData('skills', []); // Empty database
+
+      const options: SkillPropagationOptions = {
+        skillName: 'missing-skill',
+        newVersion: '1.0.0',
+        updatePath: '/path/to/skill.md',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      await expect(propagator.propagate(options)).rejects.toThrow('Skill not found');
+    });
+
+    it('should throw on version increment mismatch', async () => {
+      const skillContent = `---
+name: test-skill
+version: 1.1.0
+description: Updated skill
+---
+Content`;
+
+      fs.setFile('/path/to/skill.md', skillContent);
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+      fs.setHash('/path/to/skill.md', 'newhash');
+
+      db.setTableData('skills', [{
+        id: 1,
+        name: 'test-skill',
+        version: '1.0.0',
+        content_hash: 'oldhash',
+        content_path: '/path/to/old.md',
+      }]);
+
+      const options: SkillPropagationOptions = {
+        skillName: 'test-skill',
+        newVersion: '1.1.0',
+        updatePath: '/path/to/skill.md',
+        changeType: 'patch', // Mismatch: actual is minor
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      await expect(propagator.propagate(options)).rejects.toThrow();
+    });
+
+    it('should throw on unchanged content hash', async () => {
+      const skillContent = `---
+name: test-skill
+version: 1.0.1
+description: Updated skill
+---
+Content`;
+
+      const hash = 'samehash123';
+
+      fs.setFile('/path/to/skill.md', skillContent);
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+      fs.setHash('/path/to/skill.md', hash);
+
+      db.setTableData('skills', [{
+        id: 1,
+        name: 'test-skill',
+        version: '1.0.0',
+        content_hash: hash, // Same hash
+        content_path: '/path/to/old.md',
+      }]);
+
+      const options: SkillPropagationOptions = {
+        skillName: 'test-skill',
+        newVersion: '1.0.1',
+        updatePath: '/path/to/skill.md',
+        changeType: 'patch',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      await expect(propagator.propagate(options)).rejects.toThrow('Content hash unchanged');
+    });
+
+    it('should support agent notifications', async () => {
+      const skillContent = `---
+name: test-skill
+version: 2.0.0
+description: Updated skill
+---
+Content`;
+
+      fs.setFile('/path/to/skill.md', skillContent);
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+      fs.setHash('/path/to/skill.md', 'newhash');
+
+      db.setTableData('skills', [{
+        id: 1,
+        name: 'test-skill',
+        version: '1.0.0',
+        content_hash: 'oldhash',
+        content_path: '/path/to/old.md',
+      }]);
+
+      db.setTableData('agent_skill_mappings', [
+        { skill_id: 1, agent_type: 'backend-developer' },
+        { skill_id: 1, agent_type: 'frontend-developer' },
+      ]);
+
+      const options: SkillPropagationOptions = {
+        skillName: 'test-skill',
+        newVersion: '2.0.0',
+        updatePath: '/path/to/skill.md',
+        changeType: 'major',
+        notifyAgents: true,
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await propagator.propagate(options);
+
+      expect(result.success).toBe(true);
+      expect(result.affectedAgents).toBeDefined();
+    });
+  });
+});

package/claude-assets/skills/cfn-skill-propagation/tests/skill-validator.test.ts

@@ -0,0 +1,203 @@
+/**
+ * Tests for Skill Validator
+ */
+
+import { SkillValidator } from '../src/skill-validator';
+import { MockFileSystemAdapter } from '../src/file-system-adapter';
+import { MockDatabaseAdapter } from '../src/database-adapter';
+
+describe('SkillValidator', () => {
+  let validator: SkillValidator;
+  let fs: MockFileSystemAdapter;
+  let db: MockDatabaseAdapter;
+
+  beforeEach(() => {
+    fs = new MockFileSystemAdapter();
+    db = new MockDatabaseAdapter();
+    validator = new SkillValidator(fs, db);
+  });
+
+  afterEach(() => {
+    fs.clear();
+    db.clear();
+  });
+
+  describe('validateParameters', () => {
+    it('should validate complete options', async () => {
+      fs.setFile('/path/to/skill.md', '---\nname: test\n---');
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+
+      const options = {
+        skillName: 'test-skill',
+        newVersion: '1.0.0',
+        updatePath: '/path/to/skill.md',
+        changeType: 'patch' as const,
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await validator.validateParameters(options);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should error on missing skillName', async () => {
+      const options = {
+        skillName: '',
+        newVersion: '1.0.0',
+        updatePath: '/path/to/skill.md',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await validator.validateParameters(options);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('skillName'))).toBe(true);
+    });
+
+    it('should error on missing newVersion', async () => {
+      const options = {
+        skillName: 'test-skill',
+        newVersion: '',
+        updatePath: '/path/to/skill.md',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await validator.validateParameters(options);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('newVersion'))).toBe(true);
+    });
+
+    it('should error on missing updatePath', async () => {
+      const options = {
+        skillName: 'test-skill',
+        newVersion: '1.0.0',
+        updatePath: '',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await validator.validateParameters(options);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('updatePath'))).toBe(true);
+    });
+
+    it('should error on invalid skill name', async () => {
+      fs.setFile('/path/to/skill.md', 'content');
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+
+      const options = {
+        skillName: 'skill@invalid!',
+        newVersion: '1.0.0',
+        updatePath: '/path/to/skill.md',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await validator.validateParameters(options);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('Invalid skill name'))).toBe(true);
+    });
+
+    it('should error on invalid version format', async () => {
+      fs.setFile('/path/to/skill.md', 'content');
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+
+      const options = {
+        skillName: 'test-skill',
+        newVersion: '1.0',
+        updatePath: '/path/to/skill.md',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await validator.validateParameters(options);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('Invalid version format'))).toBe(true);
+    });
+
+    it('should error on non-existent update file', async () => {
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+
+      const options = {
+        skillName: 'test-skill',
+        newVersion: '1.0.0',
+        updatePath: '/missing/file.md',
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await validator.validateParameters(options);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('Update file not found'))).toBe(true);
+    });
+
+    it('should error on invalid change type', async () => {
+      fs.setFile('/path/to/skill.md', 'content');
+      fs.setFile('./.claude/skills-database/skills.db', 'db');
+
+      const options = {
+        skillName: 'test-skill',
+        newVersion: '1.0.0',
+        updatePath: '/path/to/skill.md',
+        changeType: 'invalid' as any,
+        databasePath: './.claude/skills-database/skills.db',
+      };
+
+      const result = await validator.validateParameters(options);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('Invalid changeType'))).toBe(true);
+    });
+  });
+
+  describe('validateVersionIncrement', () => {
+    it('should validate patch increment', async () => {
+      const result = await validator.validateVersionIncrement('1.0.0', '1.0.1', 'patch');
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should validate minor increment', async () => {
+      const result = await validator.validateVersionIncrement('1.0.0', '1.1.0', 'minor');
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should validate major increment', async () => {
+      const result = await validator.validateVersionIncrement('1.0.0', '2.0.0', 'major');
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should error on same version', async () => {
+      const result = await validator.validateVersionIncrement('1.0.0', '1.0.0', 'patch');
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('Version unchanged'))).toBe(true);
+    });
+
+    it('should error on downgrade', async () => {
+      const result = await validator.validateVersionIncrement('2.0.0', '1.0.0', 'major');
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('downgrade'))).toBe(true);
+    });
+
+    it('should error on type mismatch', async () => {
+      const result = await validator.validateVersionIncrement('1.0.0', '1.1.0', 'patch');
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('mismatch'))).toBe(true);
+    });
+  });
+
+  describe('validateContentHashChanged', () => {
+    it('should accept different hashes', () => {
+      const result = validator.validateContentHashChanged(
+        'hash1',
+        'hash2'
+      );
+      expect(result.valid).toBe(true);
+    });
+
+    it('should error on same hash', () => {
+      const result = validator.validateContentHashChanged(
+        'samehash',
+        'samehash'
+      );
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('Content hash unchanged'))).toBe(true);
+    });
+  });
+});

package/claude-assets/skills/cfn-skill-propagation/tests/version-manager.test.ts

@@ -0,0 +1,115 @@
+/**
+ * Tests for Version Manager
+ */
+
+import { VersionManager } from '../src/version-manager';
+
+describe('VersionManager', () => {
+  describe('parseVersion', () => {
+    it('should parse valid semantic version', () => {
+      const result = VersionManager.parseVersion('1.2.3');
+      expect(result).toEqual({ major: 1, minor: 2, patch: 3 });
+    });
+
+    it('should parse zero versions', () => {
+      const result = VersionManager.parseVersion('0.0.0');
+      expect(result).toEqual({ major: 0, minor: 0, patch: 0 });
+    });
+
+    it('should throw on invalid format', () => {
+      expect(() => VersionManager.parseVersion('1.2')).toThrow();
+      expect(() => VersionManager.parseVersion('1.2.3.4')).toThrow();
+      expect(() => VersionManager.parseVersion('a.b.c')).toThrow();
+    });
+  });
+
+  describe('isValidVersion', () => {
+    it('should accept valid versions', () => {
+      expect(VersionManager.isValidVersion('1.0.0')).toBe(true);
+      expect(VersionManager.isValidVersion('0.0.1')).toBe(true);
+      expect(VersionManager.isValidVersion('10.20.30')).toBe(true);
+    });
+
+    it('should reject invalid versions', () => {
+      expect(VersionManager.isValidVersion('1.0')).toBe(false);
+      expect(VersionManager.isValidVersion('1.0.0.0')).toBe(false);
+      expect(VersionManager.isValidVersion('v1.0.0')).toBe(false);
+    });
+  });
+
+  describe('compareVersions', () => {
+    it('should detect major version increase', () => {
+      expect(VersionManager.compareVersions('1.0.0', '2.0.0')).toBe('major');
+    });
+
+    it('should detect minor version increase', () => {
+      expect(VersionManager.compareVersions('1.0.0', '1.1.0')).toBe('minor');
+    });
+
+    it('should detect patch version increase', () => {
+      expect(VersionManager.compareVersions('1.0.0', '1.0.1')).toBe('patch');
+    });
+
+    it('should detect same version', () => {
+      expect(VersionManager.compareVersions('1.0.0', '1.0.0')).toBe('same');
+    });
+
+    it('should detect downgrade', () => {
+      expect(VersionManager.compareVersions('2.0.0', '1.0.0')).toBe('downgrade');
+      expect(VersionManager.compareVersions('1.1.0', '1.0.0')).toBe('downgrade');
+      expect(VersionManager.compareVersions('1.0.1', '1.0.0')).toBe('downgrade');
+    });
+
+    it('should compare correctly with zero versions', () => {
+      expect(VersionManager.compareVersions('0.0.0', '0.0.1')).toBe('patch');
+      expect(VersionManager.compareVersions('0.0.1', '0.1.0')).toBe('minor');
+      expect(VersionManager.compareVersions('0.1.0', '1.0.0')).toBe('major');
+    });
+  });
+
+  describe('validateVersionIncrement', () => {
+    it('should validate patch version increment', () => {
+      const result = VersionManager.validateVersionIncrement('1.0.0', '1.0.1', 'patch');
+      expect(result.isValid).toBe(true);
+      expect(result.changeType).toBe('patch');
+    });
+
+    it('should validate minor version increment', () => {
+      const result = VersionManager.validateVersionIncrement('1.0.0', '1.1.0', 'minor');
+      expect(result.isValid).toBe(true);
+      expect(result.changeType).toBe('minor');
+    });
+
+    it('should validate major version increment', () => {
+      const result = VersionManager.validateVersionIncrement('1.0.0', '2.0.0', 'major');
+      expect(result.isValid).toBe(true);
+      expect(result.changeType).toBe('major');
+    });
+
+    it('should reject mismatched change types', () => {
+      const result = VersionManager.validateVersionIncrement('1.0.0', '1.1.0', 'patch');
+      expect(result.isValid).toBe(false);
+      expect(result.changeType).toBe('minor');
+    });
+
+    it('should reject same version', () => {
+      const result = VersionManager.validateVersionIncrement('1.0.0', '1.0.0', 'patch');
+      expect(result.isValid).toBe(false);
+      expect(result.changeType).toBe('same');
+    });
+
+    it('should reject downgrade', () => {
+      const result = VersionManager.validateVersionIncrement('1.0.0', '0.9.0', 'patch');
+      expect(result.isValid).toBe(false);
+      expect(result.changeType).toBe('downgrade');
+    });
+  });
+
+  describe('getChangeDescription', () => {
+    it('should return appropriate descriptions', () => {
+      expect(VersionManager.getChangeDescription('major')).toContain('Breaking');
+      expect(VersionManager.getChangeDescription('minor')).toContain('features');
+      expect(VersionManager.getChangeDescription('patch')).toContain('Bug fix');
+    });
+  });
+});

package/claude-assets/skills/cfn-skill-propagation/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "lib": ["ES2020"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node",
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "strictFunctionTypes": true,
+    "strictBindCallApply": true,
+    "strictPropertyInitialization": true,
+    "noImplicitThis": true,
+    "alwaysStrict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/claude-assets/skills/task-classifier/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: task-classifier
+description: Analyzes task descriptions and classifies them into categories for agent selection
+version: 1.0.0
+tags: [classification, agent-selection, automation]
+---
+
+# Task Classifier Skill
+
+Analyzes task descriptions using keyword matching to suggest appropriate agent specializations.
+
+## Usage
+
+```bash
+./.claude/skills/task-classifier/classify-task.sh "Task description"
+```
+
+## Classification Categories
+
+| Category | Keywords | Use Case |
+|----------|----------|----------|
+| **frontend** | ui, ux, react, component, css, styling, layout, responsive, interface | UI/UX development |
+| **backend** | api, endpoint, server, database, rest, graphql, service, authentication | Server-side development |
+| **devops** | docker, kubernetes, ci/cd, deployment, infrastructure, container, pipeline | Infrastructure work |
+| **testing** | test, qa, validation, coverage, integration, unit, e2e | Quality assurance |
+| **security** | security, auth, encryption, vulnerability, audit, penetration | Security work |
+| **data** | database, sql, migration, schema, data, model, entity | Data modeling |
+| **performance** | performance, optimization, speed, cache, memory, cpu | Performance tuning |
+| **general** | (default) | General development |
+
+## Output Format
+
+Comma-separated list of classifications:
+
+```bash
+$ classify-task.sh "Create a React dashboard with API integration"
+frontend,backend,testing
+```
+
+## Integration with Agent Selector
+
+This skill is typically used with `cfn-agent-selector` to determine which agents to spawn:
+
+```bash
+CLASSIFICATION=$(classify-task.sh "$TASK_DESCRIPTION")
+AGENTS=$(select-agents.sh --classification "$CLASSIFICATION" --mode standard)
+```
+
+## Examples
+
+```bash
+# Frontend task
+$ classify-task.sh "Build responsive navigation component"
+frontend
+
+# Full-stack task
+$ classify-task.sh "Create REST API with React admin panel"
+frontend,backend
+
+# DevOps task
+$ classify-task.sh "Setup CI/CD pipeline with Docker"
+devops
+
+# Security audit
+$ classify-task.sh "Perform security audit and fix vulnerabilities"
+security
+```
+
+## Implementation Details
+
+- Uses `grep -E` for case-insensitive pattern matching
+- Returns multiple classifications if multiple keywords match
+- Falls back to "general" if no specific keywords detected
+- Stateless execution (no persistent state)
+- Exit code 0 on success, 1 on error
+
+## Used By
+
+- `cfn-v3-coordinator` - For automatic agent selection
+- `cfn-agent-selector` - As input for agent mapping
+- CFN Loop orchestration - For task-specific agent spawning