stacksagent 1.0.0

package/dist/assets/.claude/skills/stacks-agent/scripts/core.py

@@ -0,0 +1,165 @@
+"""
+Core search engine using BM25 ranking with regex matching
+"""
+
+import csv
+import re
+import math
+from pathlib import Path
+from typing import List, Dict, Any, Optional
+from collections import defaultdict
+
+# Domain to CSV file mapping
+DOMAINS = {
+    'clarity': 'clarity-syntax.csv',
+    'templates': 'contract-templates.csv',
+    'security': 'security-patterns.csv',
+    'defi': 'defi-protocols.csv',
+    'stacksjs': 'stacks-js.csv',
+    'bns': 'bns.csv',
+    'stacking': 'stacking.csv',
+    'deployment': 'deployment.csv'
+}
+
+# Auto-detection keywords
+DOMAIN_KEYWORDS = {
+    'clarity': ['define', 'uint', 'principal', 'let', 'begin', 'asserts', 'unwrap', 'function', 'type', 'syntax'],
+    'templates': ['token', 'nft', 'sip-010', 'sip-009', 'vault', 'dao', 'template', 'contract'],
+    'security': ['vulnerability', 'security', 'audit', 'attack', 'safe', 'check', 'exploit'],
+    'defi': ['swap', 'pool', 'liquidity', 'alex', 'velar', 'bitflow', 'zest', 'borrow', 'lend', 'boost'],
+    'stacksjs': ['javascript', 'stacks.js', 'connect', 'wallet', 'frontend', 'react', 'typescript'],
+    'bns': ['bns', 'name', 'domain', '.btc', 'resolve', 'register'],
+    'stacking': ['stacking', 'pox', 'delegate', 'pool', 'reward', 'cycle', 'bitcoin'],
+    'deployment': ['deploy', 'mainnet', 'testnet', 'clarinet', 'devnet']
+}
+
+
+class BM25:
+    """BM25 ranking algorithm"""
+
+    def __init__(self, documents: List[str], k1: float = 1.5, b: float = 0.75):
+        self.k1 = k1
+        self.b = b
+        self.documents = documents
+        self.doc_len = [len(doc.split()) for doc in documents]
+        self.avgdl = sum(self.doc_len) / len(documents) if documents else 0
+        self.doc_freqs = self._calc_doc_freqs()
+        self.idf = self._calc_idf()
+
+    def _calc_doc_freqs(self) -> Dict[str, int]:
+        freqs = defaultdict(int)
+        for doc in self.documents:
+            for term in set(doc.lower().split()):
+                freqs[term] += 1
+        return freqs
+
+    def _calc_idf(self) -> Dict[str, float]:
+        idf = {}
+        n = len(self.documents)
+        for term, df in self.doc_freqs.items():
+            idf[term] = math.log((n - df + 0.5) / (df + 0.5) + 1)
+        return idf
+
+    def score(self, query: str, doc_idx: int) -> float:
+        score = 0.0
+        doc = self.documents[doc_idx].lower()
+        doc_terms = doc.split()
+        term_freqs = defaultdict(int)
+        for term in doc_terms:
+            term_freqs[term] += 1
+
+        for term in query.lower().split():
+            if term not in self.idf:
+                continue
+            tf = term_freqs[term]
+            idf = self.idf[term]
+            dl = self.doc_len[doc_idx]
+            score += idf * (tf * (self.k1 + 1)) / (tf + self.k1 * (1 - self.b + self.b * dl / self.avgdl))
+
+        return score
+
+
+def detect_domain(query: str) -> str:
+    """Auto-detect domain based on query keywords"""
+    query_lower = query.lower()
+    scores = {}
+
+    for domain, keywords in DOMAIN_KEYWORDS.items():
+        score = sum(1 for kw in keywords if kw in query_lower)
+        if score > 0:
+            scores[domain] = score
+
+    if scores:
+        return max(scores, key=scores.get)
+    return 'templates'  # Default to templates
+
+
+def load_data(domain: str) -> List[Dict[str, Any]]:
+    """Load CSV data for a domain"""
+    data_dir = Path(__file__).parent.parent / 'data'
+    csv_file = data_dir / DOMAINS[domain]
+
+    if not csv_file.exists():
+        return []
+
+    with open(csv_file, 'r', encoding='utf-8') as f:
+        reader = csv.DictReader(f)
+        return list(reader)
+
+
+def search(
+    query: str,
+    domain: str = 'auto',
+    max_results: int = 5
+) -> List[Dict[str, Any]]:
+    """
+    Search knowledge base using BM25 + regex
+
+    Args:
+        query: Search query
+        domain: Domain to search or 'auto' for auto-detection
+        max_results: Maximum results to return
+
+    Returns:
+        List of matching records
+    """
+    # Auto-detect domain if needed
+    if domain == 'auto':
+        domain = detect_domain(query)
+
+    # Load data
+    data = load_data(domain)
+    if not data:
+        return []
+
+    # Create searchable text for each record
+    def record_to_text(record: Dict) -> str:
+        return ' '.join(str(v) for v in record.values())
+
+    documents = [record_to_text(r) for r in data]
+
+    # BM25 scoring
+    bm25 = BM25(documents)
+    scores = [(i, bm25.score(query, i)) for i in range(len(documents))]
+
+    # Regex boost for exact matches
+    try:
+        query_pattern = re.compile(re.escape(query), re.IGNORECASE)
+        for i, (idx, score) in enumerate(scores):
+            if query_pattern.search(documents[idx]):
+                scores[i] = (idx, score * 2)  # Boost exact matches
+    except re.error:
+        pass  # Skip regex boost if pattern is invalid
+
+    # Sort by score and return top results
+    scores.sort(key=lambda x: x[1], reverse=True)
+
+    results = []
+    for idx, score in scores[:max_results]:
+        if score > 0:
+            result = data[idx].copy()
+            result['_score'] = round(score, 3)
+            result['_domain'] = domain
+            results.append(result)
+
+    return results

