@rfxlamia/skillkit 1.1.0 → 1.2.0

package/skills/skills/been-there-done-that/references/git-commands.md

@@ -0,0 +1,132 @@
+# Git Commands Reference
+
+Used in Phase 0 of the been-there-done-that workflow.
+
+## Table of Contents
+- [Session Extraction](#session-extraction)
+- [Project Name Extraction](#project-name-extraction)
+- [Diff Stats for Selected Session](#diff-stats-for-selected-session)
+- [Branch Info](#branch-info)
+- [Stack Inference from File Extensions](#stack-inference-from-file-extensions)
+
+---
+
+## Session Extraction
+
+### Get all commits with timestamps
+
+```bash
+# Full log: unix_timestamp|hash|subject
+git -C <repo_path> log --format="%at|%H|%s" 2>/dev/null
+```
+
+Output example:
+```
+1740038400|a1b2c3d|feat: add WebSocket heartbeat
+1739952000|e4f5a6b|fix: auth token refresh
+1737360000|c7d8e9f|initial setup
+```
+
+Gap between first and second commit: `1740038400 - 1739952000 = 86400s (1 day)` → same session
+Gap between second and third commit: `1739952000 - 1737360000 = 2592000s (30 days)` → session boundary
+
+### Parse sessions (bash one-liner)
+
+```bash
+git -C <repo_path> log --format="%at|%H|%s" | awk -F'|' '
+BEGIN { session=1; prev_ts=0 }
+{
+  ts=$1; hash=$2; msg=$3
+  if (prev_ts > 0 && (prev_ts - ts) > 259200) {
+    print "---BOUNDARY---"
+    session++
+  }
+  print session "|" ts "|" hash "|" msg
+  prev_ts = ts
+}
+'
+```
+
+---
+
+## Project Name Extraction
+
+```bash
+# From remote URL (handles https and ssh formats)
+git -C <repo_path> remote get-url origin 2>/dev/null \
+  | sed 's/.*\///' \
+  | sed 's/\.git$//'
+
+# Fallback: use folder name
+basename <repo_path>
+```
+
+### Name cleaning (pseudo-code)
+
+```
+raw = output from above
+
+prefixes = ["frontend-", "backend-", "api-", "service-", "mobile-", "web-", "app-"]
+suffixes = ["-main", "-dev", "-staging", "-master", "-prod", "-v1", "-v2", "-branch"]
+
+for prefix in prefixes:
+    if raw.startswith(prefix): raw = raw[len(prefix):]
+
+for suffix in suffixes:
+    if raw.endswith(suffix): raw = raw[:-len(suffix)]
+
+clean = raw.replace("-", " ").title()
+```
+
+---
+
+## Diff Stats for Selected Session
+
+Once user confirms which session (by commit hashes):
+
+```bash
+# Files changed + insertions + deletions summary
+git -C <repo_path> diff --stat <oldest_hash>..<newest_hash> 2>/dev/null
+
+# Shortened: just the summary line
+git -C <repo_path> diff --shortstat <oldest_hash>..<newest_hash> 2>/dev/null
+# Output: "12 files changed, 847 insertions(+), 203 deletions(-)"
+
+# List of unique file extensions touched (for stack inference)
+git -C <repo_path> diff --name-only <oldest_hash>..<newest_hash> 2>/dev/null \
+  | sed 's/.*\.//' | sort -u
+```
+
+---
+
+## Branch Info
+
+```bash
+git -C <repo_path> branch --show-current 2>/dev/null
+
+# If detached HEAD, fallback:
+git -C <repo_path> rev-parse --abbrev-ref HEAD 2>/dev/null
+```
+
+---
+
+## Stack Inference from File Extensions
+
+Map file extensions to tech labels for the **Stack** field:
+
+```
+.rs          → Rust
+.ts .tsx     → TypeScript
+.js .jsx     → JavaScript
+.py          → Python
+.go          → Go
+.sql         → SQL
+.toml        → Cargo / Config
+.yaml .yml   → Config / CI
+.md          → Documentation
+.html .css   → Frontend
+Dockerfile   → Docker
+.sh          → Shell
+```
+
+Use only extensions that appear in the session diff. Deduplicate. List in order of frequency.

package/skills/skills/been-there-done-that/references/tree-insertion-logic.md

@@ -0,0 +1,145 @@
+# Tree Insertion Logic
+
+Defines how to insert a new entry at the correct position in been-there-done-that.md.
+This is not append-at-bottom. Position is determined by session.end date.
+
+## Table of Contents
+- [File Tree Structure](#file-tree-structure)
+- [Insertion Algorithm](#insertion-algorithm)
+- [Month Name Mapping](#month-name-mapping)
+- [Example: Inserting 2026-02-20](#example-inserting-2026-02-20-into-existing-file)
+- [Edge Case: Same Repo Multiple Sessions](#edge-case-same-repo-multiple-sessions-in-same-month)
+
+---
+
+## File Tree Structure
+
+```markdown
+# Been There Done That
+
+## 2026
+### January
+#### 2026-01-15 · ProjectA
+...entry content...
+
+#### 2026-01-22 · ProjectB
+...entry content...
+
+### February
+#### 2026-02-10 · ProjectC
+...entry content...
+
+## 2025
+### December
+#### 2025-12-03 · ProjectD
+...entry content...
+```
+
+**Rules (ASCENDING — oldest at top, newest at bottom):**
+- Years: ascending (2024 above 2025 above 2026)
+- Months within a year: ascending (January above December)
+- Dates within a month: ascending (01 above 15 above 28)
+- Multiple entries on same date: append BELOW existing same-date entry
+- New entries always go toward the END of their section
+
+---
+
+## Insertion Algorithm
+
+```
+INPUT: file content (string), new_entry (string), anchor_date (YYYY-MM-DD)
+
+PARSE anchor_date:
+  year  = anchor_date[0:4]   e.g. "2026"
+  month = month_name(anchor_date[5:7])  e.g. "February"
+  date  = anchor_date        e.g. "2026-02-20"
+
+STEP 1: Find or create year block
+  Search for "## <year>" in file.
+  IF NOT FOUND:
+    Scan all existing year blocks (e.g. "## 2024", "## 2025")
+    IF anchor_year > all existing years: append AFTER last year block (newer year at bottom)
+    IF anchor_year < some existing year: insert BEFORE that year block (older year stays above)
+    Add: "\n## <year>\n"
+
+STEP 2: Find or create month block within year
+  Search for "### <month>" within the year block boundaries.
+  IF NOT FOUND:
+    Find correct position within year block by month number (ascending)
+    January=1 ... December=12; insert so months are oldest-first
+    Add: "\n### <month>\n"
+
+STEP 3: Find or create date node within month
+  Search for "#### <date> ·" within the month block boundaries.
+  IF FOUND:
+    Append new_entry AFTER existing same-date entry (later on same day = lower)
+  IF NOT FOUND:
+    Find correct position within month block (dates ascending)
+    Insert new_entry at that position
+
+STEP 4: Write updated content back to file
+```
+
+---
+
+## Month Name Mapping
+
+```
+"01" → "January"    "07" → "July"
+"02" → "February"   "08" → "August"
+"03" → "March"      "09" → "September"
+"04" → "April"      "10" → "October"
+"05" → "May"        "11" → "November"
+"06" → "June"       "12" → "December"
+```
+
+---
+
+## Example: Inserting 2026-02-20 into existing file
+
+**Before:**
+```markdown
+# Been There Done That
+
+## 2026
+### January
+#### 2026-01-15 · Yagura
+...
+
+### February
+#### 2026-02-10 · WooMaps
+...
+```
+
+**After inserting 2026-02-20 · Yagura:**
+```markdown
+# Been There Done That
+
+## 2026
+### January
+#### 2026-01-15 · Yagura
+...
+
+### February
+#### 2026-02-10 · WooMaps
+...
+
+#### 2026-02-20 · Yagura    ← appended after 2026-02-10 (newer = lower)
+...new entry...
+```
+
+---
+
+## Edge Case: Same Repo, Multiple Sessions in Same Month
+
+If user logs 2 separate sessions from the same repo in the same month,
+they appear as 2 separate date entries. They are NOT merged.
+
+```markdown
+### February
+#### 2026-02-20 · Yagura    ← session B
+...
+
+#### 2026-02-05 · Yagura    ← session A (earlier)
+...
+```

package/skills/skills/coolhunter/SKILL.md

@@ -0,0 +1,270 @@
+---
+name: coolhunter
+description: >
+  Trend intelligence and cultural signal detection for emerging news and behaviors.
+  
+  USE WHEN: Researching latest news (48h), identifying cultural/tech/consumer shifts 
+  before mainstream adoption, analyzing emerging trends with advanced elicitation.
+  
+  PRIMARY TRIGGERS:
+  "coolhunt [topic]" = Full research workflow (5 steps)
+  "trend analysis" = Deep analysis with elicitation methods
+  "news scan [topic]" = Quick news gathering
+  
+  WORKFLOW: Request → Web Research → Elicitation Selection → Analysis → Report
+  
+  OUTPUT: Markdown report with headline, summary, fact-check, and behavioral analysis
+  saved to coolhunter-output/report-{datetime}/{title}.md
+category: creative
+---
+
+## Section 1: Intent Detection & Workflow Overview
+
+**Detect request type, route to appropriate workflow.**
+
+| Intent | Keywords | Route To |
+|--------|----------|----------|
+| Full coolhunt | "coolhunt", "trend", "what's new in" | Section 2 |
+| Quick scan | "news about", "latest on" | Section 2 (simplified) |
+| Analysis only | "analyze this trend" | Section 3 |
+
+### Workflow Summary
+
+```
+Step 1: RECEIVE REQUEST
+├── User provides topic (AI, crypto, business, tech, culture, etc.)
+└── Coolhunter acknowledges and prepares search strategy
+
+Step 2: WEB RESEARCH  
+├── Search latest news (prioritize last 48 hours)
+├── Gather 3-5 high-quality sources
+└── Extract key signals and emerging patterns
+
+Step 3: ELICITATION SELECTION
+├── Load: knowledge/elicitation-methods.md
+├── Analyze news context (complexity, stakeholders, risk level)
+└── Select optimal analysis pattern(s) from 50 methods
+
+Step 4: PRESENT FINDINGS
+├── Headline (Coolhunter's interpretation)
+├── Summary (concise, signal-focused)
+├── Fact-check (source verification)
+└── Behavioral analysis (culture/tech/consumer shifts)
+
+Step 5: SAVE OUTPUT
+└── Path: coolhunter-output/report-{YYYY-MM-DD-HHmm}/{title-slug}.md
+```
+
+---
+
+**For detailed execution steps:** See `references/workflow-execution.md`
+
+---
+
+## Section 2: Research Workflow
+
+### Step 2.1: Search Strategy
+
+**Search Pattern for 48-hour news:**
+```
+Query 1: "[topic] news today"
+Query 2: "[topic] latest developments 2025"  
+Query 3: "[topic] emerging trend"
+Query 4: "[topic] [specific subtopic] news"
+```
+
+**Source Quality Criteria:**
+- Prioritize: Original sources, industry publications, verified news
+- Avoid: Aggregators, outdated content, unverified claims
+- Check: Publication date within 48 hours when possible
+
+### Step 2.2: Signal Extraction
+
+**Extract from each source:**
+1. **Primary Signal**: What's the core news/change?
+2. **Stakeholders**: Who is affected or driving this?
+3. **Timeline**: When did this emerge? How fast is it moving?
+4. **Cultural Context**: What broader shift does this represent?
+
+---
+
+## Section 3: Elicitation Analysis
+
+### Method Selection Framework
+
+**Load:** `knowledge/elicitation-methods.md`
+
+**Context Analysis:**
+```
+ANALYZE the news/trend for:
+├── Complexity Level (simple → multi-faceted)
+├── Stakeholder Diversity (single → multiple groups)
+├── Risk Profile (low → high impact)
+├── Creative Potential (incremental → disruptive)
+└── Time Sensitivity (slow burn → urgent)
+```
+
+**Recommended Method Categories by Context:**
+
+| Context Type | Primary Methods | Secondary Methods |
+|--------------|-----------------|-------------------|
+| Tech disruption | Tree of Thoughts, Pre-mortem | First Principles, What If |
+| Consumer behavior | User Persona Focus Group, Stakeholder Round Table | 5 Whys, Comparative Matrix |
+| Cultural shift | Time Traveler Council, Genre Mashup | Socratic Questioning, Hindsight |
+| Business/market | Shark Tank Pitch, SCAMPER | Red Team vs Blue Team, Failure Mode |
+| Controversy/risk | Debate Club Showdown, Devil's Advocate | Self-Consistency, Expert Panel |
+
+### Analysis Output Structure
+
+```markdown
+## Analysis Method: [Selected Method Name]
+
+### Application
+[How the method was applied to this news/trend]
+
+### Key Insights
+1. [Insight from method application]
+2. [Insight from method application]
+3. [Insight from method application]
+
+### Behavioral Implications
+- Consumer: [How consumer behavior may shift]
+- Cultural: [Broader cultural meaning/impact]
+- Technology: [Tech adoption implications]
+```
+
+---
+
+## Section 4: Report Template
+
+### Output Format
+
+```markdown
+# [COOLHUNTER HEADLINE]
+> Generated: {datetime}
+> Topic: {original_request}
+> Analysis Method: {selected_method}
+
+---
+
+## 📰 News Summary
+
+**Original Headline:** [Source headline]
+**Source:** [Publication name + URL]
+**Published:** [Date/time]
+
+[2-3 paragraph summary focusing on:
+- What happened
+- Why it matters
+- Who's involved]
+
+---
+
+## ✅ Fact-Check
+
+| Claim | Verification | Source |
+|-------|--------------|--------|
+| [Key claim 1] | ✅ Verified / ⚠️ Partial / ❌ Unverified | [Source] |
+| [Key claim 2] | ... | ... |
+
+**Confidence Level:** High / Medium / Low
+**Notes:** [Any caveats or context]
+
+---
+
+## 🔮 Behavioral & Cultural Analysis
+
+### Consumer Behavior Shifts
+[Analysis of how consumer behavior may change]
+
+### Cultural Signals
+[What this trend says about broader cultural movement]
+
+### Technology Adoption Curve
+[Where this sits on adoption: innovators → early adopters → majority]
+
+### Pre-Mainstream Indicators
+[Signs this will/won't go mainstream]
+
+---
+
+## 🎯 Coolhunter's Take
+
+[1-2 paragraph synthesis with forward-looking perspective]
+
+**Watch For:** [Specific things to monitor]
+**Timeline:** [When mainstream impact expected]
+**Opportunity Window:** [For early movers]
+
+---
+
+## 📚 Sources
+1. [Full citation]
+2. [Full citation]
+```
+
+---
+
+## Section 5: File Output
+
+### Directory Structure
+
+```
+coolhunter-output/
+└── report-{YYYY-MM-DD-HHmm}/
+    └── {title-slug}.md
+```
+
+### Naming Convention
+
+**Directory:** `report-2025-12-31-1430` (date-time of generation)
+**File:** Slugified version of Coolhunter headline
+- Lowercase
+- Spaces → hyphens
+- Remove special characters
+- Max 50 characters
+
+**Example:**
+```
+coolhunter-output/
+└── report-2025-12-31-1430/
+    └── ai-agents-reshape-enterprise-software.md
+```
+
+### Save Command Pattern
+
+```bash
+# Create output directory
+mkdir -p coolhunter-output/report-$(date +%Y-%m-%d-%H%M)
+
+# Save report
+cat > "coolhunter-output/report-$(date +%Y-%m-%d-%H%M)/{slug}.md"
+```
+
+---
+
+## Quick Reference
+
+### Trigger Phrases
+- "Coolhunt [topic]" → Full 5-step workflow
+- "What's trending in [topic]" → Full workflow
+- "Latest news on [topic]" → Quick research (steps 1-2, simplified 4)
+- "Analyze this trend: [description]" → Skip to step 3-4
+
+### Method Quick-Select
+
+**For "Why is this happening?"** → 5 Whys, First Principles
+**For "What could go wrong?"** → Pre-mortem, Failure Mode
+**For "Who cares about this?"** → Stakeholder Round Table, User Persona
+**For "Is this real?"** → Self-Consistency, Expert Panel
+**For "What's next?"** → Time Traveler Council, What If Scenarios
+**For "How to capitalize?"** → SCAMPER, Reverse Engineering
+
+### Quality Gates
+
+Before saving output, verify:
+- [ ] At least 2 sources cited
+- [ ] Fact-check table completed
+- [ ] Behavioral analysis present
+- [ ] Coolhunter headline is original interpretation
+- [ ] File path follows convention

package/skills/skills/coolhunter/assets/elicitation-methods.csv

@@ -0,0 +1,51 @@
+num,category,method_name,description,output_pattern
+1,collaboration,Stakeholder Round Table,Convene multiple personas to contribute diverse perspectives - essential for requirements gathering and finding balanced solutions across competing interests,perspectives → synthesis → alignment
+2,collaboration,Expert Panel Review,Assemble domain experts for deep specialized analysis - ideal when technical depth and peer review quality are needed,expert views → consensus → recommendations
+3,collaboration,Debate Club Showdown,Two personas argue opposing positions while a moderator scores points - great for exploring controversial decisions and finding middle ground,thesis → antithesis → synthesis
+4,collaboration,User Persona Focus Group,Gather your product's user personas to react to proposals and share frustrations - essential for validating features and discovering unmet needs,reactions → concerns → priorities
+5,collaboration,Time Traveler Council,Past-you and future-you advise present-you on decisions - powerful for gaining perspective on long-term consequences vs short-term pressures,past wisdom → present choice → future impact
+6,collaboration,Cross-Functional War Room,Product manager + engineer + designer tackle a problem together - reveals trade-offs between feasibility desirability and viability,constraints → trade-offs → balanced solution
+7,collaboration,Mentor and Apprentice,Senior expert teaches junior while junior asks naive questions - surfaces hidden assumptions through teaching,explanation → questions → deeper understanding
+8,collaboration,Good Cop Bad Cop,Supportive persona and critical persona alternate - finds both strengths to build on and weaknesses to address,encouragement → criticism → balanced view
+9,collaboration,Improv Yes-And,Multiple personas build on each other's ideas without blocking - generates unexpected creative directions through collaborative building,idea → build → build → surprising result
+10,collaboration,Customer Support Theater,Angry customer and support rep roleplay to find pain points - reveals real user frustrations and service gaps,complaint → investigation → resolution → prevention
+11,advanced,Tree of Thoughts,Explore multiple reasoning paths simultaneously then evaluate and select the best - perfect for complex problems with multiple valid approaches,paths → evaluation → selection
+12,advanced,Graph of Thoughts,Model reasoning as an interconnected network of ideas to reveal hidden relationships - ideal for systems thinking and discovering emergent patterns,nodes → connections → patterns
+13,advanced,Thread of Thought,Maintain coherent reasoning across long contexts by weaving a continuous narrative thread - essential for RAG systems and maintaining consistency,context → thread → synthesis
+14,advanced,Self-Consistency Validation,Generate multiple independent approaches then compare for consistency - crucial for high-stakes decisions where verification matters,approaches → comparison → consensus
+15,advanced,Meta-Prompting Analysis,Step back to analyze the approach structure and methodology itself - valuable for optimizing prompts and improving problem-solving,current → analysis → optimization
+16,advanced,Reasoning via Planning,Build a reasoning tree guided by world models and goal states - excellent for strategic planning and sequential decision-making,model → planning → strategy
+17,competitive,Red Team vs Blue Team,Adversarial attack-defend analysis to find vulnerabilities - critical for security testing and building robust solutions,defense → attack → hardening
+18,competitive,Shark Tank Pitch,Entrepreneur pitches to skeptical investors who poke holes - stress-tests business viability and forces clarity on value proposition,pitch → challenges → refinement
+19,competitive,Code Review Gauntlet,Senior devs with different philosophies review the same code - surfaces style debates and finds consensus on best practices,reviews → debates → standards
+20,technical,Architecture Decision Records,Multiple architect personas propose and debate architectural choices with explicit trade-offs - ensures decisions are well-reasoned and documented,options → trade-offs → decision → rationale
+21,technical,Rubber Duck Debugging Evolved,Explain your code to progressively more technical ducks until you find the bug - forces clarity at multiple abstraction levels,simple → detailed → technical → aha
+22,technical,Algorithm Olympics,Multiple approaches compete on the same problem with benchmarks - finds optimal solution through direct comparison,implementations → benchmarks → winner
+23,technical,Security Audit Personas,Hacker + defender + auditor examine system from different threat models - comprehensive security review from multiple angles,vulnerabilities → defenses → compliance
+24,technical,Performance Profiler Panel,Database expert + frontend specialist + DevOps engineer diagnose slowness - finds bottlenecks across the full stack,symptoms → analysis → optimizations
+25,creative,SCAMPER Method,Apply seven creativity lenses (Substitute/Combine/Adapt/Modify/Put/Eliminate/Reverse) - systematic ideation for product innovation,S→C→A→M→P→E→R
+26,creative,Reverse Engineering,Work backwards from desired outcome to find implementation path - powerful for goal achievement and understanding endpoints,end state → steps backward → path forward
+27,creative,What If Scenarios,Explore alternative realities to understand possibilities and implications - valuable for contingency planning and exploration,scenarios → implications → insights
+28,creative,Random Input Stimulus,Inject unrelated concepts to spark unexpected connections - breaks creative blocks through forced lateral thinking,random word → associations → novel ideas
+29,creative,Exquisite Corpse Brainstorm,Each persona adds to the idea seeing only the previous contribution - generates surprising combinations through constrained collaboration,contribution → handoff → contribution → surprise
+30,creative,Genre Mashup,Combine two unrelated domains to find fresh approaches - innovation through unexpected cross-pollination,domain A + domain B → hybrid insights
+31,research,Literature Review Personas,Optimist researcher + skeptic researcher + synthesizer review sources - balanced assessment of evidence quality,sources → critiques → synthesis
+32,research,Thesis Defense Simulation,Student defends hypothesis against committee with different concerns - stress-tests research methodology and conclusions,thesis → challenges → defense → refinements
+33,research,Comparative Analysis Matrix,Multiple analysts evaluate options against weighted criteria - structured decision-making with explicit scoring,options → criteria → scores → recommendation
+34,risk,Pre-mortem Analysis,Imagine future failure then work backwards to prevent it - powerful technique for risk mitigation before major launches,failure scenario → causes → prevention
+35,risk,Failure Mode Analysis,Systematically explore how each component could fail - critical for reliability engineering and safety-critical systems,components → failures → prevention
+36,risk,Challenge from Critical Perspective,Play devil's advocate to stress-test ideas and find weaknesses - essential for overcoming groupthink,assumptions → challenges → strengthening
+37,risk,Identify Potential Risks,Brainstorm what could go wrong across all categories - fundamental for project planning and deployment preparation,categories → risks → mitigations
+38,risk,Chaos Monkey Scenarios,Deliberately break things to test resilience and recovery - ensures systems handle failures gracefully,break → observe → harden
+39,core,First Principles Analysis,Strip away assumptions to rebuild from fundamental truths - breakthrough technique for innovation and solving impossible problems,assumptions → truths → new approach
+40,core,5 Whys Deep Dive,Repeatedly ask why to drill down to root causes - simple but powerful for understanding failures,why chain → root cause → solution
+41,core,Socratic Questioning,Use targeted questions to reveal hidden assumptions and guide discovery - excellent for teaching and self-discovery,questions → revelations → understanding
+42,core,Critique and Refine,Systematic review to identify strengths and weaknesses then improve - standard quality check for drafts,strengths/weaknesses → improvements → refined
+43,core,Explain Reasoning,Walk through step-by-step thinking to show how conclusions were reached - crucial for transparency,steps → logic → conclusion
+44,core,Expand or Contract for Audience,Dynamically adjust detail level and technical depth for target audience - matches content to reader capabilities,audience → adjustments → refined content
+45,learning,Feynman Technique,Explain complex concepts simply as if teaching a child - the ultimate test of true understanding,complex → simple → gaps → mastery
+46,learning,Active Recall Testing,Test understanding without references to verify true knowledge - essential for identifying gaps,test → gaps → reinforcement
+47,philosophical,Occam's Razor Application,Find the simplest sufficient explanation by eliminating unnecessary complexity - essential for debugging,options → simplification → selection
+48,philosophical,Trolley Problem Variations,Explore ethical trade-offs through moral dilemmas - valuable for understanding values and difficult decisions,dilemma → analysis → decision
+49,retrospective,Hindsight Reflection,Imagine looking back from the future to gain perspective - powerful for project reviews,future view → insights → application
+50,retrospective,Lessons Learned Extraction,Systematically identify key takeaways and actionable improvements - essential for continuous improvement,experience → lessons → actions