anchi-kit 1.2.0 → 1.2.2

package/.antigravity/skills/csv-data-analyzer/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: csv-data-analyzer
+description: Automatically analyze CSV files to generate comprehensive insights with statistical summaries, data quality checks, pattern detection, and visualization recommendations. No prompts required.
+---
+
+# CSV Data Analyzer
+
+Automatic CSV analysis with insights, statistics, and visualization recommendations.
+
+##When to Use
+
+- Analyzing datasets
+- Data quality assessment
+- Finding patterns and trends
+- Before data visualization
+- Data profiling
+
+## Quick Analysis
+
+```bash
+# AI analyzes CSV automatically
+Upload CSV → Get instant insights
+```
+
+## Analysis Components
+
+### 1. Statistical Summary
+
+- Row/column counts
+- Data types detected
+- Missing values (%)
+- Unique values
+- Basic statistics (mean, median, mode, std dev)
+
+### 2. Data Quality
+
+- Null/missing data
+- Duplicates
+- Outliers
+- Data type inconsistencies
+- Format validation
+
+### 3. Pattern Detection
+
+- Trends over time
+- Correlations between columns
+- Clustering opportunities
+- Seasonality
+- Anomalies
+
+### 4. Visualization Recommendations
+
+- Best chart types for data
+- Suggested visualizations
+- Key relationships to highlight
+
+## Example Output
+
+```markdown
+## Dataset: sales_data.csv
+
+**Overview:**
+
+- Rows: 10,523
+- Columns: 8
+- Date Range: 2023-01-01 to 2023-12-31
+
+**Key Insights:**
+
+- Revenue trending upward (+23% YoY)
+- Missing data in 'region' column (3.2%)
+- Strong correlation between marketing_spend and sales (0.87)
+- Seasonal pattern detected (peaks in Q4)
+
+**Recommendations:**
+
+1. Visualize: Time series line chart for revenue
+2. Investigate: Missing region data
+3. Explore: Marketing ROI analysis
+4. Consider: Seasonal forecasting model
+```
+
+## Advanced Features
+
+- Automatic type inference
+- Distribution analysis
+- Correlation matrices
+- Trend detection
+- Outlier identification
+
+See [references/data-analysis-patterns.md](references/data-analysis-patterns.md) for advanced techniques.

package/.antigravity/skills/d3-visualization/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: d3-visualization
+description: Create interactive D3.js charts and data visualizations. Teaches D3 patterns for charts, graphs, and interactive dashboards with responsive design and animations.
+---
+
+# D3.js Visualization
+
+Interactive data visualizations using D3.js library.
+
+## When to Use
+
+- Creating dashboards
+- Data storytelling
+- Interactive charts
+- Custom visualizations
+- Real-time data display
+
+## Common Chart Types
+
+### Bar Charts
+
+```javascript
+const svg = d3.select("svg");
+svg
+  .selectAll("rect")
+  .data(data)
+  .enter()
+  .append("rect")
+  .attr("x", (d, i) => i * 30)
+  .attr("y", (d) => height - d.value)
+  .attr("height", (d) => d.value);
+```
+
+### Line Charts
+
+```javascript
+const line = d3
+  .line()
+  .x((d) => xScale(d.date))
+  .y((d) => yScale(d.value));
+
+svg.append("path").datum(data).attr("d", line);
+```
+
+### Scatter Plots, Pie Charts, Hierarchies
+
+See [references/chart-types.md](references/chart-types.md)
+
+## Best Practices
+
+1. **Responsive Design** - Scale to container
+2. **Smooth Animations** - Use transitions
+3. **Interactive** - Add tooltips, zooming
+4. **Accessible** - ARIA labels, keyboard nav
+5. **Performance** - Optimize for large datasets
+
+## D3 Patterns
+
+- Data binding
+- Enter/Update/Exit
+- Scales and axes
+- Transitions
+- Force layouts
+
+See [references/d3-examples.md](references/d3-examples.md) for complete examples.

