anchi-kit 1.2.0 → 1.2.2

package/.cursor/skills/chrome-devtools/scripts/screenshot.js

@@ -1,180 +0,0 @@
-#!/usr/bin/env node
-/**
- * Take a screenshot
- * Usage: node screenshot.js --output screenshot.png [--url https://example.com] [--full-page true] [--selector .element] [--max-size 5] [--no-compress]
- * Supports both CSS and XPath selectors:
- *   - CSS: node screenshot.js --selector ".main-content" --output page.png
- *   - XPath: node screenshot.js --selector "//div[@class='main-content']" --output page.png
- */
-import { getBrowser, getPage, closeBrowser, parseArgs, outputJSON, outputError } from './lib/browser.js';
-import { parseSelector, getElement, enhanceError } from './lib/selector.js';
-import fs from 'fs/promises';
-import path from 'path';
-import { execSync } from 'child_process';
-
-/**
- * Compress image using ImageMagick if it exceeds max size
- * @param {string} filePath - Path to the image file
- * @param {number} maxSizeMB - Maximum file size in MB (default: 5)
- * @returns {Promise<{compressed: boolean, originalSize: number, finalSize: number}>}
- */
-async function compressImageIfNeeded(filePath, maxSizeMB = 5) {
-  const stats = await fs.stat(filePath);
-  const originalSize = stats.size;
-  const maxSizeBytes = maxSizeMB * 1024 * 1024;
-
-  if (originalSize <= maxSizeBytes) {
-    return { compressed: false, originalSize, finalSize: originalSize };
-  }
-
-  try {
-    // Check if ImageMagick is available
-    try {
-      execSync('magick -version', { stdio: 'pipe' });
-    } catch {
-      try {
-        execSync('convert -version', { stdio: 'pipe' });
-      } catch {
-        console.error('Warning: ImageMagick not found. Install it to enable automatic compression.');
-        return { compressed: false, originalSize, finalSize: originalSize };
-      }
-    }
-
-    const ext = path.extname(filePath).toLowerCase();
-    const tempPath = filePath.replace(ext, `.temp${ext}`);
-
-    // Determine compression strategy based on file type
-    let compressionCmd;
-    if (ext === '.png') {
-      // For PNG: resize and compress with quality
-      compressionCmd = `magick "${filePath}" -strip -resize 90% -quality 85 "${tempPath}"`;
-    } else if (ext === '.jpg' || ext === '.jpeg') {
-      // For JPEG: compress with quality and progressive
-      compressionCmd = `magick "${filePath}" -strip -quality 80 -interlace Plane "${tempPath}"`;
-    } else {
-      // For other formats: convert to JPEG with compression
-      compressionCmd = `magick "${filePath}" -strip -quality 80 "${tempPath.replace(ext, '.jpg')}"`;
-    }
-
-    // Try compression
-    execSync(compressionCmd, { stdio: 'pipe' });
-
-    const compressedStats = await fs.stat(tempPath);
-    const compressedSize = compressedStats.size;
-
-    // If still too large, try more aggressive compression
-    if (compressedSize > maxSizeBytes) {
-      const finalPath = filePath.replace(ext, `.final${ext}`);
-      let aggressiveCmd;
-
-      if (ext === '.png') {
-        aggressiveCmd = `magick "${tempPath}" -strip -resize 75% -quality 70 "${finalPath}"`;
-      } else {
-        aggressiveCmd = `magick "${tempPath}" -strip -quality 60 -sampling-factor 4:2:0 "${finalPath}"`;
-      }
-
-      execSync(aggressiveCmd, { stdio: 'pipe' });
-      await fs.unlink(tempPath);
-      await fs.rename(finalPath, filePath);
-    } else {
-      await fs.rename(tempPath, filePath);
-    }
-
-    const finalStats = await fs.stat(filePath);
-    return { compressed: true, originalSize, finalSize: finalStats.size };
-  } catch (error) {
-    console.error('Compression error:', error.message);
-    // If compression fails, keep original file
-    try {
-      const tempPath = filePath.replace(path.extname(filePath), '.temp' + path.extname(filePath));
-      await fs.unlink(tempPath).catch(() => {});
-    } catch {}
-    return { compressed: false, originalSize, finalSize: originalSize };
-  }
-}
-
-async function screenshot() {
-  const args = parseArgs(process.argv.slice(2));
-
-  if (!args.output) {
-    outputError(new Error('--output is required'));
-    return;
-  }
-
-  try {
-    const browser = await getBrowser({
-      headless: args.headless !== 'false'
-    });
-
-    const page = await getPage(browser);
-
-    // Navigate if URL provided
-    if (args.url) {
-      await page.goto(args.url, {
-        waitUntil: args['wait-until'] || 'networkidle2'
-      });
-    }
-
-    const screenshotOptions = {
-      path: args.output,
-      type: args.format || 'png',
-      fullPage: args['full-page'] === 'true'
-    };
-
-    if (args.quality) {
-      screenshotOptions.quality = parseInt(args.quality);
-    }
-
-    let buffer;
-    if (args.selector) {
-      // Parse and validate selector
-      const parsed = parseSelector(args.selector);
-
-      // Get element based on selector type
-      const element = await getElement(page, parsed);
-      if (!element) {
-        throw new Error(`Element not found: ${args.selector}`);
-      }
-      buffer = await element.screenshot(screenshotOptions);
-    } else {
-      buffer = await page.screenshot(screenshotOptions);
-    }
-
-    const result = {
-      success: true,
-      output: path.resolve(args.output),
-      size: buffer.length,
-      url: page.url()
-    };
-
-    // Compress image if needed (unless --no-compress flag is set)
-    if (args['no-compress'] !== 'true') {
-      const maxSize = args['max-size'] ? parseFloat(args['max-size']) : 5;
-      const compressionResult = await compressImageIfNeeded(args.output, maxSize);
-
-      if (compressionResult.compressed) {
-        result.compressed = true;
-        result.originalSize = compressionResult.originalSize;
-        result.size = compressionResult.finalSize;
-        result.compressionRatio = ((1 - compressionResult.finalSize / compressionResult.originalSize) * 100).toFixed(2) + '%';
-      }
-    }
-
-    outputJSON(result);
-
-    if (args.close !== 'false') {
-      await closeBrowser();
-    }
-  } catch (error) {
-    // Enhance error message if selector-related
-    if (args.selector) {
-      const enhanced = enhanceError(error, args.selector);
-      outputError(enhanced);
-    } else {
-      outputError(error);
-    }
-    process.exit(1);
-  }
-}
-
-screenshot();