package/dist/assets/.claude/skills/stacks-agent/scripts/search.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Stacks Agent Skill - Search Engine
+BM25 + regex hybrid search across knowledge databases
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from core import search, DOMAINS
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='Search Stacks Agent knowledge base'
+    )
+    parser.add_argument('query', help='Search query')
+    parser.add_argument(
+        '--domain', '-d',
+        choices=list(DOMAINS.keys()) + ['auto'],
+        default='auto',
+        help='Domain to search (default: auto-detect)'
+    )
+    parser.add_argument(
+        '--max-results', '-n',
+        type=int,
+        default=5,
+        help='Maximum results to return (default: 5)'
+    )
+    parser.add_argument(
+        '--format', '-f',
+        choices=['text', 'json'],
+        default='text',
+        help='Output format (default: text)'
+    )
+
+    args = parser.parse_args()
+
+    results = search(
+        query=args.query,
+        domain=args.domain,
+        max_results=args.max_results
+    )
+
+    if args.format == 'json':
+        import json
+        print(json.dumps(results, indent=2))
+    else:
+        if not results:
+            print(f"No results found for: {args.query}")
+        else:
+            for i, result in enumerate(results, 1):
+                print(f"\n--- Result {i} (Score: {result.get('_score', 0)}) ---")
+                for key, value in result.items():
+                    if not key.startswith('_'):
+                        print(f"{key}: {value}")
+
+if __name__ == '__main__':
+    main()

package/dist/assets/.codex/skills/stacks-agent/SKILL.md

