agent-skill-kit 3.9.135

package/.agent/scripts/utils/runner.ts

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * Script Runner - PikaKit
+ * ================================
+ * Executes scripts with timeout, output capture, and error handling.
+ */
+
+import { spawn, type ChildProcess } from 'child_process';
+import { resolve } from 'path';
+import { access } from 'fs/promises';
+
+export interface RunScriptOptions {
+    timeout?: number;
+    cwd?: string;
+    env?: NodeJS.ProcessEnv;
+}
+
+export interface ScriptResult {
+    code: number;
+    stdout: string;
+    stderr: string;
+    passed: boolean;
+}
+
+/**
+ * Run a script with timeout and output capture
+ */
+export async function runScript(
+    scriptPath: string,
+    args: string[] = [],
+    options: RunScriptOptions = {}
+): Promise<ScriptResult> {
+    const {
+        timeout = 300000, // 5 minute default
+        cwd = process.cwd(),
+        env = process.env
+    } = options;
+
+    const fullPath = resolve(cwd, scriptPath);
+
+    // Determine command based on file extension
+    const extension = scriptPath.split('.').pop();
+    let command: string;
+    let commandArgs: string[];
+
+    if (extension === 'ts' || extension === 'mts') {
+        command = 'npx';
+        commandArgs = ['tsx', fullPath, ...args];
+    } else if (extension === 'js' || extension === 'mjs') {
+        command = 'node';
+        commandArgs = [fullPath, ...args];
+    } else if (extension === 'py') {
+        command = 'python';
+        commandArgs = [fullPath, ...args];
+    } else {
+        // Assume executable
+        command = fullPath;
+        commandArgs = args;
+    }
+
+    return new Promise<ScriptResult>((resolvePromise, reject) => {
+        const child: ChildProcess = spawn(command, commandArgs, {
+            cwd,
+            env: { ...env },
+            shell: true, // Required for npm/node on Windows
+            windowsHide: true
+        });
+
+        let stdout = '';
+        let stderr = '';
+        let timedOut = false;
+
+        // Timeout handler
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill('SIGTERM');
+            // Force kill after 2s if not terminated
+            setTimeout(() => {
+                if (!child.killed) {
+                    child.kill('SIGKILL');
+                }
+            }, 2000);
+        }, timeout);
+
+        // Capture output
+        child.stdout?.on('data', (data: Buffer) => {
+            stdout += data.toString();
+        });
+
+        child.stderr?.on('data', (data: Buffer) => {
+            stderr += data.toString();
+        });
+
+        // Handle completion
+        child.on('close', (code: number | null) => {
+            clearTimeout(timer);
+
+            if (timedOut) {
+                reject(new Error(`Timeout: Script exceeded ${timeout}ms`));
+            } else {
+                resolvePromise({
+                    code: code ?? 1,
+                    stdout,
+                    stderr,
+                    passed: code === 0
+                });
+            }
+        });
+
+        // Handle spawn errors
+        child.on('error', (err: Error) => {
+            clearTimeout(timer);
+            reject(err);
+        });
+    });
+}
+
+/**
+ * Check if a script file exists
+ */
+export async function scriptExists(scriptPath: string): Promise<boolean> {
+    try {
+        await access(scriptPath);
+        return true;
+    } catch {
+        return false;
+    }
+}