package/.cursor/skills/chrome-devtools/scripts/snapshot.js

@@ -1,131 +0,0 @@
-#!/usr/bin/env node
-/**
- * Get DOM snapshot with selectors
- * Usage: node snapshot.js [--url https://example.com] [--output snapshot.json]
- */
-import { getBrowser, getPage, closeBrowser, parseArgs, outputJSON, outputError } from './lib/browser.js';
-import fs from 'fs/promises';
-
-async function snapshot() {
-  const args = parseArgs(process.argv.slice(2));
-
-  try {
-    const browser = await getBrowser({
-      headless: args.headless !== 'false'
-    });
-
-    const page = await getPage(browser);
-
-    // Navigate if URL provided
-    if (args.url) {
-      await page.goto(args.url, {
-        waitUntil: args['wait-until'] || 'networkidle2'
-      });
-    }
-
-    // Get interactive elements with metadata
-    const elements = await page.evaluate(() => {
-      const interactiveSelectors = [
-        'a[href]',
-        'button',
-        'input',
-        'textarea',
-        'select',
-        '[onclick]',
-        '[role="button"]',
-        '[role="link"]',
-        '[contenteditable]'
-      ];
-
-      const elements = [];
-      const selector = interactiveSelectors.join(', ');
-      const nodes = document.querySelectorAll(selector);
-
-      nodes.forEach((el, index) => {
-        const rect = el.getBoundingClientRect();
-
-        // Generate unique selector
-        let uniqueSelector = '';
-        if (el.id) {
-          uniqueSelector = `#${el.id}`;
-        } else if (el.className) {
-          const classes = Array.from(el.classList).join('.');
-          uniqueSelector = `${el.tagName.toLowerCase()}.${classes}`;
-        } else {
-          uniqueSelector = el.tagName.toLowerCase();
-        }
-
-        elements.push({
-          index: index,
-          tagName: el.tagName.toLowerCase(),
-          type: el.type || null,
-          id: el.id || null,
-          className: el.className || null,
-          name: el.name || null,
-          value: el.value || null,
-          text: el.textContent?.trim().substring(0, 100) || null,
-          href: el.href || null,
-          selector: uniqueSelector,
-          xpath: getXPath(el),
-          visible: rect.width > 0 && rect.height > 0,
-          position: {
-            x: rect.x,
-            y: rect.y,
-            width: rect.width,
-            height: rect.height
-          }
-        });
-      });
-
-      function getXPath(element) {
-        if (element.id) {
-          return `//*[@id="${element.id}"]`;
-        }
-        if (element === document.body) {
-          return '/html/body';
-        }
-        let ix = 0;
-        const siblings = element.parentNode?.childNodes || [];
-        for (let i = 0; i < siblings.length; i++) {
-          const sibling = siblings[i];
-          if (sibling === element) {
-            return getXPath(element.parentNode) + '/' + element.tagName.toLowerCase() + '[' + (ix + 1) + ']';
-          }
-          if (sibling.nodeType === 1 && sibling.tagName === element.tagName) {
-            ix++;
-          }
-        }
-        return '';
-      }
-
-      return elements;
-    });
-
-    const result = {
-      success: true,
-      url: page.url(),
-      title: await page.title(),
-      elementCount: elements.length,
-      elements: elements
-    };
-
-    if (args.output) {
-      await fs.writeFile(args.output, JSON.stringify(result, null, 2));
-      outputJSON({
-        success: true,
-        output: args.output,
-        elementCount: elements.length
-      });
-    } else {
-      outputJSON(result);
-    }
-
-    if (args.close !== 'false') {
-      await closeBrowser();
-    }
-  } catch (error) {
-    outputError(error);
-  }
-}
-
-snapshot();

