anchi-toolkit 1.2.0 → 1.2.2

package/dist/.antigravity/skills/chrome-devtools/scripts/screenshot.js

@@ -0,0 +1,180 @@
+#!/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/dist/.antigravity/skills/chrome-devtools/scripts/snapshot.js

@@ -0,0 +1,131 @@
+#!/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/dist/.antigravity/skills/claude-code/references/advanced-features.md

@@ -0,0 +1,399 @@
+# 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`