package/.agent/scripts/verify_all.ts

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+
+/**
+ * Full Verification Suite - PikaKit
+ * ==========================================
+ * Comprehensive validation with all checks + performance + E2E
+ *
+ * Usage:
+ *   npx tsx verify_all.ts <project> --url <URL>
+ *   npx tsx verify_all.ts <project> --url <URL> --no-e2e
+ */
+
+import { resolve, join } from 'path';
+import { parseArgs } from 'node:util';
+import { access } from 'fs/promises';
+import { printHeader, printStep, printSuccess, printWarning, printError } from './utils/colors.ts';
+import { runScript, scriptExists, type ScriptResult } from './utils/runner.ts';
+import { printFinalReport, type CheckResult } from './utils/reporter.ts';
+
+interface CheckConfig {
+    name: string;
+    script: string;
+    required: boolean;
+}
+
+interface VerificationCategory {
+    category: string;
+    requiresUrl?: boolean;
+    checks: CheckConfig[];
+}
+
+// Complete verification suite
+const VERIFICATION_SUITE: VerificationCategory[] = [
+    // P0: Security (CRITICAL)
+    {
+        category: 'Security',
+        checks: [
+            { name: 'Security Scan', script: '.agent/skills/security-scanner/scripts/security_scan.ts', required: true }
+        ]
+    },
+
+    // P1: Code Quality (CRITICAL)
+    {
+        category: 'Code Quality',
+        checks: [
+            { name: 'Lint Check', script: '.agent/skills/code-review/scripts/lint_runner.ts', required: true },
+            { name: 'Type Coverage', script: '.agent/skills/typescript-expert/scripts/ts_diagnostic.ts', required: false }
+        ]
+    },
+
+    // P2: Data Layer
+    {
+        category: 'Data Layer',
+        checks: [
+            { name: 'Schema Validation', script: '.agent/skills/data-modeler/scripts/schema_validator.ts', required: false }
+        ]
+    },
+
+    // P3: Testing
+    {
+        category: 'Testing',
+        checks: [
+            { name: 'Test Suite', script: '.agent/skills/test-architect/scripts/test_runner.ts', required: false }
+        ]
+    },
+
+    // P4: UX & Accessibility
+    {
+        category: 'UX & Accessibility',
+        checks: [
+            { name: 'UX Audit', script: '.agent/skills/design-system/scripts/ux_audit.ts', required: false },
+            { name: 'Accessibility Check', script: '.agent/skills/design-system/scripts/accessibility_checker.ts', required: false }
+        ]
+    },
+
+    // P5: SEO & Content
+    {
+        category: 'SEO & Content',
+        checks: [
+            { name: 'SEO Check', script: '.agent/skills/seo-optimizer/scripts/seo_checker.ts', required: false }
+        ]
+    },
+
+    // P6: Performance (requires URL)
+    {
+        category: 'Performance',
+        requiresUrl: true,
+        checks: [
+            { name: 'Lighthouse Audit', script: '.agent/skills/perf-optimizer/scripts/lighthouse_audit.ts', required: true }
+        ]
+    },
+
+    // P7: E2E Testing (requires URL)
+    {
+        category: 'E2E Testing',
+        requiresUrl: true,
+        checks: [
+            { name: 'Playwright E2E', script: '.agent/skills/e2e-automation/scripts/playwright_runner.ts', required: false }
+        ]
+    },
+
+    // P8: Mobile
+    {
+        category: 'Mobile',
+        checks: [
+            { name: 'Mobile Audit', script: '.agent/skills/mobile-design/scripts/mobile_audit.ts', required: false }
+        ]
+    }
+];
+
+/**
+ * Run a single check
+ */
+async function runCheck(name: string, scriptPath: string, projectPath: string, url: string | null = null): Promise<CheckResult> {
+    const fullPath = join(projectPath, scriptPath);
+
+    if (!(await scriptExists(fullPath))) {
+        printWarning(`${name}: Script not found, skipping`);
+        return { name, passed: true, skipped: true, duration: 0 };
+    }
+
+    printStep(`Running: ${name}`);
+    const startTime = Date.now();
+
+    try {
+        const args: string[] = [projectPath];
+        if (url && (scriptPath.includes('lighthouse') || scriptPath.includes('playwright'))) {
+            args.push(url);
+        }
+
+        const result: ScriptResult = await runScript(fullPath, args, {
+            timeout: 600000, // 10 minutes for slow checks
+            cwd: projectPath
+        });
+
+        const duration = (Date.now() - startTime) / 1000;
+
+        if (result.passed) {
+            printSuccess(`${name}: PASSED (${duration.toFixed(1)}s)`);
+        } else {
+            printError(`${name}: FAILED (${duration.toFixed(1)}s)`);
+            if (result.stderr) {
+                console.log(`  ${result.stderr.substring(0, 300)}`);
+            }
+        }
+
+        return {
+            name,
+            passed: result.passed,
+            output: result.stdout,
+            error: result.stderr,
+            skipped: false,
+            duration
+        };
+
+    } catch (err: unknown) {
+        const duration = (Date.now() - startTime) / 1000;
+        const message = err instanceof Error ? err.message : String(err);
+
+        if (message.includes('Timeout')) {
+            printError(`${name}: TIMEOUT (>${duration.toFixed(0)}s)`);
+            return { name, passed: false, skipped: false, duration, error: 'Timeout' };
+        } else {
+            printError(`${name}: ERROR - ${message}`);
+            return { name, passed: false, skipped: false, duration, error: message };
+        }
+    }
+}
+
+/**
+ * Main entry point
+ */
+async function main(): Promise<void> {
+    const { values, positionals } = parseArgs({
+        args: process.argv.slice(2),
+        allowPositionals: true,
+        options: {
+            url: { type: 'string' },
+            'no-e2e': { type: 'boolean', default: false },
+            'stop-on-fail': { type: 'boolean', default: false }
+        }
+    });
+
+    const projectPath = resolve(positionals[0] || '.');
+
+    // Validate project path
+    try {
+        await access(projectPath);
+    } catch {
+        printError(`Project path does not exist: ${projectPath}`);
+        process.exit(1);
+    }
+
+    // Validate URL for performance checks
+    if (!values.url) {
+        printError('URL is required for performance & E2E checks');
+        console.log('\nUsage: npx tsx verify_all.ts <project> --url <URL>');
+        process.exit(1);
+    }
+
+    printHeader('🚀 PikaKit - FULL VERIFICATION SUITE');
+    console.log(`Project: ${projectPath}`);
+    console.log(`URL: ${values.url}`);
+    console.log(`Started: ${new Date().toLocaleString()}`);
+
+    const startTime = new Date();
+    const results: CheckResult[] = [];
+
+    // Run all verification categories
+    for (const suite of VERIFICATION_SUITE) {
+        const { category, requiresUrl = false, checks } = suite;
+
+        // Skip if requires URL and not provided
+        if (requiresUrl && !values.url) continue;
+
+        // Skip E2E if flag set
+        if (values['no-e2e'] && category === 'E2E Testing') continue;
+
+        printHeader(`📋 ${category.toUpperCase()}`);
+
+        for (const check of checks) {
+            const result = await runCheck(check.name, check.script, projectPath, values.url);
+            result.category = category;
+            results.push(result);
+
+            // Stop on critical failure if flag set
+            if (values['stop-on-fail'] && check.required && !result.passed && !result.skipped) {
+                printError(`CRITICAL: ${check.name} failed. Stopping verification.`);
+                printFinalReport(results, startTime);
+                process.exit(1);
+            }
+        }
+    }
+
+    // Print final report
+    const allPassed = printFinalReport(results, startTime);
+    process.exit(allPassed ? 0 : 1);
+}
+
+main().catch(err => {
+    console.error('Error:', err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/.agent/scripts/version-sync.ts

@@ -0,0 +1,256 @@
+// @ts-nocheck
+/**
+ * Version Sync — PikaKit
+ * Bumps version in package.json and syncs across all .md, registry.json, and root docs.
+ *
+ * Usage:
+ *   npx tsx version-sync.ts          # patch bump (default)
+ *   npx tsx version-sync.ts minor    # minor bump
+ *   npx tsx version-sync.ts major    # major bump
+ *   npx tsx version-sync.ts 4.0.0    # explicit version
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT_DIR = path.resolve(__dirname, '../../');
+const AGENT_DIR = path.join(ROOT_DIR, '.agent');
+
+// 1. Determine new version
+const args = process.argv.slice(2);
+let action = 'patch';
+
+for (const arg of args) {
+  if (['patch', 'minor', 'major'].includes(arg) || /^[vV]?\d+\.\d+\.\d+$/.test(arg)) {
+    action = arg;
+    break;
+  }
+}
+
+const pkgPath = path.join(ROOT_DIR, 'package.json');
+const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8').replace(/^\uFEFF/, ''));
+const currentVersion: string = pkg.version;
+
+let newVersion = currentVersion;
+
+if (action === 'patch' || action === 'minor' || action === 'major') {
+  let [major, minor, patch] = currentVersion.split('.').map(Number);
+  if (action === 'patch') patch++;
+  else if (action === 'minor') { minor++; patch = 0; }
+  else if (action === 'major') { major++; minor = 0; patch = 0; }
+  newVersion = `${major}.${minor}.${patch}`;
+} else {
+  newVersion = action.replace(/^[vV]/, '');
+}
+
+if (!/^\d+\.\d+\.\d+$/.test(newVersion)) {
+  console.error(`\n❌ Lỗi: Version không hợp lệ (${newVersion})`);
+  process.exit(1);
+}
+
+if (newVersion === currentVersion) {
+  console.log(`\n🔄 Version is unchanged (${newVersion}). Syncing...`);
+} else {
+  console.log(`\n🚀 Bumping version: ${currentVersion} → ${newVersion}`);
+  pkg.version = newVersion;
+  fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n', 'utf-8');
+}
+
+let updatedFiles = 0;
+
+// Recursive file scanner
+function scanDirectory(dir: string, ext = '.md'): string[] {
+  let results: string[] = [];
+  if (!fs.existsSync(dir)) return results;
+  const list = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of list) {
+    if (['node_modules', '.git', 'dist', 'build', '.next', 'coverage', '.turbo'].includes(entry.name)) continue;
+    const fullPath = path.resolve(dir, entry.name);
+    if (entry.isDirectory()) {
+      results = results.concat(scanDirectory(fullPath, ext));
+    } else if (fullPath.endsWith(ext)) {
+      results.push(fullPath);
+    }
+  }
+  return results;
+}
+
+// 2. Update all Markdown files in .agent/
+const agentMdFiles = scanDirectory(AGENT_DIR, '.md');
+
+for (const filePath of agentMdFiles) {
+  let content = fs.readFileSync(filePath, 'utf-8');
+  const originalContent = content;
+
+  // Update YAML metadata.version
+  const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (fmMatch) {
+    const fm = fmMatch[1];
+    if (fm.includes('version:')) {
+      const newFm = fm.replace(/version:\s*['"]?([0-9.]+)['"]?/, `version: "${newVersion}"`);
+      if (fm !== newFm) {
+        content = content.replace(fm, newFm);
+      }
+    }
+  }
+
+  // Update PikaKit vX.X.X
+  if (content.match(/PikaKit v[0-9.]+/)) {
+    content = content.replace(/PikaKit v[0-9.]+/g, `PikaKit v${newVersion}`);
+  }
+
+  // Update npm-vX.X.X
+  if (content.match(/npm-v[0-9.]+/)) {
+    content = content.replace(/npm-v[0-9.]+/g, `npm-v${newVersion}`);
+  }
+
+  // Bold version patterns like **v3.9.105**
+  if (content.match(/\*\*v\d+\.\d+\.\d+\*\*/)) {
+    content = content.replace(/\*\*v\d+\.\d+\.\d+\*\*/g, `**v${newVersion}**`);
+  }
+
+  // Standalone vX.X.X
+  const majorMinor = newVersion.split('.').slice(0, 2).join('.');
+  const standalonePattern = new RegExp(`(?<![a-zA-Z0-9/:-])v${majorMinor.replace(/\./g, '\\.')}\\.\\d+(?![a-zA-Z0-9/])`, 'g');
+  content = content.replace(standalonePattern, `v${newVersion}`);
+
+  if (content !== originalContent) {
+    fs.writeFileSync(filePath, content, 'utf-8');
+    updatedFiles++;
+    console.log(`✅ Updated ${path.relative(ROOT_DIR, filePath)} to v${newVersion}`);
+  }
+}
+
+// 3. Update registry.json
+const registryPath = path.join(AGENT_DIR, 'skills', 'registry.json');
+if (fs.existsSync(registryPath)) {
+  const registry = JSON.parse(fs.readFileSync(registryPath, 'utf-8').replace(/^\uFEFF/, ''));
+  if (registry.version !== newVersion) {
+    registry.version = newVersion;
+    fs.writeFileSync(registryPath, JSON.stringify(registry, null, 2) + '\n', 'utf-8');
+    console.log(`✅ Updated .agent/skills/registry.json to v${newVersion}`);
+    updatedFiles++;
+  }
+}
+
+// 4. Update JSON config files in .agent/config/
+const configDir = path.join(AGENT_DIR, 'config');
+if (fs.existsSync(configDir)) {
+  const configFiles = fs.readdirSync(configDir).filter((f: string) => f.endsWith('.json'));
+  for (const file of configFiles) {
+    const filePath = path.join(configDir, file);
+    try {
+      const config = JSON.parse(fs.readFileSync(filePath, 'utf-8').replace(/^\uFEFF/, ''));
+      // Check nested version fields (e.g. branding.version)
+      let changed = false;
+      if (config.version && config.version !== newVersion) {
+        config.version = newVersion;
+        changed = true;
+      }
+      if (config.branding?.version && config.branding.version !== newVersion) {
+        config.branding.version = newVersion;
+        changed = true;
+      }
+      if (changed) {
+        fs.writeFileSync(filePath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+        console.log(`✅ Updated .agent/config/${file} to v${newVersion}`);
+        updatedFiles++;
+      }
+    } catch { /* skip non-parseable files */ }
+  }
+}
+
+// 5. Update root docs
+const rootMdFiles = ['README.md', 'SYSTEM_PROMPT.md', 'GEMINI.md']
+  .map((f: string) => path.join(ROOT_DIR, f))
+  .concat(scanDirectory(path.join(ROOT_DIR, 'docs'), '.md'));
+
+for (const filePath of rootMdFiles) {
+  if (fs.existsSync(filePath)) {
+    let content = fs.readFileSync(filePath, 'utf-8');
+    const newContent = content
+      .replace(/PikaKit v[0-9.]+/g, `PikaKit v${newVersion}`)
+      .replace(/npm-v[0-9.]+/g, `npm-v${newVersion}`);
+    if (content !== newContent) {
+      fs.writeFileSync(filePath, newContent, 'utf-8');
+      console.log(`✅ Updated ${path.relative(ROOT_DIR, filePath)} to v${newVersion}`);
+      updatedFiles++;
+    }
+  }
+}
+
+// 6. Update pikakit root package (add-agent-skill-kit)
+const pikakitPkgPath = path.resolve(ROOT_DIR, '../add-agent-skill-kit/package.json');
+if (fs.existsSync(pikakitPkgPath)) {
+  const pikakitPkg = JSON.parse(fs.readFileSync(pikakitPkgPath, 'utf-8').replace(/^\uFEFF/, ''));
+  if (pikakitPkg.version !== newVersion) {
+    pikakitPkg.version = newVersion;
+    fs.writeFileSync(pikakitPkgPath, JSON.stringify(pikakitPkg, null, 2) + '\n', 'utf-8');
+    console.log(`✅ Updated pikakit package.json to v${newVersion}`);
+    updatedFiles++;
+  }
+}
+
+// 7. Update PikaKit Extension
+const extPkgPath = path.resolve(ROOT_DIR, '../add-agent-skill-kit/packages/pikakit-extension/package.json');
+if (fs.existsSync(extPkgPath)) {
+  const extPkg = JSON.parse(fs.readFileSync(extPkgPath, 'utf-8').replace(/^\uFEFF/, ''));
+  let extChanged = false;
+
+  // 7a. Sync version
+  if (extPkg.version !== newVersion) {
+    extPkg.version = newVersion;
+    extChanged = true;
+  }
+
+  // 7b. Sync description to include version
+  const expectedDesc = `PikaKit Engine v${newVersion} — Real-time auto-learning from IDE diagnostics to generate skills automatically`;
+  if (extPkg.description !== expectedDesc) {
+    extPkg.description = expectedDesc;
+    extChanged = true;
+  }
+
+  if (extChanged) {
+    fs.writeFileSync(extPkgPath, JSON.stringify(extPkg, null, 2) + '\n', 'utf-8');
+    console.log(`✅ Updated extension package.json (version + description) to v${newVersion}`);
+    updatedFiles++;
+  }
+}
+
+// 7c. Sync @version JSDoc in extension .ts source files
+const extSrcDir = path.resolve(ROOT_DIR, '../add-agent-skill-kit/packages/pikakit-extension/src');
+if (fs.existsSync(extSrcDir)) {
+  const tsFiles = fs.readdirSync(extSrcDir).filter((f: string) => f.endsWith('.ts'));
+  for (const file of tsFiles) {
+    const filePath = path.join(extSrcDir, file);
+    let content = fs.readFileSync(filePath, 'utf-8');
+    const versionTagRegex = /( \* @version )\d+\.\d+\.\d+/;
+    if (versionTagRegex.test(content)) {
+      const newContent = content.replace(versionTagRegex, `$1${newVersion}`);
+      if (content !== newContent) {
+        fs.writeFileSync(filePath, newContent, 'utf-8');
+        console.log(`✅ Updated @version in extension src/${file} to v${newVersion}`);
+        updatedFiles++;
+      }
+    }
+  }
+}
+
+const extReadmePath = path.resolve(ROOT_DIR, '../add-agent-skill-kit/packages/pikakit-extension/README.md');
+if (fs.existsSync(extReadmePath)) {
+  let content = fs.readFileSync(extReadmePath, 'utf-8');
+  const newContent = content
+    .replace(/PikaKit Engine v[0-9.]+/g, `PikaKit Engine v${newVersion}`)
+    .replace(/pikakit-engine-[0-9.]+\.vsix/g, `pikakit-engine-${newVersion}.vsix`);
+  
+  if (content !== newContent) {
+    fs.writeFileSync(extReadmePath, newContent, 'utf-8');
+    console.log(`✅ Updated extension README.md to v${newVersion}`);
+    updatedFiles++;
+  }
+}
+
+console.log(`\n🎉 Sync complete! Modified ${updatedFiles} instances to v${newVersion}.`);