claude-flow-novice 2.15.5 → 2.15.6

package/claude-assets/skills/cfn-skill-propagation/src/types.ts

@@ -0,0 +1,143 @@
+/**
+ * Type definitions for the Skill Propagation System
+ * Migrated from propagate-skill-update.sh
+ */
+
+export interface SkillMetadata {
+  name?: string;
+  version?: string;
+  description?: string;
+  tags?: string[];
+  category?: string;
+  owner?: string;
+  approval_level?: string;
+  [key: string]: unknown;
+}
+
+export interface SkillInfo {
+  id: number;
+  name: string;
+  version: string;
+  content_hash: string;
+  content_path: string;
+  tags?: string;
+  category?: string;
+  owner?: string;
+  approval_level?: string;
+  updated_at?: string;
+}
+
+export interface ValidationResult {
+  valid: boolean;
+  errors: string[];
+  warnings?: string[];
+}
+
+export interface VersionInfo {
+  major: number;
+  minor: number;
+  patch: number;
+}
+
+export type VersionChangeType = 'major' | 'minor' | 'patch' | 'same' | 'downgrade';
+
+export interface VersionComparisonResult {
+  changeType: VersionChangeType;
+  isValid: boolean;
+}
+
+export interface ContentHashResult {
+  hash: string;
+  hashChanged: boolean;
+}
+
+export interface PropagationResult {
+  success: boolean;
+  skillName: string;
+  newVersion: string;
+  oldVersion: string;
+  changeType: VersionChangeType;
+  contentHash: string;
+  metadata: {
+    tags?: string;
+    category?: string;
+    owner?: string;
+    approval_level?: string;
+  };
+  affectedAgents?: string[];
+  timestamp: string;
+}
+
+export interface ApprovalHistoryRecord {
+  skill_id: number;
+  version: string;
+  approval_level: string;
+  approver: string;
+  decision: string;
+  reasoning: string;
+  approval_criteria_check: string;
+  timestamp: string;
+}
+
+export interface SkillPropagationOptions {
+  skillName: string;
+  newVersion: string;
+  updatePath: string;
+  changeType?: 'patch' | 'minor' | 'major';
+  notifyAgents?: boolean;
+  databasePath?: string;
+  phase4PostgresHost?: string;
+  phase4PostgresDb?: string;
+  phase4PostgresUser?: string;
+  phase4PostgresPass?: string;
+  enableAgentNotifications?: boolean;
+  debug?: boolean;
+}
+
+export interface LoggerConfig {
+  debug?: boolean;
+  verbose?: boolean;
+}
+
+export interface FileSystemAdapter {
+  readFile(path: string): Promise<string>;
+  fileExists(path: string): Promise<boolean>;
+  isReadable(path: string): Promise<boolean>;
+  calculateHash(path: string): Promise<string>;
+}
+
+export interface DatabaseAdapter {
+  query(sql: string, params?: any[]): Promise<any>;
+  selectOne(sql: string, params?: any[]): Promise<any>;
+  selectAll(sql: string, params?: any[]): Promise<any[]>;
+  execute(sql: string, params?: any[]): Promise<void>;
+  getAffectedAgents(skillId: number): Promise<string[]>;
+  close(): Promise<void>;
+}
+
+export interface MetadataParser {
+  parse(content: string): SkillMetadata;
+  validate(metadata: SkillMetadata): ValidationResult;
+}
+
+export interface SkillValidator {
+  validateParameters(options: SkillPropagationOptions): Promise<ValidationResult>;
+  validateSkillExists(skillName: string): Promise<boolean>;
+  validateVersionIncrement(
+    currentVersion: string,
+    newVersion: string,
+    expectedChangeType: 'patch' | 'minor' | 'major'
+  ): Promise<ValidationResult>;
+}
+
+export interface SkillPropagator {
+  propagate(options: SkillPropagationOptions): Promise<PropagationResult>;
+}
+
+export interface Logger {
+  info(message: string): void;
+  success(message: string): void;
+  error(message: string): void;
+  warning(message: string): void;
+  debug(message: string): void;
+}

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

