@hienlh/ppm 0.9.81 → 0.9.82

package/.opencode/skills/seo/scripts/validate-schema.cjs

@@ -1,421 +0,0 @@
-#!/usr/bin/env node
-/**
- * JSON-LD Schema Validator
- *
- * Validates JSON-LD schema markup against Schema.org specs and Google Rich Results requirements
- *
- * Usage:
- *   node validate-schema.cjs -f schema.json
- *   cat schema.json | node validate-schema.cjs
- *   node validate-schema.cjs -f schema.json --verbose
- *
- * Options:
- *   -f, --file <path>    Path to JSON-LD file
- *   -v, --verbose        Show detailed validation messages
- *   -h, --help           Show help
- */
-
-const fs = require('fs');
-
-// Schema.org required fields by type
-const REQUIRED_FIELDS = {
-  Article: ['@type', 'headline', 'author', 'datePublished', 'image'],
-  BlogPosting: ['@type', 'headline', 'author', 'datePublished', 'image'],
-  NewsArticle: ['@type', 'headline', 'author', 'datePublished', 'image'],
-  Product: ['@type', 'name', 'image', 'offers'],
-  Organization: ['@type', 'name', 'url'],
-  Person: ['@type', 'name'],
-  FAQPage: ['@type', 'mainEntity'],
-  HowTo: ['@type', 'name', 'step'],
-  Recipe: ['@type', 'name', 'image', 'recipeIngredient', 'recipeInstructions'],
-  Event: ['@type', 'name', 'startDate', 'location'],
-  LocalBusiness: ['@type', 'name', 'address', 'telephone'],
-  BreadcrumbList: ['@type', 'itemListElement'],
-  VideoObject: ['@type', 'name', 'description', 'thumbnailUrl', 'uploadDate'],
-};
-
-// Date field names that should be ISO 8601 format
-const DATE_FIELDS = [
-  'datePublished',
-  'dateModified',
-  'dateCreated',
-  'startDate',
-  'endDate',
-  'uploadDate',
-  'expires',
-  'validFrom',
-  'validThrough',
-];
-
-// URL field names
-const URL_FIELDS = [
-  'url',
-  'sameAs',
-  'logo',
-  'image',
-  'thumbnailUrl',
-  'contentUrl',
-  'embedUrl',
-];
-
-// Validation result tracking
-class ValidationResult {
-  constructor() {
-    this.errors = [];
-    this.warnings = [];
-    this.passed = true;
-  }
-
-  addError(message, field = null) {
-    this.errors.push(field ? `[${field}] ${message}` : message);
-    this.passed = false;
-  }
-
-  addWarning(message, field = null) {
-    this.warnings.push(field ? `[${field}] ${message}` : message);
-  }
-
-  get isValid() {
-    return this.passed;
-  }
-}
-
-// Validate ISO 8601 date format
-function isValidISO8601(dateString) {
-  if (typeof dateString !== 'string') return false;
-
-  // Basic ISO 8601 patterns: YYYY-MM-DD, YYYY-MM-DDTHH:mm:ss, etc.
-  const iso8601Regex = /^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}:\d{2}(\.\d{3})?(Z|[+-]\d{2}:\d{2})?)?$/;
-
-  if (!iso8601Regex.test(dateString)) return false;
-
-  // Check if it's a valid date
-  const date = new Date(dateString);
-  return !isNaN(date.getTime());
-}
-
-// Validate URL format
-function isValidURL(urlString) {
-  if (typeof urlString !== 'string') return false;
-
-  try {
-    new URL(urlString);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Validate required fields for a schema type
-function validateRequiredFields(schema, result) {
-  const schemaType = Array.isArray(schema['@type']) ? schema['@type'][0] : schema['@type'];
-
-  if (!schemaType) {
-    result.addError('Missing @type field');
-    return;
-  }
-
-  const requiredFields = REQUIRED_FIELDS[schemaType];
-
-  if (!requiredFields) {
-    result.addWarning(`Unknown schema type: ${schemaType}. Cannot validate required fields.`);
-    return;
-  }
-
-  for (const field of requiredFields) {
-    if (!(field in schema) || schema[field] === '' || schema[field] === null) {
-      result.addError(`Missing required field`, field);
-    }
-  }
-}
-
-// Validate date fields
-function validateDateFields(obj, result, parentKey = '') {
-  for (const [key, value] of Object.entries(obj)) {
-    const fullKey = parentKey ? `${parentKey}.${key}` : key;
-
-    if (DATE_FIELDS.includes(key)) {
-      if (!isValidISO8601(value)) {
-        result.addError(`Invalid ISO 8601 date format: ${value}`, fullKey);
-      }
-    }
-
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-      validateDateFields(value, result, fullKey);
-    } else if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        if (typeof item === 'object' && item !== null) {
-          validateDateFields(item, result, `${fullKey}[${index}]`);
-        }
-      });
-    }
-  }
-}
-
-// Validate URL fields
-function validateURLFields(obj, result, parentKey = '') {
-  for (const [key, value] of Object.entries(obj)) {
-    const fullKey = parentKey ? `${parentKey}.${key}` : key;
-
-    if (URL_FIELDS.includes(key)) {
-      if (Array.isArray(value)) {
-        value.forEach((item, index) => {
-          if (typeof item === 'string' && !isValidURL(item)) {
-            result.addError(`Invalid URL format: ${item}`, `${fullKey}[${index}]`);
-          } else if (typeof item === 'object' && item !== null) {
-            // Handle ImageObject in arrays
-            validateURLFields(item, result, `${fullKey}[${index}]`);
-          }
-        });
-      } else if (typeof value === 'string' && !isValidURL(value)) {
-        result.addError(`Invalid URL format: ${value}`, fullKey);
-      }
-      // If value is an object (e.g., ImageObject), recursion will handle it below
-    }
-
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-      validateURLFields(value, result, fullKey);
-    } else if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        if (typeof item === 'object' && item !== null) {
-          validateURLFields(item, result, `${fullKey}[${index}]`);
-        }
-      });
-    }
-  }
-}
-
-// Validate @context
-function validateContext(schema, result) {
-  if (!schema['@context']) {
-    result.addError('Missing @context field');
-  } else if (schema['@context'] !== 'https://schema.org' &&
-             schema['@context'] !== 'http://schema.org') {
-    result.addWarning(`Non-standard @context: ${schema['@context']}. Expected https://schema.org`);
-  }
-}
-
-// Validate image fields (must be URL or ImageObject)
-function validateImages(obj, result, parentKey = '') {
-  for (const [key, value] of Object.entries(obj)) {
-    const fullKey = parentKey ? `${parentKey}.${key}` : key;
-
-    if (key === 'image') {
-      if (typeof value === 'string') {
-        if (!isValidURL(value)) {
-          result.addError(`Image must be a valid URL`, fullKey);
-        }
-      } else if (typeof value === 'object' && value !== null) {
-        if (!value['@type'] || value['@type'] !== 'ImageObject') {
-          result.addWarning(`Image object should have @type: "ImageObject"`, fullKey);
-        }
-        if (!value.url || !isValidURL(value.url)) {
-          result.addError(`ImageObject must have valid url field`, `${fullKey}.url`);
-        }
-      } else if (Array.isArray(value)) {
-        value.forEach((img, index) => {
-          if (typeof img === 'string' && !isValidURL(img)) {
-            result.addError(`Image must be a valid URL`, `${fullKey}[${index}]`);
-          }
-        });
-      }
-    }
-
-    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
-      validateImages(value, result, fullKey);
-    } else if (Array.isArray(value)) {
-      value.forEach((item, index) => {
-        if (typeof item === 'object' && item !== null) {
-          validateImages(item, result, `${fullKey}[${index}]`);
-        }
-      });
-    }
-  }
-}
-
-// Main validation function
-function validateSchema(schemaData, verbose = false) {
-  const result = new ValidationResult();
-
-  try {
-    // Parse JSON if string
-    const schema = typeof schemaData === 'string' ? JSON.parse(schemaData) : schemaData;
-
-    // Basic structure validation
-    validateContext(schema, result);
-    validateRequiredFields(schema, result);
-
-    // Field format validation
-    validateDateFields(schema, result);
-    validateURLFields(schema, result);
-    validateImages(schema, result);
-
-    // Type-specific validations
-    const schemaType = Array.isArray(schema['@type']) ? schema['@type'][0] : schema['@type'];
-
-    if (schemaType === 'Product' && schema.offers) {
-      const offers = Array.isArray(schema.offers) ? schema.offers : [schema.offers];
-      offers.forEach((offer, index) => {
-        if (!offer.price && !offer.priceRange) {
-          result.addError('Product offer must have price or priceRange', `offers[${index}]`);
-        }
-        if (!offer.priceCurrency) {
-          result.addWarning('Product offer should have priceCurrency', `offers[${index}]`);
-        }
-      });
-    }
-
-    if (schemaType === 'FAQPage' && schema.mainEntity) {
-      const questions = Array.isArray(schema.mainEntity) ? schema.mainEntity : [schema.mainEntity];
-      questions.forEach((q, index) => {
-        if (!q.name) {
-          result.addError('Question must have name field', `mainEntity[${index}]`);
-        }
-        if (!q.acceptedAnswer) {
-          result.addError('Question must have acceptedAnswer', `mainEntity[${index}]`);
-        } else if (!q.acceptedAnswer.text) {
-          result.addError('Answer must have text field', `mainEntity[${index}].acceptedAnswer`);
-        }
-      });
-    }
-
-    if (schemaType === 'HowTo' && schema.step) {
-      const steps = Array.isArray(schema.step) ? schema.step : [schema.step];
-      steps.forEach((step, index) => {
-        if (!step.text && !step.itemListElement) {
-          result.addError('HowToStep must have text or itemListElement', `step[${index}]`);
-        }
-      });
-    }
-
-  } catch (error) {
-    result.addError(`JSON parsing error: ${error.message}`);
-  }
-
-  return result;
-}
-
-// Print validation results
-function printResults(result, verbose) {
-  if (result.isValid && result.warnings.length === 0) {
-    console.log('✓ Schema validation passed');
-    return 0;
-  }
-
-  if (result.errors.length > 0) {
-    console.log(`✗ Schema validation failed (${result.errors.length} errors)\n`);
-    console.log('Errors:');
-    result.errors.forEach(error => console.log(`  - ${error}`));
-  } else {
-    console.log('✓ Schema validation passed');
-  }
-
-  if (result.warnings.length > 0) {
-    console.log(`\nWarnings (${result.warnings.length}):`);
-    result.warnings.forEach(warning => console.log(`  - ${warning}`));
-  }
-
-  return result.isValid ? 0 : 1;
-}
-
-// Parse CLI arguments
-function parseArgs(args) {
-  const options = {
-    file: null,
-    verbose: false,
-    help: false,
-  };
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-    const next = args[i + 1];
-
-    switch (arg) {
-      case '-f':
-      case '--file':
-        options.file = next;
-        i++;
-        break;
-      case '-v':
-      case '--verbose':
-        options.verbose = true;
-        break;
-      case '-h':
-      case '--help':
-        options.help = true;
-        break;
-    }
-  }
-
-  return options;
-}
-
-// Print usage
-function printUsage() {
-  console.log(`
-JSON-LD Schema Validator
-
-Validates JSON-LD schema markup against Schema.org specs and Google Rich Results requirements
-
-Usage:
-  node validate-schema.cjs -f schema.json
-  cat schema.json | node validate-schema.cjs
-  node validate-schema.cjs -f schema.json --verbose
-
-Options:
-  -f, --file <path>    Path to JSON-LD file
-  -v, --verbose        Show detailed validation messages
-  -h, --help           Show this help
-
-Exit codes:
-  0 - Validation passed
-  1 - Validation failed
-`);
-}
-
-// Main execution
-if (require.main === module) {
-  const args = process.argv.slice(2);
-  const options = parseArgs(args);
-
-  if (options.help) {
-    printUsage();
-    process.exit(0);
-  }
-
-  let schemaData;
-
-  if (options.file) {
-    // Read from file
-    try {
-      schemaData = fs.readFileSync(options.file, 'utf-8');
-    } catch (error) {
-      console.error(`Error reading file: ${error.message}`);
-      process.exit(1);
-    }
-  } else {
-    // Read from stdin
-    const chunks = [];
-    process.stdin.on('data', chunk => chunks.push(chunk));
-    process.stdin.on('end', () => {
-      schemaData = Buffer.concat(chunks).toString('utf-8');
-
-      if (!schemaData.trim()) {
-        console.error('Error: No input provided. Use -f <file> or pipe JSON to stdin');
-        printUsage();
-        process.exit(1);
-      }
-
-      const result = validateSchema(schemaData, options.verbose);
-      const exitCode = printResults(result, options.verbose);
-      process.exit(exitCode);
-    });
-    return;
-  }
-
-  const result = validateSchema(schemaData, options.verbose);
-  const exitCode = printResults(result, options.verbose);
-  process.exit(exitCode);
-}
-
-module.exports = { validateSchema, ValidationResult };

