anchi-kit 1.2.0 → 1.2.1

package/.antigravity/skills/changelog-generator/scripts/generate-changelog.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Changelog Generator
+ * Generates a changelog from git commits using conventional commit format
+ */
+
+// Get the latest tag
+function getLatestTag() {
+  try {
+    return execSync('git describe --tags --abbrev=0', { encoding: 'utf-8' }).trim();
+  } catch (error) {
+    console.log('No previous tags found, using all commits');
+    return null;
+  }
+}
+
+// Get commits since last tag
+function getCommits(sinceTag) {
+  const range = sinceTag ? `${sinceTag}..HEAD` : 'HEAD';
+  const command = `git log ${range} --pretty=format:"%h|%s|%an|%ad" --date=short --no-merges`;
+  
+  try {
+    const output = execSync(command, { encoding: 'utf-8' });
+    return output.split('\n').filter(line => line.trim());
+  } catch (error) {
+    console.error('Error fetching commits:', error.message);
+    return [];
+  }
+}
+
+// Parse conventional commit
+function parseCommit(commitLine) {
+  const [hash, message, author, date] = commitLine.split('|');
+  const match = message.match(/^(\w+)(\(.+\))?:\s*(.+)$/);
+  
+  if (!match) {
+    return { type: 'other', hash, message, author, date };
+  }
+  
+  const [, type, scope, description] = match;
+  return {
+    type: type.toLowerCase(),
+    scope: scope ? scope.slice(1, -1) : null,
+    description,
+    hash,
+    author,
+    date
+  };
+}
+
+// Categorize commits
+function categorizeCommits(commits) {
+  const categories = {
+    added: [],
+    fixed: [],
+    changed: [],
+    deprecated: [],
+    removed: [],
+    security: [],
+    other: []
+  };
+  
+  commits.forEach(commit => {
+    const parsed = parseCommit(commit);
+    
+    switch (parsed.type) {
+      case 'feat':
+        categories.added.push(parsed);
+        break;
+      case 'fix':
+        categories.fixed.push(parsed);
+        break;
+      case 'refactor':
+      case 'perf':
+      case 'style':
+        categories.changed.push(parsed);
+        break;
+      case 'security':
+        categories.security.push(parsed);
+        break;
+      case 'docs':
+      case 'test':
+      case 'chore':
+        // Skip these or add to other
+        break;
+      default:
+        if (parsed.message.toLowerCase().includes('deprecate')) {
+          categories.deprecated.push(parsed);
+        } else if (parsed.message.toLowerCase().includes('remove')) {
+          categories.removed.push(parsed);
+        } else {
+          categories.other.push(parsed);
+        }
+    }
+  });
+  
+  return categories;
+}
+
+// Generate changelog markdown
+function generateChangelog(categories, version, date) {
+  let changelog = `# Changelog\n\n`;
+  changelog += `## [${version}] - ${date}\n\n`;
+  
+  const sections = [
+    { key: 'added', title: 'Added', icon: '✨' },
+    { key: 'fixed', title: 'Fixed', icon: '🐛' },
+    { key: 'changed', title: 'Changed', icon: '🔄' },
+    { key: 'deprecated', title: 'Deprecated', icon: '⚠️' },
+    { key: 'removed', title: 'Removed', icon: '🗑️' },
+    { key: 'security', title: 'Security', icon: '🔒' }
+  ];
+  
+  sections.forEach(({ key, title, icon }) => {
+    if (categories[key].length > 0) {
+      changelog += `### ${icon} ${title}\n\n`;
+      categories[key].forEach(commit => {
+        const scope = commit.scope ? `**${commit.scope}**: ` : '';
+        changelog += `- ${scope}${commit.description} ([${commit.hash}](../../commit/${commit.hash}))\n`;
+      });
+      changelog += '\n';
+    }
+  });
+  
+  return changelog;
+}
+
+// Main function
+function main() {
+  console.log('🚀 Generating changelog...\n');
+  
+  const latestTag = getLatestTag();
+  const commits = getCommits(latestTag);
+  
+  if (commits.length === 0) {
+    console.log('No new commits found.');
+    return;
+  }
+  
+  console.log(`Found ${commits.length} commits since ${latestTag || 'beginning'}\n`);
+  
+  const categories = categorizeCommits(commits);
+  const version = process.env.VERSION || 'Unreleased';
+  const date = new Date().toISOString().split('T')[0];
+  
+  const changelogContent = generateChangelog(categories, version, date);
+  
+  // Read existing CHANGELOG.md or create new
+  const changelogPath = path.join(process.cwd(), 'CHANGELOG.md');
+  let existingChangelog = '';
+  
+  if (fs.existsSync(changelogPath)) {
+    existingChangelog = fs.readFileSync(changelogPath, 'utf-8');
+    // Remove the header to avoid duplication
+    existingChangelog = existingChangelog.replace(/^# Changelog\n\n/, '');
+  }
+  
+  // Prepend new changelog
+  const finalChangelog = changelogContent + existingChangelog;
+  
+  fs.writeFileSync(changelogPath, finalChangelog);
+  
+  console.log(`✅ Changelog updated: ${changelogPath}`);
+  console.log(`\n📝 Summary:`);
+  console.log(`   Added: ${categories.added.length}`);
+  console.log(`   Fixed: ${categories.fixed.length}`);
+  console.log(`   Changed: ${categories.changed.length}`);
+  console.log(`   Security: ${categories.security.length}`);
+}
+
+// Run if called directly
+if (require.main === module) {
+  main();
+}
+
+module.exports = { getCommits, parseCommit, categorizeCommits, generateChangelog };

package/.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`