claude-flow-novice 2.15.4 → 2.15.6

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

@@ -0,0 +1,52 @@
+{
+  "name": "@cfn/skill-propagation",
+  "version": "1.0.0",
+  "description": "TypeScript implementation of skill propagation system for CFN Loop",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "propagate-skill-update": "dist/cli.js"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.json",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src tests --ext .ts",
+    "lint:fix": "eslint src tests --ext .ts --fix",
+    "clean": "rm -rf dist coverage",
+    "prepublishOnly": "npm run build && npm test"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@types/jest": "^29.5.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.50.0",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.1",
+    "typescript": "^5.3.2"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "cfn",
+    "skill",
+    "propagation",
+    "workflow",
+    "codification",
+    "typescript"
+  ],
+  "author": "CFN Team",
+  "license": "MIT"
+}

package/claude-assets/skills/cfn-skill-propagation/propagate-skill-update.sh

@@ -0,0 +1,32 @@
+#!/usr/bin/env bash
+#
+# propagate-skill-update.sh - Bash wrapper for TypeScript Skill Propagation System
+#
+# This script provides backward compatibility with the original bash implementation
+# while delegating to the TypeScript implementation for core functionality.
+#
+# Usage:
+#   propagate-skill-update.sh SKILL_NAME NEW_VERSION UPDATE_PATH [CHANGE_TYPE] [NOTIFY_AGENTS]
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(cd "$SCRIPT_DIR/../../.." && pwd)"
+
+# Export environment variables for TypeScript CLI
+export CFN_SKILLS_DB_PATH="${CFN_SKILLS_DB_PATH:-./.claude/skills-database/skills.db}"
+export PHASE4_POSTGRES_HOST="${PHASE4_POSTGRES_HOST:-}"
+export PHASE4_POSTGRES_DB="${PHASE4_POSTGRES_DB:-workflow_codification}"
+export PHASE4_POSTGRES_USER="${PHASE4_POSTGRES_USER:-}"
+export PHASE4_POSTGRES_PASS="${PHASE4_POSTGRES_PASS:-}"
+export ENABLE_AGENT_NOTIFICATIONS="${ENABLE_AGENT_NOTIFICATIONS:-false}"
+export DEBUG="${DEBUG:-0}"
+
+# Check if TypeScript is compiled
+if [[ ! -f "$SCRIPT_DIR/dist/cli.js" ]]; then
+    echo "[ERROR] TypeScript build not found. Run 'npm run build' in $SCRIPT_DIR" >&2
+    exit 1
+fi
+
+# Run TypeScript implementation
+node "$SCRIPT_DIR/dist/cli.js" "$@"

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

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ * CLI entry point for Skill Propagation System
+ * Provides command-line interface for propagating skill updates
+ */
+
+import { NodeFileSystemAdapter } from './file-system-adapter';
+import { SQLiteDatabaseAdapter } from './database-adapter';
+import { ConsoleLogger } from './logger';
+import { SkillPropagator } from './skill-propagator';
+import type { SkillPropagationOptions } from './types';
+
+const logger = new ConsoleLogger({ debug: process.env['DEBUG'] === '1' });
+
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Parse command-line arguments
+  const skillName = args[0];
+  const newVersion = args[1];
+  const updatePath = args[2];
+  const changeType = (args[3] || 'patch') as 'patch' | 'minor' | 'major';
+  const notifyAgents = args[4] === 'true' ? true : false;
+
+  // Validate minimum arguments
+  if (!skillName || !newVersion || !updatePath) {
+    logger.error('Missing required arguments');
+    logger.error('Usage: propagate-skill-update SKILL_NAME NEW_VERSION UPDATE_PATH [CHANGE_TYPE] [NOTIFY_AGENTS]');
+    process.exit(1);
+  }
+
+  try {
+    // Create adapters
+    const fs = new NodeFileSystemAdapter();
+    const databasePath = process.env['CFN_SKILLS_DB_PATH'] || './.claude/skills-database/skills.db';
+    const db = new SQLiteDatabaseAdapter(databasePath);
+
+    // Create propagator
+    const propagator = new SkillPropagator(fs, db, logger);
+
+    // Prepare options
+    const options: SkillPropagationOptions = {
+      skillName,
+      newVersion,
+      updatePath,
+      changeType,
+      notifyAgents,
+      databasePath,
+      phase4PostgresHost: process.env['PHASE4_POSTGRES_HOST'],
+      phase4PostgresDb: process.env['PHASE4_POSTGRES_DB'] || 'workflow_codification',
+      phase4PostgresUser: process.env['PHASE4_POSTGRES_USER'],
+      phase4PostgresPass: process.env['PHASE4_POSTGRES_PASS'],
+      enableAgentNotifications: process.env['ENABLE_AGENT_NOTIFICATIONS'] === 'true',
+      debug: process.env['DEBUG'] === '1',
+    };
+
+    // Execute propagation
+    await propagator.propagate(options);
+
+    logger.success(`Propagation completed successfully`);
+    process.exit(0);
+  } catch (error) {
+    logger.error(`Propagation failed: ${(error as Error).message}`);
+    if (process.env['DEBUG'] === '1') {
+      console.error(error);
+    }
+    process.exit(1);
+  }
+}
+
+main().catch((error) => {
+  logger.error(`Fatal error: ${error.message}`);
+  process.exit(1);
+});

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

