@thanhvn14/csvibe 0.1.3 → 0.1.5

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

@@ -0,0 +1,183 @@
+# 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/.github/skills/sequential-thinking/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "sequential-thinking-skill",
+  "version": "1.0.0",
+  "description": "Sequential thinking methodology with thought processing scripts",
+  "main": "scripts/process-thought.js",
+  "scripts": {
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
+  },
+  "keywords": [
+    "sequential-thinking",
+    "problem-solving",
+    "agent-skill"
+  ],
+  "author": "Converted from Anthropic MCP Server",
+  "license": "MIT",
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/tests/**/*.test.js"
+    ],
+    "coveragePathIgnorePatterns": [
+      "/node_modules/",
+      "/tests/"
+    ]
+  }
+}

package/.github/skills/sequential-thinking/scripts/format-thought.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+
+/**
+ * Sequential Thinking Thought Formatter
+ *
+ * Formats thoughts for display with visual indicators for type (regular/revision/branch).
+ * Provides consistent, readable output for thought sequences.
+ *
+ * Usage:
+ *   node format-thought.js --thought "Analysis" --number 1 --total 5
+ *   node format-thought.js --thought "Revision" --number 2 --total 5 --revision 1
+ *   node format-thought.js --thought "Branch A" --number 3 --total 5 --branch 2 --branchId "a"
+ */
+
+class ThoughtFormatter {
+  static format(thoughtData) {
+    const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId } = thoughtData;
+
+    let prefix = '';
+    let context = '';
+    let emoji = '';
+
+    if (isRevision && revisesThought) {
+      emoji = '🔄';
+      prefix = 'REVISION';
+      context = ` (revising thought ${revisesThought})`;
+    } else if (branchFromThought) {
+      emoji = '🌿';
+      prefix = 'BRANCH';
+      context = branchId ? ` (from thought ${branchFromThought}, ID: ${branchId})` : ` (from thought ${branchFromThought})`;
+    } else {
+      emoji = '💭';
+      prefix = 'Thought';
+      context = '';
+    }
+
+    const header = `${emoji} ${prefix} ${thoughtNumber}/${totalThoughts}${context}`;
+    const maxLength = Math.max(header.length, thought.length);
+    const border = '─'.repeat(maxLength + 4);
+
+    // Wrap long thoughts
+    const wrappedThought = this.wrapText(thought, maxLength);
+    const thoughtLines = wrappedThought.map(line => `│ ${line.padEnd(maxLength + 2)} │`).join('\n');
+
+    return `
+┌${border}┐
+│ ${header.padEnd(maxLength + 2)} │
+├${border}┤
+${thoughtLines}
+└${border}┘`;
+  }
+
+  static wrapText(text, maxWidth) {
+    if (text.length <= maxWidth) {
+      return [text];
+    }
+
+    const words = text.split(' ');
+    const lines = [];
+    let currentLine = '';
+
+    for (const word of words) {
+      if ((currentLine + ' ' + word).trim().length <= maxWidth) {
+        currentLine = currentLine ? currentLine + ' ' + word : word;
+      } else {
+        if (currentLine) lines.push(currentLine);
+        currentLine = word;
+      }
+    }
+
+    if (currentLine) lines.push(currentLine);
+    return lines;
+  }
+
+  static formatSimple(thoughtData) {
+    const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId } = thoughtData;
+
+    let marker = '';
+    if (isRevision && revisesThought) {
+      marker = ` [REVISION of Thought ${revisesThought}]`;
+    } else if (branchFromThought) {
+      marker = branchId ? ` [BRANCH ${branchId.toUpperCase()} from Thought ${branchFromThought}]` : ` [BRANCH from Thought ${branchFromThought}]`;
+    }
+
+    return `Thought ${thoughtNumber}/${totalThoughts}${marker}: ${thought}`;
+  }
+
+  static formatMarkdown(thoughtData) {
+    const { thoughtNumber, totalThoughts, thought, isRevision, revisesThought, branchFromThought, branchId } = thoughtData;
+
+    let marker = '';
+    if (isRevision && revisesThought) {
+      marker = ` **[REVISION of Thought ${revisesThought}]**`;
+    } else if (branchFromThought) {
+      marker = branchId ? ` **[BRANCH ${branchId.toUpperCase()} from Thought ${branchFromThought}]**` : ` **[BRANCH from Thought ${branchFromThought}]**`;
+    }
+
+    return `**Thought ${thoughtNumber}/${totalThoughts}**${marker}\n\n${thought}\n`;
+  }
+}
+
+// CLI Interface
+if (require.main === module) {
+  const args = process.argv.slice(2);
+
+  const parseArgs = (args) => {
+    const parsed = {};
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg.startsWith('--')) {
+        const key = arg.slice(2);
+        const value = args[i + 1];
+
+        if (value && !value.startsWith('--')) {
+          // Parse boolean
+          if (value === 'true') parsed[key] = true;
+          else if (value === 'false') parsed[key] = false;
+          // Parse number
+          else if (!isNaN(value)) parsed[key] = parseFloat(value);
+          // String
+          else parsed[key] = value;
+          i++;
+        }
+      }
+    }
+    return parsed;
+  };
+
+  const input = parseArgs(args);
+
+  const thoughtData = {
+    thought: input.thought || 'No thought provided',
+    thoughtNumber: input.number || 1,
+    totalThoughts: input.total || 1,
+    isRevision: input.revision !== undefined,
+    revisesThought: input.revision,
+    branchFromThought: input.branch,
+    branchId: input.branchId
+  };
+
+  const format = input.format || 'box';
+
+  let output;
+  switch (format) {
+    case 'simple':
+      output = ThoughtFormatter.formatSimple(thoughtData);
+      break;
+    case 'markdown':
+      output = ThoughtFormatter.formatMarkdown(thoughtData);
+      break;
+    case 'box':
+    default:
+      output = ThoughtFormatter.format(thoughtData);
+  }
+
+  console.log(output);
+}
+
+module.exports = { ThoughtFormatter };