@@ -0,0 +1,126 @@
+# Stacks Agent - OpenAI Codex Skill
+
+Stacks blockchain development intelligence for Codex.
+
+## Skill Overview
+
+AI-powered assistance for building on Stacks - Bitcoin's smart contract layer.
+
+## Capabilities
+
+- Generate and audit Clarity smart contracts
+- SIP-010 fungible tokens and SIP-009 NFTs
+- DeFi protocol integration (Alex, Velar, Bitflow, Zest)
+- Security vulnerability detection and fixes
+- Stacks.js frontend integration
+- BNS name system operations
+- PoX stacking and pool delegation
+- Deployment guides (testnet, mainnet, devnet)
+
+## Knowledge Base
+
+170+ searchable entries across 8 domains:
+
+```bash
+python3 .shared/stacks-agent/scripts/search.py "<query>" --domain <domain>
+```
+
+**Domains**:
+- `clarity` - 61 functions and types
+- `templates` - 14 contract templates
+- `security` - 15 security patterns
+- `defi` - 15 DeFi protocols
+- `stacksjs` - 30 JavaScript snippets
+- `bns` - 10 name system operations
+- `stacking` - 15 stacking guides
+- `deployment` - 25 deployment steps
+
+## Workflow
+
+1. **Analyze** user request (contract type, features, network)
+2. **Search** knowledge base for relevant patterns
+3. **Generate** code following Clarity best practices
+4. **Apply** security patterns automatically
+5. **Provide** deployment instructions
+
+## Code Generation Rules
+
+### Always Include
+- Access control checks (`tx-sender` validation)
+- Error handling (`try!`, `unwrap!`)
+- Input validation (`asserts!`)
+- Named error constants (`ERR-*`)
+- Kebab-case naming
+- Documentation comments
+
+### Never Include
+- `unwrap-panic` in production code
+- Hardcoded magic numbers
+- Unvalidated external calls
+- Missing return value checks
+
+## Security Patterns
+
+### Critical
+- Validate `tx-sender` for sensitive operations
+- Check all transfer return values
+- Handle errors explicitly
+
+### High
+- Validate all inputs
+- Prevent division by zero
+- Update state before external calls
+
+### Medium
+- Prevent self-transfers
+- Restrict minting functions
+- Use `tx-sender` not `contract-caller`
+
+## Example Outputs
+
+### Token Contract
+```clarity
+(define-fungible-token my-token u1000000)
+(define-constant ERR-UNAUTHORIZED (err u100))
+(define-constant ERR-INVALID-AMOUNT (err u101))
+
+(define-public (transfer (amount uint) (recipient principal))
+  (begin
+    (asserts! (> amount u0) ERR-INVALID-AMOUNT)
+    (try! (ft-transfer? my-token amount tx-sender recipient))
+    (ok true)))
+```
+
+### DeFi Integration
+```clarity
+;; Swap on Alex
+(contract-call?
+  'SP102V8P0F7JX67ARQ77WEA3D3CFB5XW39REDT0AM.amm-swap-pool-v1-1
+  swap-helper
+  .token-wstx
+  .age000-governance-token
+  u100000000
+  u100000000
+  u1000000
+  u1)
+```
+
+## Networks
+
+- **Mainnet**: SP... addresses (production)
+- **Testnet**: ST... addresses (free STX for testing)
+- **Devnet**: Local Clarinet development
+
+## Standards
+
+- SIP-010 (FT): `SP3FBR2AGK5H9QBDH3EEN6DF8EK8JY7RX8QJ5SVTE.sip-010-trait-ft-standard`
+- SIP-009 (NFT): `SP2PABAF9FTAJYNFZH93XENAJ8FVY99RRM50D2JG9.nft-trait`
+
+## Resources
+
+- https://docs.stacks.co
+- https://explorer.hiro.so
+- https://github.com/hirosystems/clarinet
+
+**Version**: 1.0.0
+**Author**: kai-builder

package/dist/assets/.cursor/commands/stacks-agent.md

@@ -0,0 +1,50 @@
+# Stacks Agent - Cursor Command
+
+AI-powered intelligence for building Stacks blockchain applications.
+
+## Command
+Use `/stacks-agent` to activate this workflow for Stacks development tasks.
+
+## Capabilities
+
+- **Clarity Contracts**: Generate, audit, and deploy smart contracts
+- **Token Standards**: SIP-010 (fungible) and SIP-009 (NFT) templates
+- **DeFi Integration**: Alex, Velar, Bitflow, Zest, Boost, Faktory
+- **Security Analysis**: Vulnerability detection and best practices
+- **Stacks.js**: Frontend integration code snippets
+- **BNS**: Bitcoin Name System operations
+- **Stacking**: PoX stacking and pool delegation
+
+## Knowledge Search
+
+Use the search script to query the knowledge base:
+
+```bash
+python3 .shared/stacks-agent/scripts/search.py "<query>" --domain <domain>
+```
+
+**Available domains**: clarity, templates, security, defi, stacksjs, bns, stacking, deployment, auto
+
+## Workflow
+
+1. **Understand** the user's request (contract type, features, network)
+2. **Search** knowledge base for relevant patterns and examples
+3. **Generate** code based on templates and best practices
+4. **Review** security patterns and apply fixes
+5. **Provide** deployment instructions
+
+## Examples
+
+- "Create a SIP-010 token called MOON with 1M supply"
+- "Build an NFT collection with royalties"
+- "How do I swap tokens on Velar?"
+- "Deploy my contract to testnet"
+
+## Resources
+
+- Docs: https://docs.stacks.co
+- Explorer: https://explorer.hiro.so
+- Clarinet: https://github.com/hirosystems/clarinet
+
+## Version
+1.0.0 - 170+ knowledge entries across 8 domains