@@ -0,0 +1,239 @@
+/**
+ * Database Adapter for SQLite operations
+ * Supports parameterized queries to prevent SQL injection
+ */
+
+import { spawn } from 'child_process';
+import type { DatabaseAdapter } from './types';
+
+export class SQLiteDatabaseAdapter implements DatabaseAdapter {
+  private databasePath: string;
+
+  constructor(databasePath: string) {
+    this.databasePath = databasePath;
+  }
+
+  /**
+   * Execute raw SQL query and return results
+   */
+  async query(sql: string, params?: any[]): Promise<any> {
+    const results = await this.selectAll(sql, params);
+    return results.length > 0 ? results[0] : null;
+  }
+
+  /**
+   * Select single row
+   */
+  async selectOne(sql: string, params?: any[]): Promise<any> {
+    const results = await this.selectAll(sql, params);
+    return results.length > 0 ? results[0] : null;
+  }
+
+  /**
+   * Select all rows
+   */
+  async selectAll(sql: string, params?: any[]): Promise<any[]> {
+    const output = await this.executeSqlite3(sql, params);
+    if (!output.trim()) {
+      return [];
+    }
+
+    // Parse pipe-delimited output
+    const lines = output.trim().split('\n');
+    return lines.map(line => this.parsePipeDelimitedRow(line));
+  }
+
+  /**
+   * Execute SQL statement (INSERT, UPDATE, DELETE)
+   */
+  async execute(sql: string, params?: any[]): Promise<void> {
+    await this.executeSqlite3(sql, params);
+  }
+
+  /**
+   * Get affected agents using a skill
+   */
+  async getAffectedAgents(skillId: number): Promise<string[]> {
+    const results = await this.selectAll(
+      'SELECT DISTINCT agent_type FROM agent_skill_mappings WHERE skill_id = ?1',
+      [skillId]
+    );
+
+    return results.map(row => row.agent_type).filter(Boolean);
+  }
+
+  /**
+   * Close database connection (no-op for SQLite)
+   */
+  async close(): Promise<void> {
+    // SQLite doesn't require explicit connection closing
+  }
+
+  /**
+   * Execute sqlite3 command with parameter binding
+   */
+  private async executeSqlite3(sql: string, params?: any[]): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const sqlite3Args = [
+        '-header',
+        '-separator',
+        '|',
+        this.databasePath,
+      ];
+
+      const sqlWithParams = this.bindParameters(sql, params);
+
+      const process = spawn('sqlite3', sqlite3Args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      process.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      process.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      process.on('close', (code) => {
+        if (code === 0) {
+          resolve(stdout);
+        } else {
+          reject(new Error(`SQLite error: ${stderr || 'unknown error'}`));
+        }
+      });
+
+      process.stdin?.write(sqlWithParams);
+      process.stdin?.end();
+    });
+  }
+
+  /**
+   * Bind parameters to SQL query
+   * Simple implementation - in production would use proper binding
+   */
+  private bindParameters(sql: string, params?: any[]): string {
+    if (!params || params.length === 0) {
+      return sql;
+    }
+
+    let result = sql;
+    params.forEach((param, index) => {
+      const placeholder = `?${index + 1}`;
+      const value = this.escapeValue(param);
+      result = result.replace(placeholder, value);
+    });
+
+    return result;
+  }
+
+  /**
+   * Escape value for SQL safety
+   */
+  private escapeValue(value: any): string {
+    if (value === null || value === undefined) {
+      return 'NULL';
+    }
+
+    if (typeof value === 'number') {
+      return value.toString();
+    }
+
+    if (typeof value === 'boolean') {
+      return value ? '1' : '0';
+    }
+
+    if (typeof value === 'string') {
+      // Escape single quotes by doubling them
+      return `'${value.replace(/'/g, "''")}'`;
+    }
+
+    throw new Error(`Unsupported parameter type: ${typeof value}`);
+  }
+
+  /**
+   * Parse pipe-delimited row into object
+   */
+  private parsePipeDelimitedRow(line: string): Record<string, any> {
+    // For simplicity, return as array of values
+    // In production, would need column names from query
+    const values = line.split('|');
+    return {
+      value: values.length === 1 ? values[0] : values,
+    };
+  }
+}
+
+/**
+ * Mock database adapter for testing
+ */
+export class MockDatabaseAdapter implements DatabaseAdapter {
+  private data: Map<string, any[]> = new Map();
+
+  setTableData(table: string, rows: any[]): void {
+    this.data.set(table, rows);
+  }
+
+  async query(sql: string, params?: any[]): Promise<any> {
+    const results = await this.selectAll(sql, params);
+    return results.length > 0 ? results[0] : null;
+  }
+
+  async selectOne(sql: string, params?: any[]): Promise<any> {
+    const results = await this.selectAll(sql, params);
+    return results.length > 0 ? results[0] : null;
+  }
+
+  async selectAll(sql: string, params?: any[]): Promise<any[]> {
+    // Mock implementation - parse SQL to determine which table to query
+    if (sql.includes('FROM skills')) {
+      const skills = this.data.get('skills') || [];
+
+      // Handle WHERE name = ?1
+      if (params && params.length > 0 && sql.includes('WHERE name =')) {
+        return skills.filter(s => s.name === params[0]);
+      }
+
+      // Handle COUNT(*)
+      if (sql.includes('COUNT(*)')) {
+        return [{ count: skills.length, value: skills.length }];
+      }
+
+      return skills;
+    }
+
+    // Default: return empty array or result table
+    return this.data.get('result') || [];
+  }
+
+  async execute(sql: string, params?: any[]): Promise<void> {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    void sql;
+    void params;
+    // Mock implementation
+  }
+
+  async getAffectedAgents(skillId: number): Promise<string[]> {
+    const mappings = this.data.get('agent_skill_mappings') || [];
+    const agents = new Set<string>();
+
+    for (const mapping of mappings) {
+      if (mapping.skill_id === skillId) {
+        agents.add(mapping.agent_type);
+      }
+    }
+
+    return Array.from(agents);
+  }
+
+  async close(): Promise<void> {
+    this.data.clear();
+  }
+
+  clear(): void {
+    this.data.clear();
+  }
+}

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