package/.antigravity/skills/file-organizer/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: file-organizer
+description: Intelligently organize files and folders by understanding context, finding duplicates, and suggesting better organizational structures. Maintains clean, logical project hierarchies.
+---
+
+# File Organizer
+
+Context-aware file and folder organization with duplicate detection.
+
+## When to Use
+
+- Messy project directories
+- After large refactoring
+- Cleaning up downloads/temp files
+- Organizing documentation
+- Before project archival
+
+## Organization Strategies
+
+### By Type
+
+```
+project/
+├── src/           # Source code
+├── tests/         # Test files
+├── docs/          # Documentation
+├── config/        # Configuration
+└── assets/        # Images, fonts, etc.
+```
+
+### By Feature
+
+```
+project/
+├── auth/          # All auth-related files
+├── dashboard/     # Dashboard feature
+└── settings/      # Settings feature
+```
+
+### By Layer (Clean Architecture)
+
+```
+src/
+├── domain/        # Business logic
+├── application/   # Use cases
+├── infrastructure/# External concerns
+└── presentation/  # UI layer
+```
+
+## Duplicate Detection
+
+- Find exact duplicates (hash comparison)
+- Find similar files (name/content similarity)
+- Suggest consolidation
+
+## Best Practices
+
+1. **Consistent naming** - Use kebab-case or camelCase
+2. **Logical grouping** - Related files together
+3. **Flat when possible** - Avoid deep nesting
+4. **README in each folder** - Explain purpose
+5. **Regular cleanup** - Schedule organization time
+
+See [references/organization-patterns.md](references/organization-patterns.md).

package/.antigravity/skills/git-automation/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: git-automation
+description: Automated git workflows including git-pushing operations, development branch completion, and git worktrees management. Use for git operations, branch management, pull requests, and parallel development workflows.
+---
+
+# Git Automation
+
+Streamlined git workflows for efficient version control management.
+
+## When to Use
+
+- Completing development branches
+- Managing git worktrees
+- Automating git operations
+- Creating pull requests
+- Parallel feature development
+- Branch cleanup and management
+
+## Common Workflows
+
+### Finishing a Development Branch
+
+See [references/branch-finishing.md](references/branch-finishing.md)
+
+1. Ensure all changes are committed
+2. Run tests
+3. Update documentation
+4. Create pull request
+5. Clean up temporary files
+
+### Git Worktrees
+
+See [references/git-worktrees.md](references/git-worktrees.md)
+
+Work on multiple branches simultaneously:
+
+```bash
+# Create worktree for feature
+git worktree add ../myproject-feature feature/new-feature
+
+# Work in parallel
+cd ../myproject-feature
+# Make changes, commit, test
+
+# List worktrees
+git worktree list
+
+# Remove when done
+git worktree remove ../myproject-feature
+```
+
+## Git Push Automation
+
+```bash
+# Safe push with pre-checks
+git status                    # Check what's changed
+git diff --stat              # Review changes
+git push origin feature-branch
+
+# Force push (use cautiously)
+git push --force-with-lease origin feature-branch
+```
+
+## References
+
+- [Branch Finishing](references/branch-finishing.md) - Completion checklist
+- [Git Worktrees](references/git-worktrees.md) - Parallel development guide
+- [Git Helper Scripts](scripts/git-helpers.sh) - Utility scripts

package/.antigravity/skills/impact-scoring/SKILL.md