package/.opencode/skills/sequential-thinking/README.md

@@ -1,183 +0,0 @@
-# Sequential Thinking Agent Skill
-
-Structured, reflective problem-solving methodology converted from the sequential-thinking MCP server into a native Agent Skill.
-
-## Overview
-
-This skill teaches Claude to apply systematic sequential thinking methodology for complex problem-solving, without relying on external MCP tools. It enables:
-- Breaking down complex problems into manageable thought sequences
-- Dynamic adjustment of thought count as understanding evolves
-- Revision of previous thoughts when new insights emerge
-- Branching into alternative reasoning paths
-- Hypothesis generation and verification
-
-## Skill Structure
-
-```
-sequential-thinking/
-├── SKILL.md (105 lines)
-│   Core methodology, when to apply, scripts usage
-│
-├── package.json
-│   Test dependencies (jest)
-│
-├── .env.example
-│   Configuration options
-│
-├── scripts/
-│   ├── process-thought.js (executable)
-│   │   Validate and track thoughts deterministically
-│   │
-│   └── format-thought.js (executable)
-│       Format thoughts for display (box/simple/markdown)
-│
-├── tests/
-│   ├── process-thought.test.js
-│   │   Validation, tracking, history tests
-│   │
-│   └── format-thought.test.js
-│       Formatting tests (all formats)
-│
-└── references/
-    ├── core-patterns.md (95 lines)
-    │   Essential revision & branching patterns
-    │
-    ├── examples-api.md (88 lines)
-    │   API design example walkthrough
-    │
-    ├── examples-debug.md (90 lines)
-    │   Performance debugging example
-    │
-    ├── examples-architecture.md (94 lines)
-    │   Architecture decision example
-    │
-    ├── advanced-techniques.md (76 lines)
-    │   Spiral refinement, hypothesis testing, convergence
-    │
-    └── advanced-strategies.md (79 lines)
-        Uncertainty management, revision cascades, meta-thinking
-```
-
-**Documentation**: 627 lines across 7 files (all under 100 lines)
-**Scripts**: 2 executable Node.js scripts with tests
-
-## Key Features
-
-### Progressive Disclosure Design
-Each file focuses on specific aspects, loaded only when needed:
-- **SKILL.md**: Quick reference with core methodology
-- **core-patterns.md**: Common patterns for everyday use
-- **examples-*.md**: Real-world walkthroughs for learning
-- **advanced-*.md**: Sophisticated techniques for complex scenarios
-
-### Token Efficiency
-- Concise explanations sacrifice grammar for brevity
-- Examples demonstrate patterns without verbose explanation
-- Cross-references between files avoid duplication
-
-### Methodology Conversion
-Extracted from MCP server's approach and converted to instructions:
-- MCP tool provided **interface** for sequential thinking
-- Agent skill provides **methodology** to think sequentially
-- No dependency on external tools—pure instructional approach
-
-## Usage Modes
-
-**Explicit Mode**: Use visible thought markers
-```
-Thought 1/5: [Analysis]
-Thought 2/5: [Further analysis]
-```
-
-**Implicit Mode**: Apply methodology internally without cluttering output
-
-## When Claude Should Use This Skill
-
-Automatically activated for:
-- Complex problem decomposition
-- Adaptive planning with potential revisions
-- Debugging and root cause analysis
-- Architecture and design decisions
-- Problems with unclear or emerging scope
-- Multi-step solutions requiring context
-
-## Scripts Usage
-
-### Process Thought (Validation & Tracking)
-
-```bash
-# Process a thought
-node scripts/process-thought.js --thought "Initial analysis" --number 1 --total 5 --next true
-
-# Process with revision
-node scripts/process-thought.js --thought "Corrected analysis" --number 2 --total 5 --next true --revision 1
-
-# Process with branching
-node scripts/process-thought.js --thought "Branch A" --number 2 --total 5 --next true --branch 1 --branchId "branch-a"
-
-# View history
-node scripts/process-thought.js --history
-
-# Reset history
-node scripts/process-thought.js --reset
-```
-
-### Format Thought (Display)
-
-```bash
-# Box format (default)
-node scripts/format-thought.js --thought "Analysis" --number 1 --total 5
-
-# Simple text format
-node scripts/format-thought.js --thought "Analysis" --number 1 --total 5 --format simple
-
-# Markdown format
-node scripts/format-thought.js --thought "Analysis" --number 1 --total 5 --format markdown
-
-# With revision
-node scripts/format-thought.js --thought "Revised" --number 2 --total 5 --revision 1
-
-# With branch
-node scripts/format-thought.js --thought "Branch" --number 2 --total 5 --branch 1 --branchId "a"
-```
-
-### Running Tests
-
-```bash
-# Install dependencies (first time only)
-npm install
-
-# Run all tests
-npm test
-
-# Run tests in watch mode
-npm run test:watch
-
-# Run with coverage
-npm run test:coverage
-```
-
-## When to Use Scripts
-
-**Use scripts when**:
-- Need deterministic validation of thought structure
-- Want persistent thought history tracking
-- Require formatted output for documentation
-- Building tools that integrate with sequential thinking
-
-**Don't use scripts when**:
-- Applying methodology directly in responses
-- Want lightweight, inline thinking
-- No need for validation or tracking
-
-Scripts are **optional tooling** - the methodology can be applied without them.
-
-## Source
-
-Converted from: https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking
-
-Original MCP server by Anthropic (MIT License).
-Skill conversion:
-- Extracts methodology as instructions
-- Adds executable scripts for deterministic validation
-- Makes tool-independent while preserving functionality