package/dist/assets/.github/prompts/stacks-agent.prompt.md

@@ -0,0 +1,80 @@
+# Stacks Agent - GitHub Copilot Prompt
+
+AI-powered Stacks blockchain development intelligence.
+
+## Use with @stacks-agent
+
+This prompt enhances Copilot for Stacks blockchain development.
+
+## What I Can Help With
+
+- **Clarity Smart Contracts**: Generate, audit, deploy
+- **Token Standards**: SIP-010 (FT), SIP-009 (NFT)
+- **DeFi Protocols**: Alex, Velar, Bitflow, Zest, Boost
+- **Security**: Vulnerability detection and fixes
+- **Stacks.js**: Frontend integration
+- **BNS**: Name system operations
+- **Stacking**: PoX stacking and pools
+- **Deployment**: Testnet/mainnet guides
+
+## Knowledge Base
+
+Access 170+ entries via search:
+
+```bash
+python3 .shared/stacks-agent/scripts/search.py "<your-query>"
+```
+
+Add `--domain <name>` for specific domains:
+- clarity, templates, security, defi, stacksjs, bns, stacking, deployment
+
+## My Approach
+
+When you ask about Stacks development, I will:
+
+1. **Search** relevant knowledge base entries
+2. **Generate** code following best practices
+3. **Apply** security patterns automatically
+4. **Provide** deployment instructions
+5. **Reference** official documentation
+
+## Security First
+
+All generated code includes:
+- ✓ Access control (tx-sender checks)
+- ✓ Error handling (try!/unwrap!)
+- ✓ Input validation (asserts!)
+- ✓ Named error constants
+- ✓ Kebab-case naming
+- ✓ Network compatibility
+
+## Example Requests
+
+"Create a meme token with 1B supply"
+"Build an NFT marketplace contract"
+"How to swap on Alex DEX?"
+"Deploy to Stacks testnet"
+"Audit this Clarity contract for security issues"
+
+## Networks
+
+- **Mainnet**: Production (SP... addresses)
+- **Testnet**: Testing (ST... addresses, free STX)
+- **Devnet**: Local development (Clarinet)
+
+## Standards
+
+- SIP-010 Trait: `SP3FBR2AGK5H9QBDH3EEN6DF8EK8JY7RX8QJ5SVTE.sip-010-trait-ft-standard`
+- SIP-009 Trait: `SP2PABAF9FTAJYNFZH93XENAJ8FVY99RRM50D2JG9.nft-trait`
+
+## Resources
+
+- Docs: https://docs.stacks.co
+- Explorer: https://explorer.hiro.so
+- Clarinet: https://github.com/hirosystems/clarinet
+
+---
+
+**Version**: 1.0.0
+**Author**: kai-builder
+**Knowledge Entries**: 170+

package/dist/assets/.kiro/steering/stacks-agent.md

@@ -0,0 +1,78 @@
+# Stacks Agent - Kiro Steering
+
+Stacks blockchain development intelligence for Kiro AI.
+
+## Purpose
+
+Guide AI responses for Stacks blockchain development, Clarity smart contracts, and DeFi integration.
+
+## Scope
+
+- Clarity contract generation and auditing
+- SIP-010 (fungible tokens) and SIP-009 (NFTs)
+- DeFi protocols: Alex, Velar, Bitflow, Zest, Boost, Faktory
+- Stacks.js frontend integration
+- BNS (Bitcoin Name System)
+- PoX stacking and delegation
+- Deployment workflows
+
+## Knowledge Access
+
+Search knowledge base:
+```bash
+python3 .shared/stacks-agent/scripts/search.py "<query>" --domain <domain>
+```
+
+Domains: clarity, templates, security, defi, stacksjs, bns, stacking, deployment
+
+## Response Guidelines
+
+### For Contract Generation
+1. Search templates domain for relevant patterns
+2. Apply security patterns from security domain
+3. Use kebab-case naming convention
+4. Include error constants (ERR-*)
+5. Add try!/unwrap! for error handling
+6. Validate inputs with asserts!
+
+### For DeFi Integration
+1. Search defi domain for protocol specifics
+2. Provide mainnet contract addresses
+3. Include example function calls
+4. Add Stacks.js integration if needed
+
+### For Deployment
+1. Search deployment domain for steps
+2. Distinguish testnet vs mainnet
+3. Include faucet links for testnet
+4. Provide verification instructions
+
+## Security Emphasis
+
+Always check generated code for:
+- Missing tx-sender validation
+- Unchecked transfer returns
+- Missing input validation
+- Wrong network trait addresses
+- Hardcoded magic numbers
+
+## Code Style
+
+```clarity
+;; Good
+(define-constant ERR-UNAUTHORIZED (err u100))
+(define-public (transfer (amount uint))
+  (begin
+    (asserts! (> amount u0) ERR-INVALID-AMOUNT)
+    (try! (ft-transfer? token amount tx-sender recipient))
+    (ok true)))
+```
+
+## Networks
+
+- Mainnet: SP... (production)
+- Testnet: ST... (testing)
+- Devnet: local (Clarinet)
+
+## Version
+1.0.0 - 170+ knowledge entries

