opencode-skills-collection 3.1.23 → 4.0.1

package/bundled-skills/idea-autopsy/SKILL.md

@@ -0,0 +1,147 @@
+---
+name: idea-autopsy
+description: "Autopsy a business idea before you build it: kill-list check, five hard filters, a free-AI one-prompt test, live ad-market verification, and a verdict with a named kill-pattern."
+category: product
+risk: critical
+source: community
+source_repo: hafiz-actyte/idea-autopsy
+source_type: community
+date_added: "2026-07-10"
+author: hafiz-actyte
+tags: [business-ideas, idea-validation, market-research, startup, founders]
+tools: [claude, cursor, gemini]
+license: "MIT"
+license_source: "https://github.com/hafiz-actyte/idea-autopsy/blob/main/LICENSE"
+---
+
+# Idea Autopsy
+
+## Overview
+
+Turns the agent into a ruthless business-idea pathologist: instead of encouraging
+the user, it hunts for the one sentence that kills an idea — before any money or
+weeks are spent building it. Built from a real founder kill-list of 42 dead ideas
+(including a 9/10-scored idea and one that turned out to be federally illegal to
+charge for). Every autopsy ends in a hard verdict: DEAD with a named kill-pattern,
+or SURVIVED with the one cheapest test that could still kill it.
+
+## When to Use This Skill
+
+- Use when the user proposes a new business, product, or side-project idea
+- Use when the user asks "should I build X?" or "validate this idea"
+- Use when the user says "autopsy my idea"
+- Use before any market-research or build-planning task for a new venture
+
+## How It Works
+
+### Step 1: Kill-list check
+
+If the project contains a `REJECTION.md` (the user's personal kill-list), read it
+first. A NICHE match (same niche as a killed row) = verdict DEAD, cite the row,
+stop. A KILL-PATTERN match alone (new niche, previously-seen pattern) is a strong
+prior, NOT a verdict: name the matching pattern, then run the specific check for
+that pattern (the relevant filter or test below) to confirm it actually applies
+before declaring death. If no kill-list exists, ask the user for permission to create one
+with exactly this schema — this autopsy writes its first row:
+
+```markdown
+# REJECTION.md — my kill-list
+
+## Killed ideas
+
+| # | Idea/Niche | Killed (date) | Hard reason (one line) | Pattern |
+|---|-----------|---------------|------------------------|---------|
+
+## Survivors under test
+
+| Idea | Passed filters (date) | Pending test | Deadline |
+|------|----------------------|--------------|----------|
+```
+
+### Step 2: The five filters
+
+Demand evidence, not optimism. One hard NO = dead.
+
+1. **Real pain?** 2am-problem, or a nice-to-have "vitamin"?
+2. **Buyer has money?** Right now — not after the product helps them.
+3. **Proven demand?** Can the user name a single live competitor ad?
+4. **Legal to charge for?** Regulated, licensed, or illegal in the target market? Name the law if suspicion exists.
+5. **A moat?** What stops the 50th copycat next month?
+
+### Step 3: The free-AI test
+
+Try to produce the idea's core deliverable with one prompt to a frontier model.
+If one prompt produces the whole deliverable free, the verdict is DEAD with
+kill-pattern `free-AI`: the user doesn't have a product, they have a prompt.
+
+### Step 4: Live-market verification (own eyes)
+
+Desk research lies. Walk the user through the Meta Ad Library (or equivalent) with
+an explicit checklist: number of ACTIVE advertisers, age of the oldest running ad
+(90+ days = someone is paying because it works), and the three traps — zero ads
+(`wrong-channel`), a few giants (`incumbent-owned`), or hundreds of ads
+(`crowded` commodity knife-fight: demand ≠ room for you).
+
+### Step 5: Verdict
+
+```
+VERDICT: DEAD | SURVIVED
+KILL-PATTERN: <name>            (if dead)
+THE ONE SENTENCE: <the single finding that decided it>
+EVIDENCE: <2-4 hard facts with sources/numbers>
+NEXT: <if survived: the ONE cheapest test that could still kill it>
+```
+
+Then record the result — gated on consent: if `REJECTION.md` exists, or the user
+approved creating it in Step 1, append a one-line row (dead) or note the survivor
+with the date and pending test. If the user declined the kill-list, do NOT create
+or write the file — print the proposed row as text so they can save it wherever
+they prefer. The kill-list is the compounding asset — every autopsy makes the
+next one faster, but only with the user's consent.
+
+## Examples
+
+### Example 1: Idea that dies on the free-AI test
+
+```
+User: Should I build a chargeback-response kit for Shopify sellers? Ready-to-send
+      evidence packets, $29 one-time.
+Agent: Running the autopsy... Step 3 kills it: one prompt to a frontier model
+      produces a complete, usable evidence packet for free.
+      VERDICT: DEAD. KILL-PATTERN: free-AI.
+      THE ONE SENTENCE: If AI ships your whole deliverable in one prompt, you
+      don't have a product — you have a prompt.
+```
+
+### Example 2: Proven demand that still dies
+
+```
+User: An app that identifies plants from a photo — there are over a thousand
+      active ads for these, demand is proven!
+Agent: Step 4 confirms ~1,100 active advertisers — and that's the trap. The AI is
+      free, the datasets are public, everyone could build it, so everyone did.
+      VERDICT: DEAD. KILL-PATTERN: no-moat.
+      THE ONE SENTENCE: Demand tells you a market exists; it doesn't tell you
+      there's room for you.
+```
+
+## Best Practices
+
+- ✅ Demand a number, a law, a live ad, or a quote for every claim
+- ✅ Treat a fast honest kill as a WIN — it saves weeks and dollars
+- ✅ Make the user verify ad-library findings with their own eyes
+- ❌ Don't soften verdicts to be encouraging — "it depends" is a failed autopsy
+- ❌ Don't let buildability excitement skip the buyer questions; building was never the problem
+
+## Limitations
+
+- This skill does not replace legal advice, financial advice, or professional market research.
+- Kill-patterns are priors, not verdicts — a new niche matching an old pattern still deserves a fresh check that the pattern applies.
+- Ad-library checks reflect one acquisition channel; some categories legitimately sell through search or app stores.
+- Stop and ask for clarification if the idea's target market, buyer, or deliverable is unclear.
+
+## Security & Safety Notes
+
+- This skill performs no shell commands, network calls, or credential handling.
+- It modifies project state in exactly one place: creating or appending rows to the project's own `REJECTION.md` (hence `risk: critical`). It never edits other files; ask permission before creating the file on first run.
+- Web checks (ad libraries) are performed by the USER in their own browser; the skill only provides the checklist.

package/bundled-skills/it-manager-hospital/README.md

@@ -34,4 +34,4 @@ The skill will provide the core strategic answer and then **ask** if you want to
 - `examples/hospital-management-scenarios.md`: Crisis in ICU, Audit Prep, and AI Roadmaps.
 
 ---
-*Powered by Antigravity Skills Ecosystem.*
+*Powered by Agentic Skills Ecosystem.*

package/bundled-skills/it-manager-pro/README.md

@@ -38,4 +38,4 @@ To keep responses concise and high-value, the skill will provide a core answer f
 - `examples/`: Practical scenarios for crisis management, budgeting, and strategy.
 
 ---
-*Powered by Antigravity Skills Ecosystem.*
+*Powered by Agentic Skills Ecosystem.*

package/bundled-skills/itil-expert/README.md

@@ -36,4 +36,4 @@ Trigger the skill using phrases like:
 - Compliance & Sustainability Officers
 
 ---
-*Created as part of the Antigravity Skills Ecosystem.*
+*Created as part of the Agentic Skills Ecosystem.*

package/bundled-skills/langgraph/SKILL.md

@@ -112,7 +112,7 @@ def search(query: str) -> str:
 @tool
 def calculator(expression: str) -> str:
     """Evaluate a math expression."""
-    return str(eval(expression))
+    return str(safe_math_evaluator(expression))
 
 tools = [search, calculator]
 

package/bundled-skills/linkedin-content-generator/SKILL.md

@@ -55,7 +55,7 @@ formats across every session.
 
 **Python 3.8 or later** must be available in your shell path.
 
-The skill is self-contained. Install it from the antigravity skills library:
+The skill is self-contained. Install it from the Agentic Awesome Skills library:
 
 ```bash
 # Install via antigravity CLI (recommended)

package/bundled-skills/lint-and-validate/scripts/lint_runner.py

@@ -30,7 +30,7 @@ def detect_project_type(project_path: Path) -> dict:
         "type": "unknown",
         "linters": []
     }
-    
+
     # Node.js project
     package_json = project_path / "package.json"
     if package_json.exists():
@@ -39,31 +39,31 @@ def detect_project_type(project_path: Path) -> dict:
             pkg = json.loads(package_json.read_text(encoding='utf-8'))
             scripts = pkg.get("scripts", {})
             deps = {**pkg.get("dependencies", {}), **pkg.get("devDependencies", {})}
-            
+
             # Check for lint script
             if "lint" in scripts:
                 result["linters"].append({"name": "npm lint", "cmd": ["npm", "run", "lint"]})
             elif "eslint" in deps:
                 result["linters"].append({"name": "eslint", "cmd": ["npx", "eslint", "."]})
-            
+
             # Check for TypeScript
             if "typescript" in deps or (project_path / "tsconfig.json").exists():
                 result["linters"].append({"name": "tsc", "cmd": ["npx", "tsc", "--noEmit"]})
-                
+
         except:
             pass
-    
+
     # Python project
     if (project_path / "pyproject.toml").exists() or (project_path / "requirements.txt").exists():
         result["type"] = "python"
-        
+
         # Check for ruff
         result["linters"].append({"name": "ruff", "cmd": ["ruff", "check", "."]})
-        
+
         # Check for mypy
         if (project_path / "mypy.ini").exists() or (project_path / "pyproject.toml").exists():
             result["linters"].append({"name": "mypy", "cmd": ["mypy", "."]})
-    
+
     return result
 
 
@@ -75,7 +75,7 @@ def run_linter(linter: dict, cwd: Path) -> dict:
         "output": "",
         "error": ""
     }
-    
+
     try:
         proc = subprocess.run(
             linter["cmd"],
@@ -86,36 +86,36 @@ def run_linter(linter: dict, cwd: Path) -> dict:
             errors='replace',
             timeout=120
         )
-        
+
         result["output"] = proc.stdout[:2000] if proc.stdout else ""
         result["error"] = proc.stderr[:500] if proc.stderr else ""
         result["passed"] = proc.returncode == 0
-        
+
     except FileNotFoundError:
         result["error"] = f"Command not found: {linter['cmd'][0]}"
     except subprocess.TimeoutExpired:
         result["error"] = "Timeout after 120s"
     except Exception as e:
         result["error"] = str(e)
-    
+
     return result
 
 
 def main():
     project_path = Path(sys.argv[1] if len(sys.argv) > 1 else ".").resolve()
-    
+
     print(f"\n{'='*60}")
     print(f"[LINT RUNNER] Unified Linting")
     print(f"{'='*60}")
     print(f"Project: {project_path}")
     print(f"Time: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
-    
+
     # Detect project type
     project_info = detect_project_type(project_path)
     print(f"Type: {project_info['type']}")
     print(f"Linters: {len(project_info['linters'])}")
     print("-"*60)
-    
+
     if not project_info["linters"]:
         print("No linters found for this project type.")
         output = {
@@ -128,16 +128,16 @@ def main():
         }
         print(json.dumps(output, indent=2))
         sys.exit(0)
-    
+
     # Run each linter
     results = []
     all_passed = True
-    
+
     for linter in project_info["linters"]:
         print(f"\nRunning: {linter['name']}...")
         result = run_linter(linter, project_path)
         results.append(result)
-        
+
         if result["passed"]:
             print(f"  [PASS] {linter['name']}")
         else:
@@ -145,16 +145,16 @@ def main():
             if result["error"]:
                 print(f"  Error: {result['error'][:200]}")
             all_passed = False
-    
+
     # Summary
     print("\n" + "="*60)
     print("SUMMARY")
     print("="*60)
-    
+
     for r in results:
         icon = "[PASS]" if r["passed"] else "[FAIL]"
         print(f"{icon} {r['name']}")
-    
+
     output = {
         "script": "lint_runner",
         "project": str(project_path),
@@ -162,9 +162,9 @@ def main():
         "checks": results,
         "passed": all_passed
     }
-    
+
     print("\n" + json.dumps(output, indent=2))
-    
+
     sys.exit(0 if all_passed else 1)
 
 

package/bundled-skills/lint-and-validate/scripts/type_coverage.py

@@ -20,36 +20,36 @@ def check_typescript_coverage(project_path: Path) -> dict:
     issues = []
     passed = []
     stats = {'any_count': 0, 'untyped_functions': 0, 'total_functions': 0}
-    
+
     ts_files = list(project_path.rglob("*.ts")) + list(project_path.rglob("*.tsx"))
     ts_files = [f for f in ts_files if 'node_modules' not in str(f) and '.d.ts' not in str(f)]
-    
+
     if not ts_files:
         return {'type': 'typescript', 'files': 0, 'passed': [], 'issues': ["[!] No TypeScript files found"], 'stats': stats}
-    
+
     for file_path in ts_files[:30]:  # Limit
         try:
             content = file_path.read_text(encoding='utf-8', errors='ignore')
-            
+
             # Count 'any' usage
             any_matches = re.findall(r':\s*any\b', content)
             stats['any_count'] += len(any_matches)
-            
+
             # Find functions without return types
             # function name(params) { - no return type
             untyped = re.findall(r'function\s+\w+\s*\([^)]*\)\s*{', content)
             # Arrow functions without types: const fn = (x) => or (x) =>
             untyped += re.findall(r'=\s*\([^:)]*\)\s*=>', content)
             stats['untyped_functions'] += len(untyped)
-            
+
             # Count typed functions
             typed = re.findall(r'function\s+\w+\s*\([^)]*\)\s*:\s*\w+', content)
             typed += re.findall(r':\s*\([^)]*\)\s*=>\s*\w+', content)
             stats['total_functions'] += len(typed) + len(untyped)
-            
+
         except Exception:
             continue
-    
+
     # Analyze results
     if stats['any_count'] == 0:
         passed.append("[OK] No 'any' types found")
@@ -57,7 +57,7 @@ def check_typescript_coverage(project_path: Path) -> dict:
         issues.append(f"[!] {stats['any_count']} 'any' types found (acceptable)")
     else:
         issues.append(f"[X] {stats['any_count']} 'any' types found (too many)")
-    
+
     if stats['total_functions'] > 0:
         typed_ratio = (stats['total_functions'] - stats['untyped_functions']) / stats['total_functions'] * 100
         if typed_ratio >= 80:
@@ -66,9 +66,9 @@ def check_typescript_coverage(project_path: Path) -> dict:
             issues.append(f"[!] Type coverage: {typed_ratio:.0f}% (improve)")
         else:
             issues.append(f"[X] Type coverage: {typed_ratio:.0f}% (too low)")
-    
+
     passed.append(f"[OK] Analyzed {len(ts_files)} TypeScript files")
-    
+
     return {'type': 'typescript', 'files': len(ts_files), 'passed': passed, 'issues': issues, 'stats': stats}
 
 def check_python_coverage(project_path: Path) -> dict:
@@ -76,35 +76,35 @@ def check_python_coverage(project_path: Path) -> dict:
     issues = []
     passed = []
     stats = {'untyped_functions': 0, 'typed_functions': 0, 'any_count': 0}
-    
+
     py_files = list(project_path.rglob("*.py"))
     py_files = [f for f in py_files if not any(x in str(f) for x in ['venv', '__pycache__', '.git', 'node_modules'])]
-    
+
     if not py_files:
         return {'type': 'python', 'files': 0, 'passed': [], 'issues': ["[!] No Python files found"], 'stats': stats}
-    
+
     for file_path in py_files[:30]:  # Limit
         try:
             content = file_path.read_text(encoding='utf-8', errors='ignore')
-            
+
             # Count Any usage
             any_matches = re.findall(r':\s*Any\b', content)
             stats['any_count'] += len(any_matches)
-            
+
             # Find functions with type hints
             typed_funcs = re.findall(r'def\s+\w+\s*\([^)]*:[^)]+\)', content)
             typed_funcs += re.findall(r'def\s+\w+\s*\([^)]*\)\s*->', content)
             stats['typed_functions'] += len(typed_funcs)
-            
+
             # Find functions without type hints
             all_funcs = re.findall(r'def\s+\w+\s*\(', content)
             stats['untyped_functions'] += len(all_funcs) - len(typed_funcs)
-            
+
         except Exception:
             continue
-    
+
     total = stats['typed_functions'] + stats['untyped_functions']
-    
+
     if total > 0:
         typed_ratio = stats['typed_functions'] / total * 100
         if typed_ratio >= 70:
@@ -113,42 +113,42 @@ def check_python_coverage(project_path: Path) -> dict:
             issues.append(f"[!] Type hints coverage: {typed_ratio:.0f}%")
         else:
             issues.append(f"[X] Type hints coverage: {typed_ratio:.0f}% (add type hints)")
-    
+
     if stats['any_count'] == 0:
         passed.append("[OK] No 'Any' types found")
     elif stats['any_count'] <= 3:
         issues.append(f"[!] {stats['any_count']} 'Any' types found")
     else:
         issues.append(f"[X] {stats['any_count']} 'Any' types found")
-    
+
     passed.append(f"[OK] Analyzed {len(py_files)} Python files")
-    
+
     return {'type': 'python', 'files': len(py_files), 'passed': passed, 'issues': issues, 'stats': stats}
 
 def main():
     target = sys.argv[1] if len(sys.argv) > 1 else "."
     project_path = Path(target)
-    
+
     print("\n" + "=" * 60)
     print("  TYPE COVERAGE CHECKER")
     print("=" * 60 + "\n")
-    
+
     results = []
-    
+
     # Check TypeScript
     ts_result = check_typescript_coverage(project_path)
     if ts_result['files'] > 0:
         results.append(ts_result)
-    
+
     # Check Python
     py_result = check_python_coverage(project_path)
     if py_result['files'] > 0:
         results.append(py_result)
-    
+
     if not results:
         print("[!] No TypeScript or Python files found.")
         sys.exit(0)
-    
+
     # Print results
     critical_issues = 0
     for result in results:
@@ -160,7 +160,7 @@ def main():
             print(f"  {item}")
             if item.startswith("[X]"):
                 critical_issues += 1
-    
+
     print("\n" + "=" * 60)
     if critical_issues == 0:
         print("[OK] TYPE COVERAGE: ACCEPTABLE")

package/bundled-skills/logic-lens/SKILL.md

@@ -47,7 +47,7 @@ Logic Lens uses Claude Code's reasoning capabilities to:
 # Search: "logic-lens" in Claude Code > Extensions
 
 # Or install via NPX (Antigravity)
-npx antigravity-awesome-skills --claude
+npx agentic-awesome-skills --claude
 # Then invoke: @logic-lens
 ```
 

package/bundled-skills/lore/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 TheaDust
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.