package/.opencode/skills/sequential-thinking/SKILL.md

@@ -1,97 +0,0 @@
----
-name: ck:sequential-thinking
-description: Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis, revision capability, and hypothesis verification. Use for complex problem decomposition, adaptive planning, analysis needing course correction, problems with unclear scope, multi-step solutions, and hypothesis-driven work.
-argument-hint: "[problem to analyze step-by-step]"
-license: MIT
-metadata:
-  author: claudekit
-  version: "1.0.0"
----
-
-# Sequential Thinking
-
-Structured problem-solving via manageable, reflective thought sequences with dynamic adjustment.
-
-## When to Apply
-
-- Complex problem decomposition
-- Adaptive planning with revision capability
-- Analysis needing course correction
-- Problems with unclear/emerging scope
-- Multi-step solutions requiring context maintenance
-- Hypothesis-driven investigation/debugging
-
-## Core Process
-
-### 1. Start with Loose Estimate
-```
-Thought 1/5: [Initial analysis]
-```
-Adjust dynamically as understanding evolves.
-
-### 2. Structure Each Thought
-- Build on previous context explicitly
-- Address one aspect per thought
-- State assumptions, uncertainties, realizations
-- Signal what next thought should address
-
-### 3. Apply Dynamic Adjustment
-- **Expand**: More complexity discovered → increase total
-- **Contract**: Simpler than expected → decrease total
-- **Revise**: New insight invalidates previous → mark revision
-- **Branch**: Multiple approaches → explore alternatives
-
-### 4. Use Revision When Needed
-```
-Thought 5/8 [REVISION of Thought 2]: [Corrected understanding]
-- Original: [What was stated]
-- Why revised: [New insight]
-- Impact: [What changes]
-```
-
-### 5. Branch for Alternatives
-```
-Thought 4/7 [BRANCH A from Thought 2]: [Approach A]
-Thought 4/7 [BRANCH B from Thought 2]: [Approach B]
-```
-Compare explicitly, converge with decision rationale.
-
-### 6. Generate & Verify Hypotheses
-```
-Thought 6/9 [HYPOTHESIS]: [Proposed solution]
-Thought 7/9 [VERIFICATION]: [Test results]
-```
-Iterate until hypothesis verified.
-
-### 7. Complete Only When Ready
-Mark final: `Thought N/N [FINAL]`
-
-Complete when:
-- Solution verified
-- All critical aspects addressed
-- Confidence achieved
-- No outstanding uncertainties
-
-## Application Modes
-
-**Explicit**: Use visible thought markers when complexity warrants visible reasoning or user requests breakdown.
-
-**Implicit**: Apply methodology internally for routine problem-solving where thinking aids accuracy without cluttering response.
-
-## Scripts (Optional)
-
-Optional scripts for deterministic validation/tracking:
-- `scripts/process-thought.js` - Validate & track thoughts with history
-- `scripts/format-thought.js` - Format for display (box/markdown/simple)
-
-See README.md for usage examples. Use when validation/persistence needed; otherwise apply methodology directly.
-
-## References
-
-Load when deeper understanding needed:
-- `references/core-patterns.md` - Revision & branching patterns
-- `references/examples-api.md` - API design example
-- `references/examples-debug.md` - Debugging example
-- `references/examples-architecture.md` - Architecture decision example
-- `references/advanced-techniques.md` - Spiral refinement, hypothesis testing, convergence
-- `references/advanced-strategies.md` - Uncertainty, revision cascades, meta-thinking