package/dist/assets/.shared/stacks-agent/data/bns.csv

@@ -0,0 +1,11 @@
+id,category,name,description,code,contract,notes
+1,resolve,name-to-address,"Resolve BNS name to address","(contract-call? .bns name-resolve namespace name)","SP000000000000000000002Q6VF78.bns","Returns principal of name owner"
+2,resolve,address-to-name,"Get primary name for address","(contract-call? .bns resolve-principal address)","SP000000000000000000002Q6VF78.bns","Returns primary BNS name"
+3,register,register-name,"Register a new BNS name","(contract-call? .bns-v2 name-register namespace name salt zonefile-hash)","BNS-V2 contract","Requires STX payment based on name length"
+4,transfer,transfer-name,"Transfer BNS name ownership","(contract-call? .bns-v2 name-transfer namespace name new-owner zonefile-hash)","BNS-V2 contract","Owner only can transfer names"
+5,update,update-zonefile,"Update name zonefile hash","(contract-call? .bns-v2 name-update namespace name zonefile-hash)","BNS-V2 contract","Updates DNS records for name"
+6,lookup,name-info,"Get name details","(contract-call? .bns name-resolve namespace name)","SP000000000000000000002Q6VF78.bns","Returns owner zonefile-hash lease-ending-at"
+7,lookup,get-namespace-price,"Get registration price","(contract-call? .bns-v2 get-namespace-price namespace)","BNS-V2 contract","Price in microSTX"
+8,lookup,can-name-be-registered,"Check name availability","(contract-call? .bns-v2 can-name-be-registered namespace name)","BNS-V2 contract","Returns true if available"
+9,bulk,batch-register,"Register multiple names","(map register-single-name names)","Custom contract","Loop through list of names"
+10,renew,renew-name,"Renew name registration","(contract-call? .bns-v2 name-renewal namespace name)","BNS-V2 contract","Extends lease period"

package/dist/assets/.shared/stacks-agent/data/clarity-syntax.csv