@@ -0,0 +1,219 @@
+# Impact Scoring Skill
+
+> Multi-factor scoring system to prioritize tasks for AI agents.
+
+---
+
+## 🎯 The Impact Score Formula
+
+Traditional task management sorts by a single dimension (priority).
+Impact Scoring uses **multiple factors** to calculate true task importance:
+
+```
+Impact Score = (0.25 × Complexity) + (0.25 × Risk) + (0.25 × Dependencies) + (0.25 × Urgency)
+```
+
+---
+
+## 📊 Factor Definitions
+
+### 1. Complexity (0-100)
+
+How difficult is this task?
+
+| Indicator                   | Score |
+| --------------------------- | ----- |
+| Single file change          | 20    |
+| Multiple files, same module | 40    |
+| Cross-module changes        | 60    |
+| Architectural changes       | 80    |
+| Breaking changes            | 100   |
+
+**Detection:**
+
+```typescript
+function calculateComplexity(task: Task): number {
+  const fileCount = task.files.length;
+  const moduleCount = new Set(task.files.map((f) => f.module)).size;
+  const hasBreaking = task.description.includes("BREAKING");
+
+  if (hasBreaking) return 100;
+  if (moduleCount > 3) return 80;
+  if (moduleCount > 1) return 60;
+  if (fileCount > 3) return 40;
+  return 20;
+}
+```
+
+---
+
+### 2. Risk (0-100)
+
+What could go wrong?
+
+| Area            | Score |
+| --------------- | ----- |
+| UI/styling only | 10    |
+| Business logic  | 40    |
+| Database schema | 60    |
+| Authentication  | 80    |
+| Payment/billing | 100   |
+
+**Detection:**
+
+```typescript
+function calculateRisk(task: Task): number {
+  const keywords = task.description.toLowerCase();
+
+  if (keywords.includes("payment") || keywords.includes("billing")) return 100;
+  if (keywords.includes("auth") || keywords.includes("login")) return 80;
+  if (keywords.includes("database") || keywords.includes("schema")) return 60;
+  if (keywords.includes("api") || keywords.includes("logic")) return 40;
+  return 10;
+}
+```
+
+---
+
+### 3. Dependencies (0-100)
+
+How many other tasks depend on this?
+
+| Dependents             | Score |
+| ---------------------- | ----- |
+| 0 (leaf task)          | 10    |
+| 1-2 tasks              | 30    |
+| 3-5 tasks              | 50    |
+| 6-10 tasks             | 70    |
+| 10+ tasks (bottleneck) | 100   |
+
+**Why it matters:**
+A task that blocks 10 others should be prioritized over a task that blocks none.
+
+---
+
+### 4. Urgency (0-100)
+
+How time-sensitive is this?
+
+| Deadline         | Score |
+| ---------------- | ----- |
+| No deadline      | 20    |
+| This month       | 40    |
+| This week        | 60    |
+| Tomorrow         | 80    |
+| Overdue/blocking | 100   |
+
+**Also affects urgency:**
+
+- Production bug = 100
+- Customer-reported = 80
+- Internal optimization = 20
+
+---
+
+## 🧮 Score Interpretation
+
+| Score  | Priority    | Action         |
+| ------ | ----------- | -------------- |
+| 80-100 | 🔴 CRITICAL | Do immediately |
+| 60-79  | 🟠 HIGH     | Do today       |
+| 40-59  | 🟡 MEDIUM   | Do this week   |
+| 20-39  | 🟢 LOW      | Backlog        |
+| 0-19   | ⚪ TRIVIAL  | Nice to have   |
+
+---
+
+## 📋 Example Scoring
+
+### Task: "Add Stripe payment integration"
+
+```
+Complexity: 60 (cross-module)
+Risk: 100 (payment)
+Dependencies: 50 (checkout flow depends on it)
+Urgency: 60 (this week)
+
+Impact = (0.25 × 60) + (0.25 × 100) + (0.25 × 50) + (0.25 × 60)
+       = 15 + 25 + 12.5 + 15
+       = 67.5 → 🟠 HIGH
+```
+
+### Task: "Fix button color on homepage"
+
+```
+Complexity: 20 (single file)
+Risk: 10 (UI only)
+Dependencies: 10 (nothing depends on it)
+Urgency: 20 (no deadline)
+
+Impact = (0.25 × 20) + (0.25 × 10) + (0.25 × 10) + (0.25 × 20)
+       = 5 + 2.5 + 2.5 + 5
+       = 15 → ⚪ TRIVIAL
+```
+
+---
+
+## 🤖 Integration with /do
+
+When AI receives `/do "task"`, it should:
+
+1. **Calculate Impact Score** for the task
+2. **Include in Report**:
+
+```
+┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+┃  📋 MISSION COMPLETE                           ┃
+┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┫
+┃  🎯 Task: "Add payment integration"            ┃
+┃  📊 Impact Score: 68/100 (🟠 HIGH)             ┃
+┃  🚨 Risk: HIGH (payment)                       ┃
+```
+
+3. **Use for Prioritization**:
+   - If queue has multiple tasks, sort by impact score
+   - Higher impact = execute first
+
+---
+
+## 📈 Parallel Execution Planning
+
+For multiple tasks, calculate which can run in parallel:
+
+```
+Tasks:
+  A. Setup auth (Impact: 70) → blocks B, C
+  B. User profile (Impact: 50) → needs A
+  C. Dashboard (Impact: 45) → needs A
+  D. About page (Impact: 15) → no deps
+
+Execution Plan:
+  Track 1: A → B
+  Track 2: A → C
+  Track 3: D (parallel with Track 1/2)
+
+Output:
+  Wave 1: [A, D] ← Execute in parallel
+  Wave 2: [B, C] ← After A completes
+```
+
+---
+
+## 🔗 Robot Protocol Output
+
+```json
+{
+  "task": "Add payment integration",
+  "impact": {
+    "score": 68,
+    "priority": "HIGH",
+    "factors": {
+      "complexity": 60,
+      "risk": 100,
+      "dependencies": 50,
+      "urgency": 60
+    }
+  },
+  "recommendation": "Execute immediately - high risk requires quality-guardian review"
+}
+```