@@ -0,0 +1,113 @@
+/**
+ * File System Adapter for skill propagation operations
+ */
+
+import { promises as fs } from 'fs';
+import { createHash } from 'crypto';
+import { resolve } from 'path';
+import type { FileSystemAdapter } from './types';
+
+export class NodeFileSystemAdapter implements FileSystemAdapter {
+  /**
+   * Read file content
+   */
+  async readFile(path: string): Promise<string> {
+    try {
+      return await fs.readFile(path, 'utf-8');
+    } catch (error) {
+      throw new Error(`Failed to read file: ${path}. ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Check if file exists
+   */
+  async fileExists(path: string): Promise<boolean> {
+    try {
+      await fs.access(path);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check if file is readable
+   */
+  async isReadable(path: string): Promise<boolean> {
+    try {
+      await fs.access(path, fs.constants.R_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Calculate SHA256 hash of file content
+   */
+  async calculateHash(path: string): Promise<string> {
+    try {
+      const content = await this.readFile(path);
+      return createHash('sha256').update(content).digest('hex');
+    } catch (error) {
+      throw new Error(`Failed to calculate hash for file: ${path}. ${(error as Error).message}`);
+    }
+  }
+
+  /**
+   * Validate file path is within project root (prevent path traversal)
+   */
+  static validatePath(filePath: string, projectRoot: string): boolean {
+    const resolvedPath = resolve(filePath);
+    const resolvedRoot = resolve(projectRoot);
+
+    return resolvedPath.startsWith(resolvedRoot);
+  }
+}
+
+/**
+ * Mock file system adapter for testing
+ */
+export class MockFileSystemAdapter implements FileSystemAdapter {
+  private files: Map<string, string> = new Map();
+  private hashOverrides: Map<string, string> = new Map();
+
+  setFile(path: string, content: string): void {
+    this.files.set(path, content);
+  }
+
+  setHash(path: string, hash: string): void {
+    this.hashOverrides.set(path, hash);
+  }
+
+  async readFile(path: string): Promise<string> {
+    const content = this.files.get(path);
+    if (!content) {
+      throw new Error(`File not found: ${path}`);
+    }
+    return content;
+  }
+
+  async fileExists(path: string): Promise<boolean> {
+    return this.files.has(path);
+  }
+
+  async isReadable(path: string): Promise<boolean> {
+    return this.files.has(path);
+  }
+
+  async calculateHash(path: string): Promise<string> {
+    if (this.hashOverrides.has(path)) {
+      return this.hashOverrides.get(path)!;
+    }
+
+    const content = await this.readFile(path);
+    return createHash('sha256').update(content).digest('hex');
+  }
+
+  clear(): void {
+    this.files.clear();
+    this.hashOverrides.clear();
+  }
+}

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

@@ -0,0 +1,72 @@
+/**
+ * Skill Propagation System - Public API
+ * TypeScript migration from propagate-skill-update.sh
+ */
+
+import { SkillPropagator } from './skill-propagator';
+import { SkillValidator } from './skill-validator';
+import { SkillMetadataParser } from './metadata-parser';
+import { VersionManager } from './version-manager';
+import { ConsoleLogger, NoOpLogger } from './logger';
+import { NodeFileSystemAdapter, MockFileSystemAdapter } from './file-system-adapter';
+import { SQLiteDatabaseAdapter, MockDatabaseAdapter } from './database-adapter';
+
+export { SkillPropagator, SkillValidator, SkillMetadataParser, VersionManager };
+export { ConsoleLogger, NoOpLogger };
+export { NodeFileSystemAdapter, MockFileSystemAdapter };
+export { SQLiteDatabaseAdapter, MockDatabaseAdapter };
+
+// Type exports
+export type {
+  SkillMetadata,
+  SkillInfo,
+  ValidationResult,
+  VersionInfo,
+  VersionChangeType,
+  VersionComparisonResult,
+  ContentHashResult,
+  PropagationResult,
+  ApprovalHistoryRecord,
+  SkillPropagationOptions,
+  LoggerConfig,
+  FileSystemAdapter,
+  DatabaseAdapter,
+  MetadataParser,
+  SkillValidator as ISkillValidator,
+  SkillPropagator as ISkillPropagator,
+  Logger,
+} from './types';
+
+/**
+ * Convenience function to create a fully configured propagator
+ */
+export async function createSkillPropagator(
+  databasePath: string = './.claude/skills-database/skills.db'
+) {
+  const { NodeFileSystemAdapter: NodeFSAdapter } = await import('./file-system-adapter');
+  const { SQLiteDatabaseAdapter: SQLiteDB } = await import('./database-adapter');
+  const { ConsoleLogger: Logger } = await import('./logger');
+  const { SkillPropagator: Propagator } = await import('./skill-propagator');
+
+  const fs = new NodeFSAdapter();
+  const db = new SQLiteDB(databasePath);
+  const logger = new Logger({ debug: process.env['DEBUG'] === '1' });
+
+  return new Propagator(fs, db, logger);
+}
+
+const defaultExport = {
+  SkillPropagator,
+  SkillValidator,
+  SkillMetadataParser,
+  VersionManager,
+  ConsoleLogger,
+  NoOpLogger,
+  NodeFileSystemAdapter,
+  MockFileSystemAdapter,
+  SQLiteDatabaseAdapter,
+  MockDatabaseAdapter,
+  createSkillPropagator,
+};
+
+export default defaultExport;

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

@@ -0,0 +1,43 @@
+/**
+ * Logger implementation for Skill Propagation System
+ */
+
+import type { Logger, LoggerConfig } from './types';
+
+export class ConsoleLogger implements Logger {
+  private debugEnabled: boolean;
+
+  constructor(config?: LoggerConfig) {
+    this.debugEnabled = config?.debug ?? false;
+  }
+
+  info(message: string): void {
+    console.error(`[INFO] ${message}`);
+  }
+
+  success(message: string): void {
+    console.error(`[SUCCESS] ${message}`);
+  }
+
+  error(message: string): void {
+    console.error(`[ERROR] ${message}`);
+  }
+
+  warning(message: string): void {
+    console.error(`[WARNING] ${message}`);
+  }
+
+  debug(message: string): void {
+    if (this.debugEnabled) {
+      console.error(`[DEBUG] ${message}`);
+    }
+  }
+}
+
+export class NoOpLogger implements Logger {
+  info(): void {}
+  success(): void {}
+  error(): void {}
+  warning(): void {}
+  debug(): void {}
+}