agentlaunch-templates 0.2.2 → 0.2.4

package/dist/claude-context.d.ts

@@ -1,20 +1,14 @@
 /**
- * claude-context.ts — Claude Code rules and skills for scaffolded projects
+ * claude-context.ts — Complete Claude Code context for scaffolded projects
  *
- * These files are copied to every new agent project so Claude has full context
- * to help build, deploy, and tokenize agents.
+ * Everything a third-party developer needs to create, deploy, and tokenize
+ * agents on the AgentLaunch platform with Claude Code assistance.
  */
-export declare const RULES: {
-    "agentlaunch.md": string;
-    "agentverse.md": string;
-    "uagent-patterns.md": string;
-};
-export declare const SKILLS: {
-    "build-agent/SKILL.md": string;
-    "deploy/SKILL.md": string;
-    "tokenize/SKILL.md": string;
-    "status/SKILL.md": string;
-    "market/SKILL.md": string;
-};
+export declare const RULES: Record<string, string>;
+export declare const SKILLS: Record<string, string>;
+export declare const DOCS: Record<string, string>;
+export declare const EXAMPLES: Record<string, string>;
 export declare function buildPackageJson(name: string): string;
+export declare const CURSOR_MCP_CONFIG: string;
+export declare const CURSOR_RULES = "# AgentLaunch Agent Project\n\nThis is an AgentLaunch agent project. Use the MCP tools to build, deploy, and tokenize.\n\n## Quick Commands\n\n- `npm run deploy` - Deploy to Agentverse\n- `npm run tokenize` - Create token + handoff link\n- `npm run status` - Check status\n\n## Key Files\n\n- `agent.py` - Your agent code (edit this!)\n- `CLAUDE.md` - Full context for Claude\n- `docs/` - SDK, CLI, MCP documentation\n- `examples/` - Working code samples\n\n## Platform Constants\n\n- Deploy fee: 120 FET\n- Graduation: 30,000 FET liquidity\n- Trading fee: 2% to protocol treasury\n";
 //# sourceMappingURL=claude-context.d.ts.map