package/.antigravity/skills/kaizen/SKILL.md

@@ -0,0 +1,94 @@
+---
+name: kaizen
+description: Continuous improvement methodology combining Japanese Kaizen philosophy and Lean principles. Apply systematic approaches for code quality, performance optimization, and incremental enhancements.
+---
+
+# Kaizen - Continuous Improvement
+
+Systematic continuous improvement for code quality and performance.
+
+## When to Use
+
+- Code quality improvement
+- Performance optimization
+- Technical debt reduction
+- Process enhancement
+- Team efficiency gains
+
+## PDCA Cycle
+
+### Plan
+
+- Identify improvement area
+- Set measurable goals
+- Create action plan
+
+### Do
+
+- Implement changes
+- Document approach
+- Collect data
+
+### Check
+
+- Measure results
+- Compare to goals
+- Identify gaps
+
+### Act
+
+- Standardize what works
+- Adjust what doesn't
+- Plan next cycle
+
+## Application Areas
+
+### Code Quality
+
+```javascript
+// Before (Kaizen opportunity)
+function process(data) {
+  if (data) {
+    if (data.items) {
+      return data.items.map((i) => i.value);
+    }
+  }
+  return [];
+}
+
+// After (Kaizen applied)
+function processItems(data) {
+  return data?.items?.map((item) => item.value) ?? [];
+}
+```
+
+### Performance
+
+- Profile → Identify bottlenecks → Optimize → Measure
+- Incremental improvements (aim for 1% better each week)
+
+### Technical Debt
+
+- List debts → Prioritize → Fix incrementally → Prevent new debt
+
+## Lean Principles
+
+1. **Eliminate Waste** - Remove unused code, redundant processes
+2. **Amplify Learning** - Document lessons, share knowledge
+3. **Decide Late** - Keep options open, avoid premature optimization
+4. **Deliver Fast** - Small, frequent improvements
+5. **Empower Team** - Everyone suggests improvements
+6. **Build Quality In** - Prevent issues, don't just fix them
+7. **See the Whole** - System thinking, not just parts
+
+## Kaizen Events
+
+Weekly improvement sprints:
+
+1. Pick one improvement area
+2. Dedicate time (2-4 hours)
+3. Implement change
+4. Measure impact
+5. Share learnings
+
+See [references/continuous-improvement-cycles.md](references/continuous-improvement-cycles.md) and [references/lean-methodology.md](references/lean-methodology.md) for detailed methods.