package/.cursor/skills/claude-code/references/advanced-features.md

@@ -1,399 +0,0 @@
-# Advanced Features
-
-Extended thinking, prompt caching, checkpointing, and memory management in Cursor.
-
-## Extended Thinking
-
-Deep reasoning for complex problems.
-
-### Enable Extended Thinking
-
-**Global configuration:**
-```bash
-claude config set thinking.enabled true
-claude config set thinking.budget 15000
-```
-
-**Project settings (.cursor/settings.json):**
-```json
-{
-  "thinking": {
-    "enabled": true,
-    "budget": 10000,
-    "mode": "auto"
-  }
-}
-```
-
-**Command-line flag:**
-```bash
-claude --thinking "architect microservices system"
-```
-
-### Thinking Modes
-
-**auto**: Claude decides when to use extended thinking
-**manual**: User explicitly requests thinking
-**disabled**: No extended thinking
-
-```json
-{
-  "thinking": {
-    "mode": "auto",
-    "budget": 10000,
-    "minComplexity": 0.7
-  }
-}
-```
-
-### Budget Control
-
-Set token budget for thinking:
-
-```json
-{
-  "thinking": {
-    "budget": 10000,      // Max tokens for thinking
-    "budgetPerRequest": 5000,  // Per-request limit
-    "adaptive": true      // Adjust based on task complexity
-  }
-}
-```
-
-### Best Use Cases
-
-- Architecture design
-- Complex algorithm development
-- System refactoring
-- Performance optimization
-- Security analysis
-- Bug investigation
-
-### Example
-
-```bash
-claude --thinking "Design a distributed caching system with:
-- High availability
-- Consistency guarantees
-- Horizontal scalability
-- Fault tolerance"
-```
-
-## Prompt Caching
-
-Reduce costs by caching repeated context.
-
-### Enable Caching
-
-**API usage:**
-```typescript
-const response = await client.messages.create({
-  model: 'claude-sonnet-4-5-20250929',
-  system: [
-    {
-      type: 'text',
-      text: 'You are a coding assistant...',
-      cache_control: { type: 'ephemeral' }
-    }
-  ],
-  messages: [...]
-});
-```
-
-**CLI configuration:**
-```json
-{
-  "caching": {
-    "enabled": true,
-    "ttl": 300,
-    "maxSize": "100MB"
-  }
-}
-```
-
-### Cache Strategy
-
-**What to cache:**
-- Large codebases
-- Documentation
-- API specifications
-- System prompts
-- Project context
-
-**What not to cache:**
-- User queries
-- Dynamic content
-- Temporary data
-- Session-specific info
-
-### Cache Control
-
-```typescript
-// Cache large context
-{
-  type: 'text',
-  text: largeCodebase,
-  cache_control: { type: 'ephemeral' }
-}
-
-// Update without invalidating cache
-{
-  type: 'text',
-  text: newUserQuery
-  // No cache_control = not cached
-}
-```
-
-### Cost Savings
-
-With caching:
-- First request: Full cost
-- Subsequent requests: ~90% discount on cached tokens
-- Cache TTL: 5 minutes
-
-Example:
-```
-Without caching:
-Request 1: 10,000 tokens @ $3/M = $0.03
-Request 2: 10,000 tokens @ $3/M = $0.03
-Total: $0.06
-
-With caching (8,000 tokens cached):
-Request 1: 10,000 tokens @ $3/M = $0.03
-Request 2: 2,000 new + 8,000 cached @ $0.30/M = $0.0024
-Total: $0.0324 (46% savings)
-```
-
-## Checkpointing
-
-Automatically track and rewind changes.
-
-### Enable Checkpointing
-
-```bash
-claude config set checkpointing.enabled true
-```
-
-**Settings:**
-```json
-{
-  "checkpointing": {
-    "enabled": true,
-    "autoSave": true,
-    "interval": 300,
-    "maxCheckpoints": 50
-  }
-}
-```
-
-### View Checkpoints
-
-```bash
-# List checkpoints
-claude checkpoint list
-
-# View checkpoint details
-claude checkpoint show checkpoint-123
-```
-
-### Restore Checkpoint
-
-```bash
-# Restore to checkpoint
-claude checkpoint restore checkpoint-123
-
-# Restore to time
-claude checkpoint restore --time "2025-11-06T10:00:00Z"
-
-# Restore specific files
-claude checkpoint restore checkpoint-123 --files src/main.js
-```
-
-### Create Manual Checkpoint
-
-```bash
-# Create checkpoint with message
-claude checkpoint create "before refactoring auth module"
-
-# Create at important moments
-claude checkpoint create "working state before experiment"
-```
-
-### Checkpoint Strategies
-
-**Auto-save checkpoints:**
-- Before major changes
-- After successful tests
-- Every N minutes
-- Before destructive operations
-
-**Manual checkpoints:**
-- Before risky refactors
-- At working states
-- Before experiments
-- After milestones
-
-### Example Workflow
-
-```bash
-# Create checkpoint before risky change
-claude checkpoint create "before performance optimization"
-
-# Make changes
-claude "optimize database queries for 10x performance"
-
-# If something breaks
-claude checkpoint restore "before performance optimization"
-
-# Or continue with improvements
-claude checkpoint create "performance optimization complete"
-```
-
-## Memory Management
-
-Control how Claude remembers context across sessions.
-
-### Memory Locations
-
-**global**: Share memory across all projects
-**project**: Project-specific memory
-**none**: Disable memory
-
-```bash
-# Set memory location
-claude config set memory.location project
-
-# Enable memory
-claude config set memory.enabled true
-```
-
-### Configuration
-
-```json
-{
-  "memory": {
-    "enabled": true,
-    "location": "project",
-    "ttl": 86400,
-    "maxSize": "10MB",
-    "autoSummarize": true
-  }
-}
-```
-
-### Memory Operations
-
-```bash
-# View stored memories
-claude memory list
-
-# View specific memory
-claude memory show memory-123
-
-# Clear all memories
-claude memory clear
-
-# Clear old memories
-claude memory clear --older-than 7d
-
-# Clear project memories
-claude memory clear --project
-```
-
-### What Gets Remembered
-
-**Automatically:**
-- Project structure
-- Coding patterns
-- Preferences
-- Common commands
-- File locations
-
-**Explicitly stored:**
-- Important context
-- Design decisions
-- Architecture notes
-- Team conventions
-
-### Memory Best Practices
-
-**Project memory:**
-- Good for project-specific context
-- Shares across team members
-- Persists in `.cursor/memory/`
-- Commit to version control (optional)
-
-**Global memory:**
-- Personal preferences
-- General knowledge
-- Common patterns
-- Cross-project learnings
-
-**Disable memory when:**
-- Working with sensitive data
-- One-off tasks
-- Testing/experimentation
-- Troubleshooting
-
-### Example
-
-```bash
-# Remember project architecture
-claude "Remember: This project uses Clean Architecture with:
-- Domain layer (core business logic)
-- Application layer (use cases)
-- Infrastructure layer (external dependencies)
-- Presentation layer (API/UI)"
-
-# Claude will recall this in future sessions
-claude "Add a new user registration feature"
-# Claude: "I'll implement this following the Clean Architecture..."
-```
-
-## Context Windows
-
-Manage large context effectively.
-
-### Maximum Context
-
-Model context limits:
-- Claude Sonnet: 200k tokens
-- Claude Opus: 200k tokens
-- Claude Haiku: 200k tokens
-
-### Context Management
-
-```json
-{
-  "context": {
-    "maxTokens": 200000,
-    "autoTruncate": true,
-    "prioritize": ["recent", "relevant"],
-    "summarizeLong": true
-  }
-}
-```
-
-### Strategies
-
-**Summarization:**
-- Auto-summarize old context
-- Keep summaries of large files
-- Compress conversation history
-
-**Prioritization:**
-- Recent messages first
-- Most relevant files
-- Explicit user priorities
-
-**Chunking:**
-- Process large codebases in chunks
-- Incremental analysis
-- Parallel processing
-
-## See Also
-
-- Pricing: https://docs.cursor.com/about-claude/pricing
-- Token counting: https://docs.cursor.com/build-with-claude/token-counting
-- Best practices: `references/best-practices.md`
-- Configuration: `references/configuration.md`