package/.github/skills/sequential-thinking/scripts/process-thought.js

@@ -0,0 +1,236 @@
+#!/usr/bin/env node
+
+/**
+ * Sequential Thinking Thought Processor
+ *
+ * Validates and tracks sequential thoughts with revision and branching support.
+ * Provides deterministic validation and context management.
+ *
+ * Usage:
+ *   node process-thought.js --thought "Analysis text" --number 1 --total 5 --next true
+ *   node process-thought.js --thought "Revision" --number 2 --total 5 --next true --revision 1
+ *   node process-thought.js --reset  # Reset thought history
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// Configuration
+const HISTORY_FILE = path.join(__dirname, '.thought-history.json');
+const DISABLE_LOGGING = process.env.DISABLE_THOUGHT_LOGGING?.toLowerCase() === 'true';
+
+class ThoughtProcessor {
+  constructor() {
+    this.loadHistory();
+  }
+
+  loadHistory() {
+    try {
+      if (fs.existsSync(HISTORY_FILE)) {
+        const data = JSON.parse(fs.readFileSync(HISTORY_FILE, 'utf8'));
+        this.thoughtHistory = data.thoughtHistory || [];
+        this.branches = data.branches || {};
+      } else {
+        this.thoughtHistory = [];
+        this.branches = {};
+      }
+    } catch (error) {
+      this.thoughtHistory = [];
+      this.branches = {};
+    }
+  }
+
+  saveHistory() {
+    fs.writeFileSync(
+      HISTORY_FILE,
+      JSON.stringify({
+        thoughtHistory: this.thoughtHistory,
+        branches: this.branches
+      }, null, 2)
+    );
+  }
+
+  resetHistory() {
+    this.thoughtHistory = [];
+    this.branches = {};
+    if (fs.existsSync(HISTORY_FILE)) {
+      fs.unlinkSync(HISTORY_FILE);
+    }
+  }
+
+  validateThought(input) {
+    const errors = [];
+
+    if (!input.thought || typeof input.thought !== 'string' || input.thought.trim() === '') {
+      errors.push('Invalid thought: must be a non-empty string');
+    }
+
+    if (!input.thoughtNumber || typeof input.thoughtNumber !== 'number' || input.thoughtNumber < 1) {
+      errors.push('Invalid thoughtNumber: must be a positive number');
+    }
+
+    if (!input.totalThoughts || typeof input.totalThoughts !== 'number' || input.totalThoughts < 1) {
+      errors.push('Invalid totalThoughts: must be a positive number');
+    }
+
+    if (typeof input.nextThoughtNeeded !== 'boolean') {
+      errors.push('Invalid nextThoughtNeeded: must be a boolean');
+    }
+
+    // Optional field validations
+    if (input.isRevision !== undefined && typeof input.isRevision !== 'boolean') {
+      errors.push('Invalid isRevision: must be a boolean');
+    }
+
+    if (input.revisesThought !== undefined && (typeof input.revisesThought !== 'number' || input.revisesThought < 1)) {
+      errors.push('Invalid revisesThought: must be a positive number');
+    }
+
+    if (input.branchFromThought !== undefined && (typeof input.branchFromThought !== 'number' || input.branchFromThought < 1)) {
+      errors.push('Invalid branchFromThought: must be a positive number');
+    }
+
+    if (input.branchId !== undefined && typeof input.branchId !== 'string') {
+      errors.push('Invalid branchId: must be a string');
+    }
+
+    if (input.needsMoreThoughts !== undefined && typeof input.needsMoreThoughts !== 'boolean') {
+      errors.push('Invalid needsMoreThoughts: must be a boolean');
+    }
+
+    return errors;
+  }
+
+  processThought(input) {
+    const errors = this.validateThought(input);
+
+    if (errors.length > 0) {
+      return {
+        success: false,
+        errors,
+        status: 'failed'
+      };
+    }
+
+    // Auto-adjust totalThoughts if thoughtNumber exceeds it
+    if (input.thoughtNumber > input.totalThoughts) {
+      input.totalThoughts = input.thoughtNumber;
+    }
+
+    // Create thought data
+    const thoughtData = {
+      thought: input.thought,
+      thoughtNumber: input.thoughtNumber,
+      totalThoughts: input.totalThoughts,
+      nextThoughtNeeded: input.nextThoughtNeeded,
+      isRevision: input.isRevision,
+      revisesThought: input.revisesThought,
+      branchFromThought: input.branchFromThought,
+      branchId: input.branchId,
+      needsMoreThoughts: input.needsMoreThoughts,
+      timestamp: new Date().toISOString()
+    };
+
+    // Add to history
+    this.thoughtHistory.push(thoughtData);
+
+    // Track branches
+    if (thoughtData.branchFromThought && thoughtData.branchId) {
+      if (!this.branches[thoughtData.branchId]) {
+        this.branches[thoughtData.branchId] = [];
+      }
+      this.branches[thoughtData.branchId].push(thoughtData);
+    }
+
+    // Save history
+    this.saveHistory();
+
+    return {
+      success: true,
+      thoughtNumber: thoughtData.thoughtNumber,
+      totalThoughts: thoughtData.totalThoughts,
+      nextThoughtNeeded: thoughtData.nextThoughtNeeded,
+      branches: Object.keys(this.branches),
+      thoughtHistoryLength: this.thoughtHistory.length,
+      timestamp: thoughtData.timestamp
+    };
+  }
+
+  getHistory() {
+    return {
+      thoughts: this.thoughtHistory,
+      branches: this.branches,
+      totalThoughts: this.thoughtHistory.length
+    };
+  }
+}
+
+// CLI Interface
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const processor = new ThoughtProcessor();
+
+  // Parse arguments
+  const parseArgs = (args) => {
+    const parsed = {};
+    for (let i = 0; i < args.length; i++) {
+      const arg = args[i];
+      if (arg.startsWith('--')) {
+        const key = arg.slice(2);
+        const value = args[i + 1];
+
+        if (key === 'reset') {
+          return { reset: true };
+        }
+
+        if (key === 'history') {
+          return { history: true };
+        }
+
+        if (value && !value.startsWith('--')) {
+          // Parse boolean
+          if (value === 'true') parsed[key] = true;
+          else if (value === 'false') parsed[key] = false;
+          // Parse number
+          else if (!isNaN(value)) parsed[key] = parseFloat(value);
+          // String
+          else parsed[key] = value;
+          i++;
+        }
+      }
+    }
+    return parsed;
+  };
+
+  const input = parseArgs(args);
+
+  if (input.reset) {
+    processor.resetHistory();
+    console.log(JSON.stringify({ success: true, message: 'History reset' }, null, 2));
+    process.exit(0);
+  }
+
+  if (input.history) {
+    console.log(JSON.stringify(processor.getHistory(), null, 2));
+    process.exit(0);
+  }
+
+  // Map CLI args to expected field names
+  const thoughtInput = {
+    thought: input.thought,
+    thoughtNumber: input.number,
+    totalThoughts: input.total,
+    nextThoughtNeeded: input.next,
+    isRevision: input.revision !== undefined ? true : input.isRevision,
+    revisesThought: input.revision,
+    branchFromThought: input.branch,
+    branchId: input.branchId,
+    needsMoreThoughts: input.needsMore
+  };
+
+  const result = processor.processThought(thoughtInput);
+  console.log(JSON.stringify(result, null, 2));
+  process.exit(result.success ? 0 : 1);
+}
+
+module.exports = { ThoughtProcessor };

package/.github/skills/shopify/README.md

@@ -0,0 +1,66 @@
+# Shopify API Research Documentation
+
+This directory contains comprehensive research and analysis of various APIs for integration purposes.
+
+## Contents
+
+### Shopify GraphQL Admin API Analysis
+**File:** `shopify-graphql-admin-api-analysis.md`  
+**Date:** 2025-10-25  
+**Status:** Complete  
+**Thoroughness:** Very Thorough
+
+A comprehensive analysis of Shopify's GraphQL Admin API covering:
+- API overview and capabilities
+- Key features and operations
+- Common query and mutation patterns
+- Best practices and optimization strategies
+- Authentication and security considerations
+- Rate limiting and performance optimization
+- Typical use cases and implementation patterns
+- Troubleshooting guide
+- Code examples in multiple languages
+- Resources and further learning
+
+**Key Sections:**
+1. Executive Summary
+2. API Overview
+3. Key Features
+4. Common Operations (Queries & Mutations)
+5. API Structure (Types, Connections, Errors)
+6. Best Practices
+7. Typical Use Cases
+8. API Versions and Deprecation
+9. Tools and SDKs
+10. Security Considerations
+11. Performance Optimization
+12. Common Patterns
+13. Troubleshooting
+14. Resources and Further Learning
+
+**Size:** 1,348 lines, ~26KB
+
+---
+
+## Usage
+
+These documents are intended for:
+- Development planning and architecture decisions
+- Team onboarding and training
+- Integration implementation reference
+- Best practices guidance
+- Troubleshooting support
+
+---
+
+## Maintenance
+
+- Documents should be reviewed quarterly
+- Update when API versions change
+- Add new findings from implementation experience
+- Keep code examples current with latest SDK versions
+
+---
+
+**Last Updated:** 2025-10-25  
+**Maintained By:** Claude Code Engineering Team

package/.github/skills/shopify/scripts/requirements.txt

@@ -0,0 +1,19 @@
+# Shopify Skill Dependencies
+# Python 3.10+ required
+
+# No Python package dependencies - uses only standard library
+
+# Testing dependencies (dev)
+pytest>=8.0.0
+pytest-cov>=4.1.0
+pytest-mock>=3.12.0
+
+# Note: This script requires the Shopify CLI tool
+# Install Shopify CLI:
+#   npm install -g @shopify/cli @shopify/theme
+#   or via Homebrew (macOS):
+#   brew tap shopify/shopify
+#   brew install shopify-cli
+#
+# Authenticate with:
+#   shopify auth login