@@ -0,0 +1,62 @@
+id,category,name,syntax,description,example,notes
+1,types,uint,"uint","Unsigned integer (0 to 2^128-1)","(define-data-var counter uint u0)","Use u prefix for literals"
+2,types,int,"int","Signed integer (-2^127 to 2^127-1)","(define-data-var balance int 0)","Can be negative"
+3,types,bool,"bool","Boolean true/false","(define-data-var active bool true)","true or false only"
+4,types,principal,"principal","Stacks address or contract","tx-sender","SP... or ST... format"
+5,types,buff,"(buff n)","Fixed-length byte buffer","(buff 32)","Max 1MB"
+6,types,string-ascii,"(string-ascii n)","ASCII string","(string-ascii 50)","ASCII chars only"
+7,types,string-utf8,"(string-utf8 n)","UTF-8 string","(string-utf8 100)","Unicode support"
+8,types,list,"(list n type)","Fixed-length list","(list 10 uint)","Homogeneous types"
+9,types,tuple,"{ key: type }","Named fields","{ name: (string-ascii 50), age: uint }","Like struct"
+10,types,optional,"(optional type)","Maybe value","(optional uint)","some/none"
+11,types,response,"(response ok-type err-type)","Result type","(response bool uint)","ok/err"
+12,functions,define-public,"(define-public (name (arg type)) body)","Public function","(define-public (transfer (amount uint)) (ok true))","Callable externally"
+13,functions,define-read-only,"(define-read-only (name) body)","Read-only function","(define-read-only (get-balance) (ok u100))","No state changes"
+14,functions,define-private,"(define-private (name) body)","Private function","(define-private (helper) u1)","Internal only"
+15,functions,define-data-var,"(define-data-var name type value)","State variable","(define-data-var owner principal tx-sender)","Mutable storage"
+16,functions,define-map,"(define-map name key-type value-type)","Key-value map","(define-map balances principal uint)","Persistent storage"
+17,functions,define-constant,"(define-constant name value)","Constant value","(define-constant ERR-UNAUTHORIZED (err u401))","Immutable"
+18,functions,define-fungible-token,"(define-fungible-token name supply?)","Create FT","(define-fungible-token MY-TOKEN u1000000)","SIP-010 base"
+19,functions,define-non-fungible-token,"(define-non-fungible-token name type)","Create NFT","(define-non-fungible-token MY-NFT uint)","SIP-009 base"
+20,control,if,"(if condition then else)","Conditional","(if (> x u0) u1 u0)","Both branches required"
+21,control,match,"(match opt (some val) expr none-expr)","Pattern match","(match (get-user) user (ok user) (err u404))","Optional/response"
+22,control,let,"(let ((var val)) body)","Local binding","(let ((x u1) (y u2)) (+ x y))","Scoped variables"
+23,control,begin,"(begin expr1 expr2 ...)","Sequence","(begin (print ""hi"") (ok true))","Returns last"
+24,control,asserts!,"(asserts! condition error)","Assert or abort","(asserts! (is-eq tx-sender owner) ERR-UNAUTHORIZED)","Stops execution"
+25,control,try!,"(try! response)","Unwrap or propagate","(try! (ft-transfer? token u100 from to))","Early return on err"
+26,control,unwrap!,"(unwrap! opt error)","Unwrap or error","(unwrap! (map-get? users id) ERR-NOT-FOUND)","Must succeed"
+27,control,unwrap-panic,"(unwrap-panic opt)","Unwrap or panic","(unwrap-panic (some u1))","Use carefully"
+28,arithmetic,+,"(+ a b ...)","Addition","(+ u1 u2 u3)","Auto-checks overflow"
+29,arithmetic,-,"(- a b)","Subtraction","(- u10 u5)","Returns uint if uint"
+30,arithmetic,*,"(* a b ...)","Multiplication","(* u5 u3)","Auto-checks overflow"
+31,arithmetic,/,"(/ a b)","Division","(/ u10 u2)","Integer division"
+32,arithmetic,mod,"(mod a b)","Modulo","(mod u10 u3)","Remainder"
+33,comparison,is-eq,"(is-eq a b)","Equality check","(is-eq tx-sender owner)","Works with all types"
+34,comparison,>,"(> a b)","Greater than","(> u5 u3)","true or false"
+35,comparison,<,"(< a b)","Less than","(< u3 u5)","true or false"
+36,comparison,>=,"(>= a b)","Greater than or equal","(>= u5 u5)","true or false"
+37,comparison,<=,"(<= a b)","Less than or equal","(<= u3 u5)","true or false"
+38,logic,and,"(and expr1 expr2 ...)","Logical AND","(and (> x u0) (< x u100))","Short-circuits"
+39,logic,or,"(or expr1 expr2 ...)","Logical OR","(or (is-eq x u1) (is-eq x u2))","Short-circuits"
+40,logic,not,"(not expr)","Logical NOT","(not (is-eq x u0))","Inverts boolean"
+41,map-functions,map-set,"(map-set map key value)","Set map entry","(map-set balances user u100)","Creates or updates"
+42,map-functions,map-get?,"(map-get? map key)","Get map value","(map-get? balances user)","Returns optional"
+43,map-functions,map-delete,"(map-delete map key)","Delete map entry","(map-delete balances user)","Removes key"
+44,map-functions,map-insert,"(map-insert map key value)","Insert if not exists","(map-insert balances user u100)","False if exists"
+45,var-functions,var-get,"(var-get var)","Get variable value","(var-get counter)","Returns current value"
+46,var-functions,var-set,"(var-set var value)","Set variable value","(var-set counter u10)","Updates value"
+47,token-functions,ft-transfer?,"(ft-transfer? token amount from to)","Transfer fungible tokens","(ft-transfer? my-token u100 tx-sender recipient)","Returns response"
+48,token-functions,ft-mint?,"(ft-mint? token amount recipient)","Mint fungible tokens","(ft-mint? my-token u1000 recipient)","Increases supply"
+49,token-functions,ft-burn?,"(ft-burn? token amount sender)","Burn fungible tokens","(ft-burn? my-token u100 tx-sender)","Decreases supply"
+50,token-functions,ft-get-balance,"(ft-get-balance token principal)","Get FT balance","(ft-get-balance my-token user)","Returns uint"
+51,token-functions,ft-get-supply,"(ft-get-supply token)","Get total supply","(ft-get-supply my-token)","Returns uint"
+52,token-functions,nft-transfer?,"(nft-transfer? nft id from to)","Transfer NFT","(nft-transfer? my-nft u1 tx-sender recipient)","Returns response"
+53,token-functions,nft-mint?,"(nft-mint? nft id recipient)","Mint NFT","(nft-mint? my-nft u1 recipient)","Returns response"
+54,token-functions,nft-burn?,"(nft-burn? nft id sender)","Burn NFT","(nft-burn? my-nft u1 tx-sender)","Returns response"
+55,token-functions,nft-get-owner?,"(nft-get-owner? nft id)","Get NFT owner","(nft-get-owner? my-nft u1)","Returns optional principal"
+56,stx-functions,stx-transfer?,"(stx-transfer? amount from to)","Transfer STX","(stx-transfer? u1000000 tx-sender recipient)","Amount in microSTX"
+57,stx-functions,stx-burn?,"(stx-burn? amount sender)","Burn STX","(stx-burn? u1000000 tx-sender)","Destroys STX"
+58,stx-functions,stx-get-balance,"(stx-get-balance principal)","Get STX balance","(stx-get-balance tx-sender)","Returns uint"
+59,contract-functions,contract-call?,"(contract-call? contract function args...)","Call external contract","(contract-call? .other-contract transfer u100)","Returns response"
+60,contract-functions,as-contract,"(as-contract expr)","Execute as contract","(as-contract (stx-transfer? u100 tx-sender recipient))","Contract is tx-sender"
+61,contract-functions,contract-of,"(contract-of trait-ref)","Get contract principal","(contract-of .token-trait)","Returns principal"