@@ -0,0 +1,118 @@
+/**
+ * Version management utilities for Skill Propagation
+ */
+
+import type { VersionInfo, VersionChangeType, VersionComparisonResult } from './types';
+
+export class VersionManager {
+  /**
+   * Parse a semantic version string into components
+   */
+  static parseVersion(version: string): VersionInfo {
+    const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+    if (!match || match.length !== 4) {
+      throw new Error(`Invalid version format: ${version}. Expected format: MAJOR.MINOR.PATCH`);
+    }
+
+    return {
+      major: parseInt(match[1]!, 10),
+      minor: parseInt(match[2]!, 10),
+      patch: parseInt(match[3]!, 10),
+    };
+  }
+
+  /**
+   * Validate version format
+   */
+  static isValidVersion(version: string): boolean {
+    return /^\d+\.\d+\.\d+$/.test(version);
+  }
+
+  /**
+   * Compare two versions and determine the change type
+   */
+  static compareVersions(currentVersion: string, newVersion: string): VersionChangeType {
+    const current = this.parseVersion(currentVersion);
+    const next = this.parseVersion(newVersion);
+
+    if (next.major > current.major) {
+      return 'major';
+    }
+    if (next.major < current.major) {
+      return 'downgrade';
+    }
+
+    if (next.minor > current.minor) {
+      return 'minor';
+    }
+    if (next.minor < current.minor) {
+      return 'downgrade';
+    }
+
+    if (next.patch > current.patch) {
+      return 'patch';
+    }
+    if (next.patch < current.patch) {
+      return 'downgrade';
+    }
+
+    return 'same';
+  }
+
+  /**
+   * Validate version increment matches expected change type
+   */
+  static validateVersionIncrement(
+    currentVersion: string,
+    newVersion: string,
+    expectedChangeType: 'patch' | 'minor' | 'major'
+  ): VersionComparisonResult {
+    const actualChangeType = this.compareVersions(currentVersion, newVersion);
+
+    const result: VersionComparisonResult = {
+      changeType: actualChangeType,
+      isValid: false,
+    };
+
+    switch (actualChangeType) {
+      case 'same':
+        return {
+          ...result,
+          isValid: false,
+        };
+
+      case 'downgrade':
+        return {
+          ...result,
+          isValid: false,
+        };
+
+      case 'major':
+      case 'minor':
+      case 'patch':
+        result.isValid = actualChangeType === expectedChangeType;
+        return result;
+
+      default:
+        return {
+          ...result,
+          isValid: false,
+        };
+    }
+  }
+
+  /**
+   * Get human-readable version change description
+   */
+  static getChangeDescription(changeType: VersionChangeType): string {
+    const descriptions: Record<VersionChangeType, string> = {
+      major: 'Breaking changes (incompatible API changes)',
+      minor: 'New features added (backward compatible)',
+      patch: 'Bug fix (no new features)',
+      same: 'Version unchanged',
+      downgrade: 'Version downgrade (not allowed)',
+    };
+
+    return descriptions[changeType];
+  }
+}

package/claude-assets/skills/cfn-skill-propagation/tests/file-system-adapter.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Tests for File System Adapter
+ */
+
+import { MockFileSystemAdapter } from '../src/file-system-adapter';
+
+describe('MockFileSystemAdapter', () => {
+  let adapter: MockFileSystemAdapter;
+
+  beforeEach(() => {
+    adapter = new MockFileSystemAdapter();
+  });
+
+  afterEach(() => {
+    adapter.clear();
+  });
+
+  describe('readFile', () => {
+    it('should read file content', async () => {
+      adapter.setFile('/path/to/file.md', 'content');
+      const content = await adapter.readFile('/path/to/file.md');
+      expect(content).toBe('content');
+    });
+
+    it('should throw on missing file', async () => {
+      await expect(adapter.readFile('/missing/file.md')).rejects.toThrow();
+    });
+  });
+
+  describe('fileExists', () => {
+    it('should return true for existing file', async () => {
+      adapter.setFile('/path/to/file.md', 'content');
+      const exists = await adapter.fileExists('/path/to/file.md');
+      expect(exists).toBe(true);
+    });
+
+    it('should return false for missing file', async () => {
+      const exists = await adapter.fileExists('/missing/file.md');
+      expect(exists).toBe(false);
+    });
+  });
+
+  describe('isReadable', () => {
+    it('should return true for readable file', async () => {
+      adapter.setFile('/path/to/file.md', 'content');
+      const readable = await adapter.isReadable('/path/to/file.md');
+      expect(readable).toBe(true);
+    });
+
+    it('should return false for unreadable file', async () => {
+      const readable = await adapter.isReadable('/missing/file.md');
+      expect(readable).toBe(false);
+    });
+  });
+
+  describe('calculateHash', () => {
+    it('should calculate hash for file content', async () => {
+      adapter.setFile('/path/to/file.md', 'test content');
+      const hash = await adapter.calculateHash('/path/to/file.md');
+      expect(typeof hash).toBe('string');
+      expect(hash.length).toBe(64); // SHA256 hex length
+    });
+
+    it('should return same hash for same content', async () => {
+      adapter.setFile('/path/file1.md', 'same content');
+      adapter.setFile('/path/file2.md', 'same content');
+      const hash1 = await adapter.calculateHash('/path/file1.md');
+      const hash2 = await adapter.calculateHash('/path/file2.md');
+      expect(hash1).toBe(hash2);
+    });
+
+    it('should return different hash for different content', async () => {
+      adapter.setFile('/path/file1.md', 'content 1');
+      adapter.setFile('/path/file2.md', 'content 2');
+      const hash1 = await adapter.calculateHash('/path/file1.md');
+      const hash2 = await adapter.calculateHash('/path/file2.md');
+      expect(hash1).not.toBe(hash2);
+    });
+
+    it('should use overridden hash if set', async () => {
+      adapter.setFile('/path/to/file.md', 'content');
+      adapter.setHash('/path/to/file.md', 'custom-hash-value');
+      const hash = await adapter.calculateHash('/path/to/file.md');
+      expect(hash).toBe('custom-hash-value');
+    });
+
+    it('should throw on missing file', async () => {
+      await expect(adapter.calculateHash('/missing/file.md')).rejects.toThrow();
+    });
+  });
+});

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

