@smicolon/ai-kit 0.1.0 → 0.1.1

package/packs/failure-log/README.md

@@ -0,0 +1,168 @@
+# failure-log
+
+Persistent failure memory system that tracks mistakes and prevents repeating them across sessions.
+
+## Overview
+
+This plugin creates a "learning from mistakes" system for each project. Failures are logged to a local file and automatically injected into context at the start of each session, ensuring the agent never repeats the same mistakes.
+
+## Features
+
+- **Persistent Memory**: Failures survive across sessions in `.claude/failure-log.local.md`
+- **Auto-Injection**: Condensed failure summary injected on every prompt
+- **Semi-Automatic Capture**: Hooks detect potential failures and prompt for logging
+- **Manual Logging**: `/failure-add` command for explicit failure entry
+- **Categorized Entries**: Organize by imports, security, testing, architecture, conventions
+- **Project-Specific**: Each project maintains its own failure log
+
+## Installation
+
+```bash
+/plugin install failure-log
+```
+
+## Usage
+
+### Adding Failures
+
+**Manual (recommended for important mistakes):**
+```
+/failure-add Used relative imports instead of alias pattern in Django
+```
+
+**Semi-automatic:**
+When the PostToolUse hook detects a potential mistake (error, correction), it will prompt whether to log it.
+
+### Viewing Failures
+
+```
+/failure-list              # Show all failures
+/failure-list imports      # Filter by category
+/failure-list security     # Filter by category
+```
+
+### Categories
+
+| Category | Description |
+|----------|-------------|
+| `imports` | Wrong import patterns |
+| `security` | Missing security checks |
+| `testing` | Wrong test approaches |
+| `architecture` | Structural mistakes |
+| `conventions` | Code style violations |
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────┐
+│                 FAILURE LOG FLOW                │
+├─────────────────────────────────────────────────┤
+│                                                 │
+│  1. CAPTURE                                     │
+│     - Manual: /failure-add "description"        │
+│     - Auto: Hook detects errors → prompts       │
+│                                                 │
+│  2. STORE                                       │
+│     - .claude/failure-log.local.md              │
+│     - YAML frontmatter + Markdown entries       │
+│                                                 │
+│  3. INJECT                                      │
+│     - UserPromptSubmit hook reads log           │
+│     - Condensed summary added to context        │
+│     - "AVOID THESE KNOWN MISTAKES: ..."         │
+│                                                 │
+└─────────────────────────────────────────────────┘
+```
+
+## File Format
+
+The failure log is stored at `.claude/failure-log.local.md`:
+
+```markdown
+---
+enabled: true
+last_updated: 2026-01-01T10:30:00Z
+---
+
+# Failure Log
+
+## Pattern Mistakes
+
+### [2026-01-01] Wrong import pattern in Django
+**Context:** Writing user service
+**Mistake:** Used `from users.models import User`
+**Correct:** Use `import users.models as _users_models`
+**Category:** imports
+
+## Failed Approaches
+
+### [2026-01-01] Mocking database directly
+**Context:** Writing unit tests
+**What failed:** Mocking ORM breaks fixtures
+**Better approach:** Use factory_boy
+**Category:** testing
+```
+
+## Configuration
+
+### Disabling Injection
+
+To temporarily disable failure injection without deleting the log:
+
+```markdown
+---
+enabled: false
+last_updated: 2026-01-01T10:30:00Z
+---
+```
+
+### Gitignore
+
+Add to your `.gitignore`:
+
+```
+.claude/*.local.md
+```
+
+## Components
+
+| Component | Purpose |
+|-----------|---------|
+| `hooks/hooks.json` | Hook configuration |
+| `hooks/scripts/inject-failures.sh` | Reads log, outputs summary |
+| `skills/failure-log-manager/` | Knowledge about log format |
+| `commands/failure-add.md` | Manual failure entry |
+| `commands/failure-list.md` | View logged failures |
+
+## Best Practices
+
+### What to Log
+
+- Pattern violations that recur
+- Non-obvious mistakes
+- Project-specific conventions
+- Security-related errors
+- Architecture decisions that failed
+
+### What NOT to Log
+
+- One-time typos
+- Linting errors (already caught)
+- Generic programming mistakes
+- Non-actionable failures
+
+## Troubleshooting
+
+### Failures Not Injecting
+
+1. Check file exists: `.claude/failure-log.local.md`
+2. Verify `enabled: true` in frontmatter
+3. Restart Claude Code (hooks load at session start)
+
+### Hook Not Detecting Failures
+
+The PostToolUse hook only triggers on Write/Edit operations. For other failures, use `/failure-add` manually.
+
+## License
+
+MIT

package/packs/failure-log/commands/failure-add.md

@@ -0,0 +1,106 @@
+---
+name: failure-add
+description: Add a failure or mistake to the project's failure log for future reference
+argument-hint: "[description of mistake]"
+allowed-tools: ["Read", "Write", "AskUserQuestion"]
+---
+
+# Add Failure to Log
+
+Record a mistake to prevent repeating it in future sessions.
+
+## Steps
+
+1. **Parse the user's input** to understand the failure:
+   - What was the context?
+   - What was the mistake?
+   - What is the correct approach?
+
+2. **Determine failure type**:
+   - **Pattern Mistake**: Recurring pattern violation (imports, naming, structure)
+   - **Failed Approach**: An approach that doesn't work
+
+3. **Determine category** (ask if unclear):
+   - `imports` - Wrong import patterns
+   - `security` - Missing security checks
+   - `testing` - Wrong test approaches
+   - `architecture` - Structural mistakes
+   - `conventions` - Code style violations
+
+4. **Check if failure log exists** at `.claude/failure-log.local.md`:
+   - If not, create it with the template below
+   - If yes, read existing content
+
+5. **Add the new failure entry**:
+   - Update `last_updated` timestamp in frontmatter
+   - Add entry under appropriate section (Pattern Mistakes or Failed Approaches)
+   - Place newest entries first
+
+6. **Confirm** the failure was logged with a brief summary
+
+## Template for New File
+
+```markdown
+---
+enabled: true
+last_updated: [CURRENT_ISO_TIMESTAMP]
+---
+
+# Failure Log
+
+This log tracks mistakes to prevent repeating them across sessions.
+
+## Pattern Mistakes
+
+[NEW_ENTRY_HERE]
+
+## Failed Approaches
+
+_No failed approaches logged yet._
+```
+
+## Entry Format
+
+### For Pattern Mistakes
+
+```markdown
+### [YYYY-MM-DD] Brief descriptive title
+**Context:** What was being done when the mistake occurred
+**Mistake:** The specific error or violation
+**Correct:** The correct approach to use instead
+**Category:** [category]
+```
+
+### For Failed Approaches
+
+```markdown
+### [YYYY-MM-DD] Brief descriptive title
+**Context:** What was being attempted
+**What failed:** Why the approach didn't work
+**Better approach:** What works instead
+**Category:** [category]
+```
+
+## Examples
+
+**User says:** "Log that I used relative imports in Django"
+
+**Entry created:**
+```markdown
+### [2026-01-01] Used relative imports in Django service
+**Context:** Writing business logic in user service
+**Mistake:** Used `from .models import User` relative import
+**Correct:** Use `import users.models as _users_models` with alias pattern
+**Category:** imports
+```
+
+**User says:** "Remember that mocking the database directly doesn't work"
+
+**Entry created:**
+```markdown
+### [2026-01-01] Mocking database directly in tests
+**Context:** Writing unit tests for user creation
+**What failed:** Mocking `User.objects.create` breaks ORM behavior and fixtures
+**Better approach:** Use factory_boy to create test data, mock external services only
+**Category:** testing
+```

package/packs/failure-log/commands/failure-list.md

@@ -0,0 +1,89 @@
+---
+name: failure-list
+description: View all logged failures and mistakes for this project
+argument-hint: "[category]"
+allowed-tools: ["Read"]
+---
+
+# List Failures
+
+Display failures from the project's failure log.
+
+## Steps
+
+1. **Check if failure log exists** at `.claude/failure-log.local.md`:
+   - If not, inform user: "No failure log found. Use `/failure-add` to start logging mistakes."
+
+2. **Read the failure log** file
+
+3. **Parse optional category filter** from arguments:
+   - If category provided, filter entries by that category
+   - Valid categories: `imports`, `security`, `testing`, `architecture`, `conventions`
+   - If no category, show all entries
+
+4. **Display failures** in a readable format:
+
+## Output Format
+
+```
+📋 Failure Log Summary
+━━━━━━━━━━━━━━━━━━━━━
+
+Total entries: X
+Last updated: YYYY-MM-DD
+
+## Pattern Mistakes (X entries)
+
+1. [2026-01-01] Brief title
+   Category: imports
+   Mistake: What went wrong
+   Correct: What to do instead
+
+2. [2026-01-01] Another title
+   ...
+
+## Failed Approaches (X entries)
+
+1. [2026-01-01] Brief title
+   Category: testing
+   What failed: Why it didn't work
+   Better: What works instead
+
+━━━━━━━━━━━━━━━━━━━━━
+```
+
+## Filtered Output
+
+When category is provided:
+
+```
+📋 Failure Log: imports
+━━━━━━━━━━━━━━━━━━━━━
+
+Showing X entries for category: imports
+
+1. [2026-01-01] Wrong import pattern
+   Mistake: Used relative imports
+   Correct: Use alias pattern
+
+...
+```
+
+## Empty Log
+
+If log exists but has no entries:
+
+```
+📋 Failure Log
+━━━━━━━━━━━━━━
+
+No failures logged yet.
+
+Use `/failure-add "description"` to log a mistake.
+```
+
+## Usage Examples
+
+- `/failure-list` - Show all failures
+- `/failure-list imports` - Show only import-related failures
+- `/failure-list security` - Show only security-related failures

package/packs/failure-log/hooks/hooks.json

@@ -0,0 +1,16 @@
+{
+  "description": "Failure log hooks for injecting learned lessons at session start",
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/scripts/inject-failures.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}

package/packs/failure-log/hooks/scripts/inject-failures.sh

@@ -0,0 +1,64 @@
+#!/bin/bash
+set -euo pipefail
+
+# Failure log injection script
+# Reads .claude/failure-log.local.md and injects a condensed summary into context
+
+FAILURE_LOG=".claude/failure-log.local.md"
+
+# Quick exit if no failure log exists
+if [[ ! -f "$FAILURE_LOG" ]]; then
+  exit 0
+fi
+
+# Parse YAML frontmatter
+FRONTMATTER=$(sed -n '/^---$/,/^---$/{ /^---$/d; p; }' "$FAILURE_LOG" 2>/dev/null || echo "")
+
+# Check if enabled (default to true if not specified)
+ENABLED=$(echo "$FRONTMATTER" | grep '^enabled:' | sed 's/enabled: *//' | tr -d ' ' || echo "true")
+if [[ "$ENABLED" == "false" ]]; then
+  exit 0
+fi
+
+# Extract markdown body (everything after the second ---)
+BODY=$(awk '/^---$/{i++; next} i>=2' "$FAILURE_LOG" 2>/dev/null || echo "")
+
+# Count failures (lines starting with ###)
+FAILURE_COUNT=$(echo "$BODY" | grep -c '^### ' || echo "0")
+
+if [[ "$FAILURE_COUNT" -eq 0 ]]; then
+  exit 0
+fi
+
+# Extract failure summaries (condensed format)
+# Get the mistake line from each failure entry
+FAILURES_SUMMARY=$(echo "$BODY" | awk '
+  /^### / {
+    # Get the failure title (date and description)
+    title = $0
+    gsub(/^### /, "", title)
+  }
+  /^\*\*Mistake:\*\*/ {
+    mistake = $0
+    gsub(/^\*\*Mistake:\*\* */, "", mistake)
+    if (title != "") {
+      print "- " title ": " mistake
+      title = ""
+    }
+  }
+')
+
+# If no structured failures found, try simpler extraction
+if [[ -z "$FAILURES_SUMMARY" ]]; then
+  # Just extract headers as reminders
+  FAILURES_SUMMARY=$(echo "$BODY" | grep '^### ' | sed 's/^### /- /' | head -20)
+fi
+
+# Output system message with failure context
+if [[ -n "$FAILURES_SUMMARY" ]]; then
+  cat << EOF
+{
+  "systemMessage": "⚠️ FAILURE LOG ACTIVE ($FAILURE_COUNT known mistakes to avoid):\n$FAILURES_SUMMARY\n\nReview full log at .claude/failure-log.local.md if needed."
+}
+EOF
+fi

package/packs/failure-log/skills/failure-log-manager/SKILL.md

@@ -0,0 +1,164 @@
+---
+name: failure-log-manager
+description: This skill should be used when the user asks to "log a failure", "remember this mistake", "add to failure log", "what mistakes to avoid", "check failure log", or when a mistake is detected that should be recorded for future reference. Manages persistent failure memory.
+---
+
+# Failure Log Manager
+
+Manages the persistent failure log at `.claude/failure-log.local.md` to prevent repeating mistakes across sessions.
+
+## Activation Triggers
+
+This skill activates when:
+- User asks to log a mistake or failure
+- A pattern violation or error is detected
+- User wants to review known mistakes
+- Adding, viewing, or managing failure entries
+
+## File Location
+
+```
+.claude/failure-log.local.md
+```
+
+This file is project-specific and should be in `.gitignore`.
+
+## File Format
+
+```markdown
+---
+enabled: true
+last_updated: 2026-01-01T10:30:00Z
+---
+
+# Failure Log
+
+## Pattern Mistakes
+
+### [YYYY-MM-DD] Brief title
+**Context:** What was being done
+**Mistake:** What went wrong
+**Correct:** What should be done instead
+**Category:** imports|security|testing|architecture|conventions
+
+## Failed Approaches
+
+### [YYYY-MM-DD] Brief title
+**Context:** What was being attempted
+**What failed:** Why the approach didn't work
+**Better approach:** What works instead
+**Category:** imports|security|testing|architecture|conventions
+```
+
+## Categories
+
+| Category | Description | Examples |
+|----------|-------------|----------|
+| `imports` | Wrong import patterns | Relative imports, missing aliases |
+| `security` | Missing security checks | No permission classes, exposed secrets |
+| `testing` | Wrong test approaches | unittest vs pytest, missing fixtures |
+| `architecture` | Structural mistakes | Wrong file locations, missing layers |
+| `conventions` | Code style violations | Naming, formatting, patterns |
+
+## Adding Failures
+
+### Pattern Mistake Entry
+
+For recurring pattern violations:
+
+```markdown
+### [2026-01-01] Wrong import pattern in Django
+**Context:** Writing user service
+**Mistake:** Used `from users.models import User` instead of alias pattern
+**Correct:** Use `import users.models as _users_models`
+**Category:** imports
+```
+
+### Failed Approach Entry
+
+For approaches that don't work:
+
+```markdown
+### [2026-01-01] Tried unittest instead of pytest
+**Context:** Writing tests for user service
+**What failed:** unittest assertions don't integrate with Django fixtures
+**Better approach:** Use pytest with factory_boy for test data
+**Category:** testing
+```
+
+## Reading Failures
+
+To check the failure log:
+
+1. Read `.claude/failure-log.local.md`
+2. Parse entries under each section
+3. Use category to filter relevant failures
+4. Apply lessons to current task
+
+## Creating Initial Log
+
+If no failure log exists, create with template:
+
+```markdown
+---
+enabled: true
+last_updated: CURRENT_ISO_TIMESTAMP
+---
+
+# Failure Log
+
+This log tracks mistakes to prevent repeating them across sessions.
+
+## Pattern Mistakes
+
+_No pattern mistakes logged yet._
+
+## Failed Approaches
+
+_No failed approaches logged yet._
+```
+
+## Updating Log
+
+When adding a new failure:
+
+1. Read existing file
+2. Update `last_updated` in frontmatter
+3. Add new entry under appropriate section (Pattern Mistakes or Failed Approaches)
+4. Maintain chronological order (newest first)
+5. Write updated file
+
+## Best Practices
+
+### What to Log
+
+Log failures that are:
+- Likely to recur (pattern-based mistakes)
+- Non-obvious (not caught by linting)
+- Project-specific (conventions unique to codebase)
+- Costly to repeat (security, architecture)
+
+### What NOT to Log
+
+Skip failures that are:
+- One-time typos
+- Already caught by linting/tests
+- Generic programming errors
+- Not actionable
+
+### Entry Quality
+
+Each entry must have:
+- Clear date for context
+- Specific mistake description
+- Actionable correct approach
+- Appropriate category
+
+## Integration with Hooks
+
+The `UserPromptSubmit` hook automatically injects a condensed summary of failures into context. The summary includes:
+- Total failure count
+- One-line summary per failure
+- Reference to full log file
+
+This ensures failures are always visible without overwhelming context.

package/packs/flutter/.claude-plugin/plugin.json

@@ -0,0 +1,10 @@
+{
+  "name": "flutter",
+  "version": "0.1.0",
+  "description": "Flutter development plugin with Fastlane automation, store publishing, and architecture patterns",
+  "author": {
+    "name": "Smicolon",
+    "email": "dev@smicolon.com"
+  },
+  "keywords": ["flutter", "fastlane", "ios", "android", "app-store", "google-play", "mobile"]
+}

package/packs/flutter/CHANGELOG.md

@@ -0,0 +1,19 @@
+# Changelog
+
+All notable changes to the smi-flutter plugin will be documented in this file.
+
+## [Unreleased]
+
+### Changed
+- Renamed from `smi-flutter` to `flutter` as part of ai-kit migration
+- Moved from `plugins/smi-flutter/` to `packs/flutter/`
+
+## [0.1.0] - 2025-01-02
+
+### Added
+- Initial release (experimental)
+- 3 agents: flutter-architect, flutter-builder, release-manager
+- 5 commands: flutter-build, flutter-test, flutter-deploy, fastlane-setup, signing-setup
+- 3 skills: flutter-architecture, fastlane-knowledge, store-publishing
+- Fastlane automation for iOS and Android
+- App Store and Play Store publishing support