package/dist/assets/.shared/stacks-agent/data/contract-templates.csv

@@ -0,0 +1,15 @@
+id,category,name,description,traits,use_case,features
+1,token,sip010-basic,"Basic SIP-010 fungible token","SP3FBR2AGK5H9QBDH3EEN6DF8EK8JY7RX8QJ5SVTE.sip-010-trait-ft-standard","Meme tokens utility tokens","transfer get-name get-symbol get-decimals get-balance get-total-supply get-token-uri"
+2,token,sip010-mintable,"SIP-010 with mint function","sip-010-trait","Reward tokens inflationary","All SIP-010 functions plus mint (owner-only)"
+3,token,sip010-burnable,"SIP-010 with burn on transfer","sip-010-trait","Deflationary tokens","All SIP-010 functions plus burn mechanism"
+4,token,sip010-capped,"SIP-010 with max supply cap","sip-010-trait","Limited supply tokens","All SIP-010 functions with supply cap check"
+5,nft,sip009-basic,"Basic SIP-009 NFT collection","SP2PABAF9FTAJYNFZH93XENAJ8FVY99RRM50D2JG9.nft-trait","PFP collections","transfer get-last-token-id get-token-uri get-owner"
+6,nft,sip009-mintable,"SIP-009 with public mint","nft-trait","Open mints allowlists","All SIP-009 functions plus public mint"
+7,nft,sip009-royalties,"SIP-009 with royalty support","nft-trait","Creator royalties","All SIP-009 functions plus royalty tracking"
+8,defi,vault-basic,"Simple STX vault","none","Savings staking","deposit withdraw get-balance"
+9,defi,vault-timelocked,"Vault with unlock period","none","Vesting lockups","deposit withdraw-after-period get-unlock-time"
+10,defi,pool-basic,"Basic liquidity pool","none","DEX pools","add-liquidity remove-liquidity swap get-reserves"
+11,dao,dao-basic,"Simple DAO with proposals","none","Governance","create-proposal vote execute-proposal"
+12,dao,dao-treasury,"DAO with treasury management","none","Protocol governance","All DAO functions plus treasury management"
+13,marketplace,nft-marketplace,"NFT listing and sales","nft-trait","NFT trading","list-nft unlist-nft buy-nft get-listing"
+14,stacking,stacking-pool,"Stacking pool delegation","none","Pool operators","delegate revoke get-delegation-info claim-rewards"