@@ -0,0 +1,176 @@
+/**
+ * Tests for Metadata Parser
+ */
+
+import { SkillMetadataParser } from '../src/metadata-parser';
+
+describe('SkillMetadataParser', () => {
+  let parser: SkillMetadataParser;
+
+  beforeEach(() => {
+    parser = new SkillMetadataParser();
+  });
+
+  describe('parse', () => {
+    it('should parse basic frontmatter', () => {
+      const content = `---
+name: test-skill
+version: 1.0.0
+description: A test skill
+---
+Content here`;
+
+      const metadata = parser.parse(content);
+      expect(metadata.name).toBe('test-skill');
+      expect(metadata.version).toBe('1.0.0');
+      expect(metadata.description).toBe('A test skill');
+    });
+
+    it('should parse array fields', () => {
+      const content = `---
+name: test-skill
+version: 1.0.0
+description: A test skill
+tags: [tag1, tag2, tag3]
+---
+Content`;
+
+      const metadata = parser.parse(content);
+      expect(Array.isArray(metadata.tags)).toBe(true);
+      expect(metadata.tags).toContain('tag1');
+      expect(metadata.tags).toContain('tag2');
+    });
+
+    it('should parse quoted strings', () => {
+      const content = `---
+name: "my-skill"
+version: "1.0.0"
+description: "A quoted skill"
+---
+Content`;
+
+      const metadata = parser.parse(content);
+      expect(metadata.name).toBe('my-skill');
+      expect(metadata.description).toBe('A quoted skill');
+    });
+
+    it('should throw on missing frontmatter', () => {
+      const content = 'Content without frontmatter';
+      expect(() => parser.parse(content)).toThrow();
+    });
+
+    it('should handle empty fields', () => {
+      const content = `---
+name: test-skill
+version: 1.0.0
+description:
+category:
+---
+Content`;
+
+      const metadata = parser.parse(content);
+      expect(metadata.name).toBe('test-skill');
+      expect(metadata.description).toBeNull();
+    });
+  });
+
+  describe('validate', () => {
+    it('should validate required fields', () => {
+      const metadata = {
+        name: 'test-skill',
+        version: '1.0.0',
+        description: 'Test',
+      };
+
+      const result = parser.validate(metadata);
+      expect(result.valid).toBe(true);
+      expect(result.errors).toHaveLength(0);
+    });
+
+    it('should error on missing name', () => {
+      const metadata = {
+        version: '1.0.0',
+        description: 'Test',
+      };
+
+      const result = parser.validate(metadata);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Missing required field: name');
+    });
+
+    it('should error on missing version', () => {
+      const metadata = {
+        name: 'test-skill',
+        description: 'Test',
+      };
+
+      const result = parser.validate(metadata);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Missing required field: version');
+    });
+
+    it('should error on missing description', () => {
+      const metadata = {
+        name: 'test-skill',
+        version: '1.0.0',
+      };
+
+      const result = parser.validate(metadata);
+      expect(result.valid).toBe(false);
+      expect(result.errors).toContain('Missing required field: description');
+    });
+
+    it('should error on invalid version format', () => {
+      const metadata = {
+        name: 'test-skill',
+        version: '1.0',
+        description: 'Test',
+      };
+
+      const result = parser.validate(metadata);
+      expect(result.valid).toBe(false);
+      expect(result.errors.some(e => e.includes('Invalid version format'))).toBe(true);
+    });
+  });
+
+  describe('extractField', () => {
+    it('should extract single field value', () => {
+      const content = `---
+name: test-skill
+version: 1.0.0
+---`;
+
+      const name = parser.extractField(content, 'name');
+      expect(name).toBe('test-skill');
+    });
+
+    it('should return null for missing field', () => {
+      const content = `---
+name: test-skill
+---`;
+
+      const version = parser.extractField(content, 'missing');
+      expect(version).toBeNull();
+    });
+  });
+
+  describe('extractArrayField', () => {
+    it('should extract array field', () => {
+      const content = `---
+tags: [tag1, tag2, tag3]
+---`;
+
+      const tags = parser.extractArrayField(content, 'tags');
+      expect(tags).toEqual(['tag1', 'tag2', 'tag3']);
+    });
+
+    it('should return empty array for missing field', () => {
+      const content = `---
+name: test-skill
+---`;
+
+      const tags = parser.extractArrayField(content, 'tags');
+      expect(tags).toEqual([]);
+    });
+  });
+});