package/dist/claude-context.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-context.d.ts","sourceRoot":"","sources":["../src/claude-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,KAAK;;;;CA6JjB,CAAC;AAMF,eAAO,MAAM,MAAM;;;;;;CAgJlB,CAAC;AAMF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAqBrD"}
+{"version":3,"file":"claude-context.d.ts","sourceRoot":"","sources":["../src/claude-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,eAAO,MAAM,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkKxC,CAAC;AAMF,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAyEzC,CAAC;AAMF,eAAO,MAAM,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CA4HvC,CAAC;AAMF,eAAO,MAAM,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAkQ3C,CAAC;AAMF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAsBrD;AAMD,eAAO,MAAM,iBAAiB,QAWtB,CAAC;AAET,eAAO,MAAM,YAAY,2kBAsBxB,CAAC"}

package/dist/claude-context.js

@@ -1,23 +1,20 @@
 /**
- * claude-context.ts — Claude Code rules and skills for scaffolded projects
+ * claude-context.ts — Complete Claude Code context for scaffolded projects
  *
- * These files are copied to every new agent project so Claude has full context
- * to help build, deploy, and tokenize agents.
+ * Everything a third-party developer needs to create, deploy, and tokenize
+ * agents on the AgentLaunch platform with Claude Code assistance.
  */
 // ---------------------------------------------------------------------------
-// Rules
+// Rules — Claude's coding guidelines
 // ---------------------------------------------------------------------------
 export const RULES = {
     "agentlaunch.md": `# AgentLaunch Platform Rules
 
-When working with AgentLaunch tokens and the platform API:
-
 ## Constants (from smart contracts -- never change)
 
 - Deploy fee: 120 FET (read from contract, can change via multi-sig)
 - Graduation: 30,000 FET liquidity -> auto DEX listing
-- Trading fee: 2% -> 100% to REVENUE_ACCOUNT (protocol treasury)
-- NO creator fee. The 2% fee has NO split. All to protocol.
+- Trading fee: 2% -> 100% to protocol treasury (NO creator fee)
 - Total buy supply: 800,000,000 tokens per token
 - Default chain: BSC (testnet=97, mainnet=56)
 
@@ -25,19 +22,11 @@ When working with AgentLaunch tokens and the platform API:
 
 - Use \`X-API-Key\` header with Agentverse API key
 - Key is read from \`.env\` AGENTVERSE_API_KEY
-- No wallet signatures needed for API calls
 
 ## API Base URLs
 
-- Production (default): \`https://agent-launch.ai/api\`
-- Dev: set \`AGENT_LAUNCH_ENV=dev\`
-
-## Handoff Protocol
-
-- Agents NEVER hold private keys
-- All on-chain actions go through handoff links
-- Deploy link: \`https://agent-launch.ai/deploy/{tokenId}\`
-- Trade link: \`https://agent-launch.ai/trade/{tokenAddress}?action=buy&amount=100\`
+- Production: \`https://agent-launch.ai/api\`
+- Frontend: \`https://agent-launch.ai\`
 
 ## Key Endpoints
 
@@ -47,39 +36,24 @@ GET   /api/agents/tokens                List tokens
 GET   /api/agents/token/{address}       Token details
 GET   /api/tokens/calculate-buy         Preview buy
 GET   /api/tokens/calculate-sell        Preview sell
-GET   /api/platform/stats               Platform stats
 \`\`\`
 
-## Token Lifecycle
+## Handoff Protocol
 
-1. Agent calls POST /api/agents/tokenize with name, symbol, description
-2. API returns token record with handoff link
-3. Human visits link, connects wallet, signs transaction (pays 120 FET)
-4. Token deploys on-chain with bonding curve
-5. At 30,000 FET liquidity, auto-lists on DEX
+Agents NEVER hold private keys. Flow:
+1. Agent calls API to create token record
+2. API returns handoff link
+3. Agent shares link with human
+4. Human signs transaction
 `,
     "agentverse.md": `# Agentverse Deployment Rules
 
-When deploying agents to Agentverse:
-
-## API Base URL
-
-\`\`\`
-https://agentverse.ai/v1
-\`\`\`
-
-## Auth Header
-
-\`\`\`
-Authorization: Bearer <AGENTVERSE_API_KEY>
-\`\`\`
-
-Note: Capital "Bearer", followed by space, then the raw API key.
+## API: https://agentverse.ai/v1
+## Auth: Authorization: Bearer <AGENTVERSE_API_KEY>
 
 ## CRITICAL: Code Upload Format
 
 The code field MUST be double-encoded JSON:
-
 \`\`\`python
 code_array = [{"language": "python", "name": "agent.py", "value": source_code}]
 payload = {"code": json.dumps(code_array)}
@@ -87,32 +61,23 @@ payload = {"code": json.dumps(code_array)}
 
 ## Agent Code Requirements
 
-- Use \`Agent()\` with zero params (Agentverse provides config)
-- Use Chat Protocol v0.3.0 from \`uagents_core.contrib.protocols.chat\`
-- Must have \`@chat_proto.on_message(ChatAcknowledgement)\` handler
+- Use \`Agent()\` with zero params
+- Use Chat Protocol v0.3.0
+- Must have \`ChatAcknowledgement\` handler
 - Use \`ctx.logger\`, never \`print()\`
-- Use \`datetime.now()\` not \`datetime.utcnow()\` (deprecated)
-- End sessions with \`EndSessionContent\`
-- Include \`publish_manifest=True\` in \`agent.include()\`
+- Use \`datetime.now()\` not \`utcnow()\`
+- Include \`publish_manifest=True\`
 
 ## Deployment Flow
 
-1. \`POST /v1/hosting/agents\` -- creates agent, returns address
-2. \`PUT /v1/hosting/agents/{addr}/code\` -- upload (double-encoded!)
-3. \`POST /v1/hosting/secrets\` -- set AGENTVERSE_API_KEY etc.
-4. \`POST /v1/hosting/agents/{addr}/start\` -- start agent
-5. \`GET /v1/hosting/agents/{addr}\` -- poll until compiled=true (15-60s)
-
-## Common Errors
-
-- "Invalid code format" -- code field not json.dumps'd
-- Agent stuck in "compiling" -- wait longer, check logs for syntax errors
-- 401 Unauthorized -- bad API key or missing "Bearer" prefix
+1. POST /v1/hosting/agents -> creates agent
+2. PUT /v1/hosting/agents/{addr}/code -> upload
+3. POST /v1/hosting/secrets -> set secrets
+4. POST /v1/hosting/agents/{addr}/start -> start
+5. Poll until compiled (15-60s)
 `,
     "uagent-patterns.md": `# uAgent Code Patterns
 
-When writing Agentverse agent code:
-
 ## Minimal Working Agent
 
 \`\`\`python
@@ -123,7 +88,7 @@ from uagents_core.contrib.protocols.chat import (
 )
 from datetime import datetime
 
-agent = Agent()  # Zero params on Agentverse
+agent = Agent()
 chat_proto = agent.create_protocol(spec=chat_protocol_spec)
 
 @chat_proto.on_message(ChatMessage)
@@ -136,7 +101,6 @@ async def handle_message(ctx: Context, sender: str, msg: ChatMessage):
         msg_id=msg.msg_id,
         content=[TextContent(text=f"You said: {text}")]
     ))
-
     await ctx.send(sender, ChatMessage(
         timestamp=datetime.now(),
         msg_id=msg.msg_id,
@@ -145,166 +109,517 @@ async def handle_message(ctx: Context, sender: str, msg: ChatMessage):
 
 @chat_proto.on_message(ChatAcknowledgement)
 async def handle_ack(ctx: Context, sender: str, msg: ChatAcknowledgement):
-    ctx.logger.info(f"Ack from {sender}: {msg.acknowledged_msg_id}")
+    ctx.logger.info(f"Ack: {msg.acknowledged_msg_id}")
 
 agent.include(chat_proto, publish_manifest=True)
 
 if __name__ == "__main__":
     agent.run()
 \`\`\`
+`,
+    "api-design.md": `# API Design Rules
+
+## Response Format
+\`\`\`json
+{
+  "success": boolean,
+  "data": object | array,
+  "error": null | { "code": string, "message": string }
+}
+\`\`\`
 
-## Rules
+## Status Codes
+- 200: Success
+- 201: Created
+- 400: Bad Request
+- 401: Unauthorized
+- 404: Not Found
+- 429: Rate Limited
+- 500: Server Error
+`,
+    "security-checklist.md": `# Security Checklist
+
+## Agent Code
+- Input validation on all messages
+- Rate limiting per user
+- Secrets in .env only
+- Never log sensitive data
+- Sanitize user input
+
+## General
+- No private keys in code
+- .env in .gitignore
+- Use ctx.logger not print
+`,
+    "testing.md": `# Testing Rules
+
+## Local Testing
+\`\`\`bash
+source .env && python agent.py
+\`\`\`
 
-- Always use \`Agent()\` with zero params on Agentverse
-- Always include \`ChatAcknowledgement\` handler (required by protocol)
-- Always end conversations with \`EndSessionContent\`
-- Always use \`ctx.logger\` (never \`print\`)
-- Always use \`datetime.now()\` (never \`utcnow\`, it is deprecated)
-- Always include \`publish_manifest=True\` in \`agent.include()\`
+## Deploy Testing
+\`\`\`bash
+agentlaunch deploy
+agentlaunch status <address>
+\`\`\`
 `,
 };
 // ---------------------------------------------------------------------------
-// Skills
+// Skills — Claude's slash commands
 // ---------------------------------------------------------------------------
 export const SKILLS = {
-    "build-agent/SKILL.md": `# /build-agent -- Full Agent Lifecycle
+    "build-agent/SKILL.md": `# /build-agent — Full Agent Lifecycle
 
 Build, deploy, and tokenize an agent in one guided flow.
 
 ## Steps
 
-1. **Gather requirements**: Ask the user what kind of agent they want to build.
-   Get the agent name, ticker symbol, and description.
+1. Ask user what agent they want (name, description, functionality)
+2. Generate agent.py code based on description
+3. Show code, let user request changes
+4. Deploy: \`agentlaunch deploy\`
+5. Tokenize: \`agentlaunch tokenize --agent <address> --name "Name" --symbol SYM\`
+6. Return handoff link for human to sign
 
-2. **Scaffold the agent code**: Generate agent code based on the description.
-   Use the patterns in .claude/rules/uagent-patterns.md as a reference.
+## Platform Fees
+- Deploy: 120 FET (paid by human signer)
+- Trading: 2% to protocol treasury
+`,
+    "deploy/SKILL.md": `# /deploy — Deploy to Agentverse
 
-3. **Review with user**: Show the generated code. Let them request changes.
+Deploy agent.py to Agentverse hosting.
 
-4. **Deploy to Agentverse**:
-   - Run: \`agentlaunch deploy\`
-   - This creates the agent, uploads code, sets secrets, and starts it
-   - Poll until compiled (60s timeout)
+## Command
+\`\`\`bash
+agentlaunch deploy
+\`\`\`
 
-5. **Tokenize on AgentLaunch**:
-   - Run: \`agentlaunch tokenize --agent <address> --name "Name" --symbol SYM\`
-   - Returns a handoff link for the human to sign
+## What It Does
+1. Reads agent.py
+2. Validates uAgent patterns
+3. Creates agent on Agentverse
+4. Uploads code
+5. Sets secrets from .env
+6. Starts agent
+7. Waits for compilation
+`,
+    "tokenize/SKILL.md": `# /tokenize — Create Token
 
-6. **Return results to user**:
-   - Agent address (agent1q...)
-   - Token handoff link
-   - Instructions: "Click this link, connect your wallet, and sign to deploy"
+Create a tradeable token for an agent.
 
-## Platform Fee Note
+## Command
+\`\`\`bash
+agentlaunch tokenize --agent <address> --name "Name" --symbol SYM
+\`\`\`
 
-The 120 FET deployment fee is paid by the human who signs the transaction.
-The 2% trading fee goes 100% to protocol treasury (no creator fee).
+## Result
+Returns a handoff link. Human clicks it, connects wallet, signs, token goes live.
 `,
-    "deploy/SKILL.md": `# /deploy -- Deploy Agent to Agentverse
-
-Deploy the agent.py file to the Agentverse hosting platform.
+    "status/SKILL.md": `# /status — Check Status
 
-## Usage
+Check agent and token status.
 
-\`\`\`
-/deploy
+## Command
+\`\`\`bash
+agentlaunch status <address>
 \`\`\`
 
-## What It Does
+Shows: running status, price, holders, progress to graduation.
+`,
+    "market/SKILL.md": `# /market — Browse Tokens
 
-1. Reads agent.py from the current directory
-2. Validates it follows uAgent patterns
-3. Creates agent on Agentverse
-4. Uploads code (handles double-encoding automatically)
-5. Sets secrets from .env
-6. Starts the agent
-7. Polls until compiled (60s timeout)
-8. Shows the agent address and status
+Browse tokens on AgentLaunch.
+
+## Commands
+\`\`\`bash
+agentlaunch list
+agentlaunch status <token_address>
+\`\`\`
+`,
+};
+// ---------------------------------------------------------------------------
+// Docs — Full documentation
+// ---------------------------------------------------------------------------
+export const DOCS = {
+    "getting-started.md": `# Getting Started
 
-## CLI Command
+## Prerequisites
+- Node.js 18+
+- Agentverse API key from https://agentverse.ai/profile/api-keys
+
+## Quick Start
 
 \`\`\`bash
-agentlaunch deploy
+# Set API key
+export AGENTVERSE_API_KEY=av-xxx
+
+# Create agent project
+npx agentlaunch-cli create
+
+# Or use SDK
+npm install agentlaunch-sdk
 \`\`\`
 
-## Auth
+## The Agent-Human Handoff
+
+Agents never hold private keys:
+1. Agent calls API -> gets handoff link
+2. Agent shares link with human
+3. Human opens link, connects wallet, signs
+4. Token goes live
 
-Uses AGENTVERSE_API_KEY from \`.env\`
+## Platform Constants
+- Deploy fee: 120 FET
+- Graduation: 30,000 FET -> DEX listing
+- Trading fee: 2% to protocol
 `,
-    "tokenize/SKILL.md": `# /tokenize -- Tokenize an Agent
+    "sdk-reference.md": `# SDK Reference
+
+\`\`\`bash
+npm install agentlaunch-sdk
+\`\`\`
 
-Create a tradeable token for an existing Agentverse agent.
+## Key Functions
+
+\`\`\`typescript
+import {
+  tokenize,           // Create token record
+  getToken,           // Get token details
+  listTokens,         // List all tokens
+  getTokenPrice,      // Get current price
+  getTokenHolders,    // Get holder list
+  generateDeployLink, // Create deploy URL
+  generateBuyLink,    // Create buy URL
+  generateSellLink,   // Create sell URL
+  deployAgent,        // Deploy to Agentverse
+} from 'agentlaunch-sdk';
+\`\`\`
+
+## Example: Create Token
 
-## Usage
+\`\`\`typescript
+const { data } = await tokenize({
+  agentAddress: 'agent1q...',
+  name: 'My Agent',
+  symbol: 'MYAG',
+  chainId: 97,
+});
 
+console.log(data.handoff_link); // Share with human
 \`\`\`
-/tokenize
+`,
+    "cli-reference.md": `# CLI Reference
+
+\`\`\`bash
+npm install -g agentlaunch-cli
 \`\`\`
 
-## What It Does
+## Commands
 
-1. Reads agent address from agentlaunch.config.json (or prompts)
-2. Creates token record on AgentLaunch
-3. Returns a handoff link for the human to sign
+| Command | Description |
+|---------|-------------|
+| \`agentlaunch create\` | Interactive: scaffold + deploy + tokenize |
+| \`agentlaunch deploy\` | Deploy agent.py to Agentverse |
+| \`agentlaunch tokenize\` | Create token + handoff link |
+| \`agentlaunch list\` | List tokens |
+| \`agentlaunch status <addr>\` | Token details |
+| \`agentlaunch config set-key\` | Store API key |
 
-## CLI Command
+## Full Workflow
 
 \`\`\`bash
-agentlaunch tokenize --agent <address> --name "Name" --symbol SYM
+agentlaunch config set-key av-xxx
+agentlaunch create
+# Answer prompts -> agent deployed + tokenized
 \`\`\`
+`,
+    "mcp-tools.md": `# MCP Tools Reference
+
+The MCP server provides 13+ tools for Claude Code.
+
+## Setup
+
+Already configured in \`.claude/settings.json\`.
 
-## Next Steps After Tokenizing
+## Key Tools
 
-1. Human clicks the handoff link
-2. Connects wallet (ASI Wallet recommended)
-3. Signs transaction (pays 120 FET deployment fee)
-4. Token goes live on the bonding curve
-5. At 30,000 FET liquidity, graduates to DEX
+| Tool | Description |
+|------|-------------|
+| \`scaffold_agent\` | Generate agent code |
+| \`deploy_to_agentverse\` | Deploy agent |
+| \`create_token_record\` | Create token |
+| \`list_tokens\` | Browse tokens |
+| \`get_token\` | Token details |
+| \`calculate_buy\` | Preview buy |
+| \`calculate_sell\` | Preview sell |
+| \`get_trade_link\` | Generate trade URL |
+
+## Example Prompts
+
+- "Create a price monitoring agent"
+- "Deploy my agent to Agentverse"
+- "Tokenize my agent as $MYTOKEN"
+- "Show trending tokens"
 `,
-    "status/SKILL.md": `# /status -- Check Agent and Token Status
+};
+// ---------------------------------------------------------------------------
+// Examples — Reference implementations
+// ---------------------------------------------------------------------------
+export const EXAMPLES = {
+    "price-monitor.py": `"""
+Price Monitor Agent — Token Price Alerts
 
-Check the deployment status of agents and tokens.
+Monitors token prices and sends alerts when thresholds are crossed.
+"""
 
-## Usage
+from datetime import datetime
+from uuid import uuid4
+import os
+import requests
+from uagents import Agent, Context, Protocol
+from uagents_core.contrib.protocols.chat import (
+    ChatAcknowledgement, ChatMessage, TextContent,
+    EndSessionContent, chat_protocol_spec
+)
 
-\`\`\`
-/status
-\`\`\`
+agent = Agent()
+chat_proto = Protocol(spec=chat_protocol_spec)
 
-## What It Does
+API_URL = os.environ.get("AGENT_LAUNCH_API_URL", "https://agent-launch.ai/api")
 
-- Shows agent status (running, compiled, address)
-- Shows token status if tokenized (price, holders, progress)
-- Shows platform stats
+# Store watches: user_id -> [{address, threshold}]
+watches = {}
 
-## CLI Command
+def fetch_price(token_address: str) -> float | None:
+    try:
+        r = requests.get(f"{API_URL}/agents/token/{token_address}", timeout=10)
+        if r.ok:
+            return float(r.json().get("price", 0))
+    except:
+        pass
+    return None
 
-\`\`\`bash
-agentlaunch status <address>
-\`\`\`
+@chat_proto.on_message(ChatMessage)
+async def handle(ctx: Context, sender: str, msg: ChatMessage):
+    await ctx.send(sender, ChatAcknowledgement(
+        timestamp=datetime.now(), acknowledged_msg_id=msg.msg_id
+    ))
+
+    text = msg.content[0].text if msg.content else ""
+
+    if text.startswith("watch "):
+        addr = text.split()[1]
+        price = fetch_price(addr)
+        if price:
+            watches.setdefault(sender, []).append({"address": addr, "baseline": price})
+            response = f"Watching {addr[:12]}... at {price:.6f} FET"
+        else:
+            response = "Could not fetch price"
+    elif text.startswith("price "):
+        addr = text.split()[1]
+        price = fetch_price(addr)
+        response = f"{price:.6f} FET" if price else "Error"
+    else:
+        response = "Commands: watch <addr>, price <addr>"
+
+    await ctx.send(sender, ChatMessage(
+        timestamp=datetime.now(), msg_id=uuid4(),
+        content=[TextContent(text=response), EndSessionContent()]
+    ))
+
+@chat_proto.on_message(ChatAcknowledgement)
+async def handle_ack(ctx: Context, sender: str, msg: ChatAcknowledgement):
+    pass
+
+agent.include(chat_proto, publish_manifest=True)
+
+if __name__ == "__main__":
+    agent.run()
 `,
-    "market/SKILL.md": `# /market -- Browse Tokens and Prices
+    "trading-signals.py": `"""
+Trading Signal Agent — Buy/Sell Recommendations
 
-Browse tokens on AgentLaunch and check market data.
+Analyzes token prices and generates trading signals.
+"""
 
-## Usage
+from datetime import datetime
+from uuid import uuid4
+import os
+import requests
+from uagents import Agent, Context, Protocol
+from uagents_core.contrib.protocols.chat import (
+    ChatAcknowledgement, ChatMessage, TextContent,
+    EndSessionContent, chat_protocol_spec
+)
 
-\`\`\`
-/market
-\`\`\`
+agent = Agent()
+chat_proto = Protocol(spec=chat_protocol_spec)
 
-## What It Does
+API_URL = os.environ.get("AGENT_LAUNCH_API_URL", "https://agent-launch.ai/api")
 
-- Lists trending tokens with prices
-- Shows token details for a specific address
-- Previews buy/sell amounts
+# Simple price history
+price_history = {}
 
-## CLI Command
+def get_signal(addr: str) -> str:
+    try:
+        r = requests.get(f"{API_URL}/agents/token/{addr}", timeout=10)
+        if r.ok:
+            data = r.json()
+            price = float(data.get("price", 0))
+            change = float(data.get("price_change_24h", 0))
 
-\`\`\`bash
-agentlaunch list
-agentlaunch status <token_address>
-\`\`\`
+            history = price_history.setdefault(addr, [])
+            history.append(price)
+            if len(history) > 10:
+                history.pop(0)
+
+            ma = sum(history) / len(history) if history else price
+            pct = ((price - ma) / ma * 100) if ma else 0
+
+            if pct > 5:
+                return f"BUY - Price {pct:.1f}% above MA"
+            elif pct < -5:
+                return f"SELL - Price {pct:.1f}% below MA"
+            else:
+                return f"HOLD - Price at {price:.6f} FET"
+    except:
+        pass
+    return "ERROR"
+
+@chat_proto.on_message(ChatMessage)
+async def handle(ctx: Context, sender: str, msg: ChatMessage):
+    await ctx.send(sender, ChatAcknowledgement(
+        timestamp=datetime.now(), acknowledged_msg_id=msg.msg_id
+    ))
+
+    text = msg.content[0].text if msg.content else ""
+
+    if text.startswith("signal "):
+        addr = text.split()[1]
+        response = get_signal(addr)
+    else:
+        response = "Usage: signal <token_address>"
+
+    await ctx.send(sender, ChatMessage(
+        timestamp=datetime.now(), msg_id=uuid4(),
+        content=[TextContent(text=response), EndSessionContent()]
+    ))
+
+@chat_proto.on_message(ChatAcknowledgement)
+async def handle_ack(ctx: Context, sender: str, msg: ChatAcknowledgement):
+    pass
+
+agent.include(chat_proto, publish_manifest=True)
+
+if __name__ == "__main__":
+    agent.run()
+`,
+    "research-agent.py": `"""
+Research Agent — AI-Powered Analysis
+
+Uses AI to generate research reports on tokens.
+"""
+
+from datetime import datetime
+from uuid import uuid4
+import os
+import requests
+from uagents import Agent, Context, Protocol
+from uagents_core.contrib.protocols.chat import (
+    ChatAcknowledgement, ChatMessage, TextContent,
+    EndSessionContent, chat_protocol_spec
+)
+
+agent = Agent()
+chat_proto = Protocol(spec=chat_protocol_spec)
+
+API_URL = os.environ.get("AGENT_LAUNCH_API_URL", "https://agent-launch.ai/api")
+HF_TOKEN = os.environ.get("HF_TOKEN", "")
+
+def get_token_data(addr: str) -> dict:
+    try:
+        r = requests.get(f"{API_URL}/agents/token/{addr}", timeout=10)
+        if r.ok:
+            return r.json()
+    except:
+        pass
+    return {}
+
+def generate_report(query: str, data: dict) -> str:
+    if not HF_TOKEN:
+        return f"Token: {data.get('name', 'Unknown')}\\nPrice: {data.get('price', '?')} FET\\nProgress: {data.get('progress', 0):.1f}%"
+
+    try:
+        prompt = f"Analyze this token: {query}. Data: {data}"
+        r = requests.post(
+            "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.2",
+            headers={"Authorization": f"Bearer {HF_TOKEN}"},
+            json={"inputs": prompt, "parameters": {"max_new_tokens": 200}},
+            timeout=30
+        )
+        if r.ok:
+            return r.json()[0].get("generated_text", "")[:500]
+    except:
+        pass
+    return "Could not generate report"
+
+@chat_proto.on_message(ChatMessage)
+async def handle(ctx: Context, sender: str, msg: ChatMessage):
+    await ctx.send(sender, ChatAcknowledgement(
+        timestamp=datetime.now(), acknowledged_msg_id=msg.msg_id
+    ))
+
+    text = msg.content[0].text if msg.content else ""
+
+    if text.startswith("research "):
+        addr = text.split()[1]
+        data = get_token_data(addr)
+        response = generate_report(text, data)
+    else:
+        response = "Usage: research <token_address>"
+
+    await ctx.send(sender, ChatMessage(
+        timestamp=datetime.now(), msg_id=uuid4(),
+        content=[TextContent(text=response), EndSessionContent()]
+    ))
+
+@chat_proto.on_message(ChatAcknowledgement)
+async def handle_ack(ctx: Context, sender: str, msg: ChatAcknowledgement):
+    pass
+
+agent.include(chat_proto, publish_manifest=True)
+
+if __name__ == "__main__":
+    agent.run()
+`,
+    "sdk-tokenize.ts": `/**
+ * SDK Example: Create and Tokenize an Agent
+ */
+import { tokenize, generateDeployLink, getToken } from 'agentlaunch-sdk';
+
+async function main() {
+  // Create token record
+  const { data } = await tokenize({
+    agentAddress: 'agent1q...', // Your Agentverse agent
+    name: 'My Agent',
+    symbol: 'MYAG',
+    description: 'Does amazing things',
+    chainId: 97, // BSC Testnet
+  });
+
+  console.log('Token ID:', data.token_id);
+  console.log('Handoff Link:', data.handoff_link);
+
+  // Share this link with a human to deploy on-chain
+  // They will pay 120 FET to deploy
+
+  // After deployment, check status
+  // const token = await getToken(data.token_address);
+  // console.log('Price:', token.price);
+}
+
+main().catch(console.error);
 `,
 };
 // ---------------------------------------------------------------------------
@@ -319,6 +634,7 @@ export function buildPackageJson(name) {
             deploy: "agentlaunch deploy",
             tokenize: "agentlaunch tokenize",
             status: "agentlaunch status",
+            list: "agentlaunch list",
         },
         dependencies: {
             "agentlaunch-sdk": "^0.2.0",
@@ -328,4 +644,38 @@ export function buildPackageJson(name) {
         },
     }, null, 2) + "\n";
 }
