apero-kit-cli 2.3.0 → 2.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "apero-kit-cli",
-  "version": "2.3.0",
+  "version": "2.4.0",
   "description": "CLI tool to scaffold AI agent projects with pre-configured kits (Claude, OpenCode, Codex)",
   "type": "module",
   "bin": {

package/templates/discord/README.md

@@ -1,6 +1,13 @@
-# Discord + Clawbot Setup Guide
+# Discord + OpenClaw Setup Guide
 
-This directory contains configuration for running your AI agent on Discord via [Clawbot/OpenClaw](https://docs.openclaw.ai).
+This directory contains configuration for running your AI agent on Discord via [OpenClaw](https://docs.openclaw.ai).
+
+## Features
+
+- **Auto Intent Detection** - No need to type `/plan` or `/brainstorm`, bot understands natural language
+- **Skills System** - Commands converted to skills format for better context
+- **Train Prompt** - Add new knowledge via URLs, files, or inline content
+- **Progressive Disclosure** - Skills load on-demand to save tokens
 
 ## Quick Start
 
@@ -128,6 +135,70 @@ openclaw gateway restart
 openclaw doctor
 ```
 
+## Skills System
+
+Your commands are converted to **OpenClaw Skills** format for better AI understanding.
+
+### Structure
+```
+.discord/
+├── skills/
+│   ├── auto-intent-router/    # Auto-detects user intent
+│   │   └── SKILL.md
+│   ├── train-prompt/          # Add new knowledge
+│   │   └── SKILL.md
+│   ├── planning/              # Converted from /plan
+│   │   └── SKILL.md
+│   ├── brainstorm/            # Converted from /brainstorm
+│   │   └── SKILL.md
+│   └── ...
+├── commands/                  # Original commands (backup)
+├── commands.json5             # Slash commands config
+└── config.json5               # Main config
+```
+
+### How It Works
+
+1. **Auto Intent Router** detects what user wants from natural language
+2. **Appropriate skill** is activated automatically
+3. User gets response without typing commands
+
+Example:
+```
+User: "I need to add payment processing"
+Bot: [Detects PLANNING intent, activates planning skill]
+     "I'll help you plan the payment processing feature..."
+```
+
+## Training New Knowledge
+
+Use the **train-prompt** skill to teach the bot new things:
+
+### Train from URL
+```
+/train https://docs.stripe.com/api
+```
+
+### Train from File
+```
+/train:file ./docs/coding-standards.md
+```
+
+### Train Inline
+```
+/train:inline
+Our deployment process:
+1. Run tests
+2. Build
+3. Deploy staging
+4. Deploy production
+```
+
+### List Trained Knowledge
+```
+/train:list
+```
+
 ## Troubleshooting
 
 **Bot not responding?**
@@ -143,8 +214,14 @@ openclaw doctor
 - Verify bot has required permissions
 - Check guild configuration in `config.json5`
 
+**Skills not loading?**
+- Check `skills/` directory exists
+- Verify SKILL.md files have correct frontmatter
+- Run `openclaw skills list` to see active skills
+
 ## Resources
 
 - [OpenClaw Documentation](https://docs.openclaw.ai)
 - [Discord Channel Guide](https://docs.openclaw.ai/channels/discord)
+- [Skills Guide](https://docs.openclaw.ai/tools/skills)
 - [Slash Commands](https://docs.openclaw.ai/tools/slash-commands)

package/templates/discord/skills/auto-intent-router/SKILL.md

@@ -0,0 +1,195 @@
+---
+name: auto-intent-router
+description: Automatically detects user intent and routes to appropriate skill without manual commands
+user-invocable: false
+disable-model-invocation: false
+metadata: {"openclaw": {"always": true, "priority": 1}}
+---
+
+# Auto Intent Router
+
+## Purpose
+
+This skill runs on EVERY message to detect user intent and automatically activate the appropriate skill. Users don't need to type commands like `/plan` or `/brainstorm` - the bot understands natural language.
+
+## Priority
+
+This skill has highest priority (runs first) to route messages before other processing.
+
+## Intent Detection Matrix
+
+| Intent | Keywords/Patterns | Activated Skill |
+|--------|-------------------|-----------------|
+| **PLANNING** | plan, design, architect, implement, create, build feature | `planning`, `plan-fast`, `plan-hard` |
+| **BRAINSTORMING** | brainstorm, ideas, options, alternatives, think about, explore | `brainstorm` |
+| **DEBUGGING** | fix, debug, error, broken, bug, issue, not working, crash | `debugging`, `fix-fast`, `fix-hard` |
+| **CODE REVIEW** | review, check my code, look at this, audit, examine | `code-review` |
+| **CODING** | code, implement, write, develop, create function | `code`, `cook` |
+| **TESTING** | test, unit test, spec, coverage, jest, vitest | `testing` |
+| **DATABASE** | database, schema, migration, query, sql, table | `database` |
+| **API DESIGN** | api, endpoint, rest, graphql, route | `api-design` |
+| **DOCUMENTATION** | document, docs, readme, explain, describe | `documentation` |
+| **DEPLOYMENT** | deploy, release, staging, production, ci/cd | `deployment` |
+| **TRAINING** | train, learn, teach, add knowledge, remember | `train-prompt` |
+| **SCOUTING** | find, search, where is, locate, explore codebase | `scout` |
+
+## Detection Algorithm
+
+```
+1. EXTRACT keywords from user message
+2. MATCH against intent patterns
+3. CALCULATE confidence score for each intent
+4. IF confidence > 0.7:
+     ACTIVATE corresponding skill
+   ELSE IF multiple intents detected:
+     ASK user for clarification
+   ELSE:
+     PROCEED with general response
+```
+
+## Confidence Scoring
+
+```
+score = (keyword_matches * 0.4) + (pattern_matches * 0.3) + (context_relevance * 0.3)
+
+- keyword_matches: Number of intent keywords found
+- pattern_matches: Regex patterns matched
+- context_relevance: Based on conversation history
+```
+
+## Workflow
+
+### Step 1: Parse Message
+
+Extract:
+- Primary keywords
+- Question type (how, what, why, can you)
+- Code references (file paths, function names)
+- URLs or links
+
+### Step 2: Intent Classification
+
+For each potential intent:
+1. Count keyword matches
+2. Check pattern matches
+3. Consider conversation context
+4. Calculate confidence score
+
+### Step 3: Route or Clarify
+
+**High Confidence (>0.7):**
+```
+Silently activate the matched skill.
+User sees natural response, not "Activating planning skill..."
+```
+
+**Medium Confidence (0.4-0.7):**
+```
+"I think you want to [intent]. Should I:
+A) Create a plan for this
+B) Brainstorm alternatives first
+C) Just help directly"
+```
+
+**Low Confidence (<0.4):**
+```
+Respond naturally without special skill activation.
+```
+
+## Examples
+
+### Example 1: Planning Intent
+```
+User: "I need to add user authentication to the app"
+
+[Intent Detection]
+Keywords: "add", "authentication", "app"
+Pattern: "I need to" + feature description
+Confidence: PLANNING = 0.85
+
+[Action]
+Activate: planning skill
+Response: "I'll help you plan the authentication system..."
+```
+
+### Example 2: Debugging Intent
+```
+User: "The login button isn't working anymore"
+
+[Intent Detection]
+Keywords: "isn't working"
+Pattern: [component] + "not working"
+Confidence: DEBUGGING = 0.9
+
+[Action]
+Activate: debugging skill
+Response: "Let me investigate the login button issue..."
+```
+
+### Example 3: Ambiguous Intent
+```
+User: "Can you help with the API?"
+
+[Intent Detection]
+Keywords: "API"
+Confidence: API_DESIGN = 0.5, DEBUGGING = 0.4
+
+[Action]
+Clarify: "I can help with the API. Do you want to:
+A) Design new endpoints
+B) Fix an existing issue
+C) Review the current implementation"
+```
+
+### Example 4: Training Intent
+```
+User: "Learn this documentation: https://docs.stripe.com/api"
+
+[Intent Detection]
+Keywords: "learn", URL present
+Confidence: TRAINING = 0.95
+
+[Action]
+Activate: train-prompt skill
+Response: "I'll learn from the Stripe API documentation..."
+```
+
+## Context Awareness
+
+The router considers conversation history:
+
+- If previous message was about planning → lower threshold for planning-related follow-ups
+- If user just shared code → debugging/review more likely
+- If discussing architecture → planning/design more likely
+
+## Override Behavior
+
+Users can still use explicit commands to override:
+- `/plan` - Force planning mode
+- `/brainstorm` - Force brainstorming mode
+- `/fix` - Force debugging mode
+
+Explicit commands bypass intent detection.
+
+## Configuration
+
+Skills can declare their trigger conditions in their SKILL.md frontmatter:
+
+```yaml
+metadata: {
+  "openclaw": {
+    "triggers": {
+      "keywords": ["plan", "design", "architect"],
+      "patterns": ["how should I", "best way to"],
+      "confidence_boost": 0.1
+    }
+  }
+}
+```
+
+## Performance Notes
+
+- Intent detection runs in <50ms
+- Only loads full skill content after routing
+- Caches recent intent classifications
+- Batches multiple skill reads when needed

package/templates/discord/skills/train-prompt/SKILL.md

@@ -0,0 +1,306 @@
+---
+name: train-prompt
+description: Add new documents, links, or knowledge to train and expand bot capabilities
+user-invocable: true
+disable-model-invocation: false
+metadata: {"openclaw": {"always": true}}
+---
+
+# Train Prompt - Auto Learning System
+
+## Trigger Conditions
+
+Activate when user:
+- Says: "train", "learn", "add knowledge", "teach you"
+- Provides: URL, document link, file path
+- Requests: "remember this", "add this to your knowledge"
+- Commands: "/train", "/learn", "/add-doc"
+
+## Input Types Supported
+
+1. **URLs** - Web pages, documentation, articles
+2. **Files** - Markdown, PDF, text files
+3. **Inline content** - Direct text/instructions
+4. **GitHub repos** - Repository documentation
+
+## Workflow
+
+### Step 1: Detect Input Type
+
+```
+IF input contains URL → fetch_and_process_url
+IF input contains file path → read_and_process_file
+IF input is inline text → process_inline_content
+IF input is GitHub URL → clone_and_extract_docs
+```
+
+### Step 2: Process Content
+
+#### For URLs:
+1. Fetch URL content using `web_fetch` tool
+2. Extract main content (remove nav, ads, etc.)
+3. Convert to markdown format
+4. Identify key concepts and patterns
+
+#### For Files:
+1. Read file content
+2. Parse based on file type (md, pdf, txt)
+3. Extract structured information
+
+#### For Inline Content:
+1. Parse user's instructions
+2. Identify intent and knowledge type
+3. Structure as skill or reference
+
+### Step 3: Generate Skill/Reference
+
+Based on content type, create:
+
+**A) New Skill** (if content describes a workflow/process):
+```
+skills/<skill-name>/
+├── SKILL.md          ← Generated skill definition
+└── references/
+    └── source.md     ← Original content
+```
+
+**B) Reference Document** (if content is documentation):
+```
+skills/<parent-skill>/
+└── references/
+    └── <doc-name>.md ← Extracted knowledge
+```
+
+**C) Bootstrap Update** (if content is identity/rules):
+```
+Append to SOUL.md or AGENTS.md
+```
+
+### Step 4: Skill Generation Template
+
+For new skills, generate:
+
+```yaml
+---
+name: {extracted-name}
+description: {one-line-summary}
+user-invocable: true
+metadata: {"openclaw": {"always": true, "source": "{original-url-or-path}"}}
+---
+
+# {Skill Title}
+
+## Purpose
+{extracted-purpose}
+
+## Trigger Conditions
+Activate when user mentions:
+{extracted-keywords}
+
+## Workflow
+{extracted-steps}
+
+## Reference
+Source: {original-source}
+Added: {timestamp}
+```
+
+### Step 5: Confirm & Save
+
+1. Show preview of generated skill/reference
+2. Ask user to confirm or edit
+3. Save to appropriate location
+4. Update skill index
+
+## Commands
+
+### /train <url>
+Fetch and learn from a URL.
+
+Example:
+```
+/train https://docs.example.com/api-guide
+```
+
+### /train:file <path>
+Learn from a local file.
+
+Example:
+```
+/train:file ./docs/coding-standards.md
+```
+
+### /train:inline
+Learn from inline content.
+
+Example:
+```
+/train:inline
+When handling API errors:
+1. Log the error with context
+2. Return appropriate HTTP status
+3. Never expose internal details
+```
+
+### /train:github <repo-url>
+Extract knowledge from GitHub repository.
+
+Example:
+```
+/train:github https://github.com/example/repo
+```
+
+### /train:list
+Show all trained knowledge sources.
+
+### /train:remove <skill-name>
+Remove a trained skill.
+
+## Output Format
+
+After training:
+
+```markdown
+## Training Complete
+
+**Source:** {url-or-path}
+**Type:** {skill|reference|bootstrap}
+**Location:** {saved-path}
+
+### Generated Knowledge
+
+**Skill:** {skill-name}
+**Description:** {description}
+**Triggers:** {keyword-list}
+
+### Next Steps
+- Test with: "{example-trigger}"
+- Edit at: {file-path}
+- View all: /train:list
+```
+
+## Storage Structure
+
+```
+.discord/
+├── skills/
+│   ├── trained/                    ← Auto-generated skills
+│   │   ├── api-docs-example/
+│   │   │   ├── SKILL.md
+│   │   │   └── references/
+│   │   │       └── source.md
+│   │   └── coding-standards/
+│   │       └── SKILL.md
+│   └── train-prompt/               ← This skill
+│       └── SKILL.md
+├── knowledge/                      ← Reference documents
+│   ├── sources.json               ← Index of all sources
+│   └── docs/
+│       ├── doc-001.md
+│       └── doc-002.md
+└── SOUL.md                        ← Updated with rules
+```
+
+## Knowledge Index (sources.json)
+
+```json
+{
+  "sources": [
+    {
+      "id": "src-001",
+      "type": "url",
+      "source": "https://docs.example.com/api",
+      "skill": "api-docs-example",
+      "added": "2024-01-15T10:30:00Z",
+      "keywords": ["api", "rest", "endpoints"]
+    }
+  ],
+  "stats": {
+    "total_skills": 5,
+    "total_references": 12,
+    "last_updated": "2024-01-15T10:30:00Z"
+  }
+}
+```
+
+## Advanced Features
+
+### Auto-Refresh
+For URLs, optionally set up periodic refresh:
+```
+/train <url> --refresh=daily
+```
+
+### Merge Knowledge
+Combine multiple sources into one skill:
+```
+/train:merge skill-a skill-b --into=combined-skill
+```
+
+### Export Training
+Export all trained knowledge:
+```
+/train:export --format=zip
+```
+
+## Security Notes
+
+- Only fetch from trusted URLs
+- Sanitize all external content
+- Don't execute code from external sources
+- Review generated skills before enabling
+
+## Examples
+
+### Example 1: Train from API Documentation
+```
+User: /train https://stripe.com/docs/api
+
+Bot: Fetching Stripe API documentation...
+
+Training Complete!
+
+**Skill:** stripe-api
+**Triggers:** "stripe", "payment", "checkout", "subscription"
+**Capabilities:**
+- Create payment intents
+- Handle webhooks
+- Manage subscriptions
+
+Test with: "How do I create a Stripe checkout session?"
+```
+
+### Example 2: Train Custom Workflow
+```
+User: /train:inline
+Our deployment process:
+1. Run tests: npm test
+2. Build: npm run build
+3. Deploy staging: ./deploy.sh staging
+4. Smoke test staging
+5. Deploy prod: ./deploy.sh prod
+
+Bot: Training Complete!
+
+**Skill:** deployment-workflow
+**Triggers:** "deploy", "release", "staging", "production"
+
+Test with: "Help me deploy to staging"
+```
+
+### Example 3: Train from GitHub
+```
+User: /train:github https://github.com/company/styleguide
+
+Bot: Cloning repository...
+Found: README.md, CONTRIBUTING.md, docs/*.md
+
+Training Complete!
+
+**Skills Generated:**
+1. code-style (from style-guide.md)
+2. git-workflow (from CONTRIBUTING.md)
+3. project-setup (from README.md)
+
+Test with: "What's our code style for TypeScript?"
+```