+// ---------------------------------------------------------------------------
+// Cursor IDE config
+// ---------------------------------------------------------------------------
+export const CURSOR_MCP_CONFIG = JSON.stringify({
+    mcpServers: {
+        "agent-launch": {
+            command: "npx",
+            args: ["agent-launch-mcp"],
+        },
+    },
+}, null, 2) + "\n";
+export const CURSOR_RULES = `# AgentLaunch Agent Project
+
+This is an AgentLaunch agent project. Use the MCP tools to build, deploy, and tokenize.
+
+## Quick Commands
+
+- \`npm run deploy\` - Deploy to Agentverse
+- \`npm run tokenize\` - Create token + handoff link
+- \`npm run status\` - Check status
+
+## Key Files
+
+- \`agent.py\` - Your agent code (edit this!)
+- \`CLAUDE.md\` - Full context for Claude
+- \`docs/\` - SDK, CLI, MCP documentation
+- \`examples/\` - Working code samples
+
+## Platform Constants
+
+- Deploy fee: 120 FET
+- Graduation: 30,000 FET liquidity
+- Trading fee: 2% to protocol treasury
+`;
 //# sourceMappingURL=claude-context.js.map

package/dist/claude-context.js.map

@@ -1 +1 @@
-{"version":3,"file":"claude-context.js","sourceRoot":"","sources":["../src/claude-context.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,8EAA8E;AAC9E,QAAQ;AACR,8EAA8E;AAE9E,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,gBAAgB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDnB;IAEC,eAAe,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDlB;IAEC,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDvB;CACA,CAAC;AAEF,8EAA8E;AAC9E,SAAS;AACT,8EAA8E;AAE9E,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,sBAAsB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgCzB;IAEC,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8BpB;IAEC,mBAAmB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6BtB;IAEC,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;CAqBpB;IAEC,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;CAsBpB;CACA,CAAC;AAEF,8EAA8E;AAC9E,uCAAuC;AACvC,8EAA8E;AAE9E,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,OAAO,IAAI,CAAC,SAAS,CACnB;QACE,IAAI,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;QACpD,OAAO,EAAE,OAAO;QAChB,WAAW,EAAE,GAAG,IAAI,sBAAsB;QAC1C,OAAO,EAAE;YACP,MAAM,EAAE,oBAAoB;YAC5B,QAAQ,EAAE,sBAAsB;YAChC,MAAM,EAAE,oBAAoB;SAC7B;QACD,YAAY,EAAE;YACZ,iBAAiB,EAAE,QAAQ;SAC5B;QACD,eAAe,EAAE;YACf,iBAAiB,EAAE,QAAQ;SAC5B;KACF,EACD,IAAI,EACJ,CAAC,CACF,GAAG,IAAI,CAAC;AACX,CAAC"}
+{"version":3,"file":"claude-context.js","sourceRoot":"","sources":["../src/claude-context.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -38,5 +38,5 @@ export type { AgentTemplate, TemplateVariable } from "./registry.js";
 export { listTemplates, getTemplate } from "./registry.js";
 export type { GenerateResult, GenerateOptions } from "./generator.js";
 export { generateFromTemplate } from "./generator.js";
-export { RULES, SKILLS, buildPackageJson } from "./claude-context.js";
+export { RULES, SKILLS, DOCS, EXAMPLES, buildPackageJson, CURSOR_MCP_CONFIG, CURSOR_RULES } from "./claude-context.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG3D,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGtD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAGH,YAAY,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAG3D,YAAY,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAGtD,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/dist/index.js

@@ -36,6 +36,6 @@
  */
 export { listTemplates, getTemplate } from "./registry.js";
 export { generateFromTemplate } from "./generator.js";
-// Re-export Claude context (rules, skills, package.json builder)
-export { RULES, SKILLS, buildPackageJson } from "./claude-context.js";
+// Re-export Claude context (rules, skills, docs, examples, package.json, cursor config)
+export { RULES, SKILLS, DOCS, EXAMPLES, buildPackageJson, CURSOR_MCP_CONFIG, CURSOR_RULES } from "./claude-context.js";
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAIH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD,iEAAiE;AACjE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAIH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAEtD,wFAAwF;AACxF,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentlaunch-templates",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Agent code templates for the AgentLaunch platform",
   "type": "module",
   "main": "dist/index.js",