@musashishao/agent-kit 1.8.1 → 1.9.0

package/.agent/skills/discord-bot-architect/SKILL.md

@@ -0,0 +1,447 @@
+---
+name: discord-bot-architect
+description: "Build Discord bots with Discord.js. Slash commands, events, buttons, modals, and database integration."
+version: "1.0.0"
+---
+
+# 🤖 Discord Bot Architect
+
+You are a Discord bot developer who builds engaging community bots. You understand Discord.js v14+, slash commands, interactions, and best practices for scalable bots.
+
+---
+
+## When to Use This Skill
+
+- Building community management bots
+- Game integration bots
+- Moderation and admin tools
+- Music and entertainment bots
+- AI-powered conversation bots
+- Utility and productivity bots
+
+---
+
+## Capabilities
+
+- `discord-js`
+- `slash-commands`
+- `buttons-modals`
+- `embeds`
+- `events`
+- `database-integration`
+
+---
+
+## 1. Project Setup
+
+```bash
+npm init -y
+npm install discord.js dotenv
+npm install -D typescript @types/node
+```
+
+### Bot Structure
+
+```
+discord-bot/
+├── src/
+│   ├── index.ts           # Entry point
+│   ├── commands/          # Slash commands
+│   │   ├── ping.ts
+│   │   └── help.ts
+│   ├── events/            # Event handlers
+│   │   ├── ready.ts
+│   │   └── interactionCreate.ts
+│   ├── utils/
+│   │   └── deploy-commands.ts
+│   └── types/
+│       └── index.ts
+├── .env
+├── package.json
+└── tsconfig.json
+```
+
+---
+
+## 2. Bot Client Setup
+
+```typescript
+// src/index.ts
+import { Client, GatewayIntentBits, Collection } from 'discord.js';
+import { config } from 'dotenv';
+import { loadCommands } from './utils/loadCommands';
+import { loadEvents } from './utils/loadEvents';
+
+config();
+
+const client = new Client({
+  intents: [
+    GatewayIntentBits.Guilds,
+    GatewayIntentBits.GuildMessages,
+    GatewayIntentBits.GuildMembers,
+    GatewayIntentBits.MessageContent,
+  ],
+});
+
+// Extend client with commands collection
+declare module 'discord.js' {
+  export interface Client {
+    commands: Collection<string, Command>;
+  }
+}
+
+client.commands = new Collection();
+
+async function main() {
+  await loadCommands(client);
+  await loadEvents(client);
+  
+  await client.login(process.env.DISCORD_TOKEN);
+}
+
+main().catch(console.error);
+```
+
+---
+
+## 3. Slash Commands
+
+```typescript
+// src/commands/ping.ts
+import { SlashCommandBuilder, ChatInputCommandInteraction } from 'discord.js';
+
+export const data = new SlashCommandBuilder()
+  .setName('ping')
+  .setDescription('Check bot latency');
+
+export async function execute(interaction: ChatInputCommandInteraction) {
+  const sent = await interaction.reply({ 
+    content: 'Pinging...', 
+    fetchReply: true 
+  });
+  
+  const latency = sent.createdTimestamp - interaction.createdTimestamp;
+  const apiLatency = interaction.client.ws.ping;
+  
+  await interaction.editReply(
+    `🏓 Pong! Latency: ${latency}ms | API: ${apiLatency}ms`
+  );
+}
+```
+
+### Command with Options
+
+```typescript
+// src/commands/user.ts
+import { SlashCommandBuilder, ChatInputCommandInteraction, EmbedBuilder } from 'discord.js';
+
+export const data = new SlashCommandBuilder()
+  .setName('user')
+  .setDescription('Get user information')
+  .addUserOption(option =>
+    option
+      .setName('target')
+      .setDescription('The user to get info about')
+      .setRequired(false)
+  );
+
+export async function execute(interaction: ChatInputCommandInteraction) {
+  const target = interaction.options.getUser('target') ?? interaction.user;
+  const member = await interaction.guild?.members.fetch(target.id);
+  
+  const embed = new EmbedBuilder()
+    .setColor(0x5865F2)
+    .setTitle(`User Info: ${target.username}`)
+    .setThumbnail(target.displayAvatarURL())
+    .addFields(
+      { name: 'ID', value: target.id, inline: true },
+      { name: 'Joined', value: member?.joinedAt?.toDateString() ?? 'N/A', inline: true },
+      { name: 'Created', value: target.createdAt.toDateString(), inline: true },
+      { name: 'Roles', value: member?.roles.cache.map(r => r.name).join(', ') ?? 'N/A' }
+    )
+    .setTimestamp();
+  
+  await interaction.reply({ embeds: [embed] });
+}
+```
+
+---
+
+## 4. Buttons and Modals
+
+```typescript
+// src/commands/feedback.ts
+import { 
+  SlashCommandBuilder, 
+  ActionRowBuilder, 
+  ButtonBuilder, 
+  ButtonStyle,
+  ModalBuilder,
+  TextInputBuilder,
+  TextInputStyle,
+  ChatInputCommandInteraction,
+  ButtonInteraction,
+  ModalSubmitInteraction
+} from 'discord.js';
+
+export const data = new SlashCommandBuilder()
+  .setName('feedback')
+  .setDescription('Send feedback to the team');
+
+export async function execute(interaction: ChatInputCommandInteraction) {
+  const row = new ActionRowBuilder<ButtonBuilder>()
+    .addComponents(
+      new ButtonBuilder()
+        .setCustomId('feedback_bug')
+        .setLabel('Report Bug')
+        .setStyle(ButtonStyle.Danger)
+        .setEmoji('🐛'),
+      new ButtonBuilder()
+        .setCustomId('feedback_feature')
+        .setLabel('Feature Request')
+        .setStyle(ButtonStyle.Primary)
+        .setEmoji('💡'),
+      new ButtonBuilder()
+        .setCustomId('feedback_other')
+        .setLabel('Other')
+        .setStyle(ButtonStyle.Secondary)
+    );
+  
+  await interaction.reply({
+    content: 'What type of feedback do you have?',
+    components: [row],
+  });
+}
+
+// Button handler
+export async function handleButton(interaction: ButtonInteraction) {
+  if (!interaction.customId.startsWith('feedback_')) return;
+  
+  const type = interaction.customId.replace('feedback_', '');
+  
+  const modal = new ModalBuilder()
+    .setCustomId(`feedback_modal_${type}`)
+    .setTitle(`${type.charAt(0).toUpperCase() + type.slice(1)} Feedback`);
+  
+  const titleInput = new TextInputBuilder()
+    .setCustomId('title')
+    .setLabel('Title')
+    .setStyle(TextInputStyle.Short)
+    .setRequired(true);
+  
+  const descriptionInput = new TextInputBuilder()
+    .setCustomId('description')
+    .setLabel('Description')
+    .setStyle(TextInputStyle.Paragraph)
+    .setRequired(true);
+  
+  modal.addComponents(
+    new ActionRowBuilder<TextInputBuilder>().addComponents(titleInput),
+    new ActionRowBuilder<TextInputBuilder>().addComponents(descriptionInput)
+  );
+  
+  await interaction.showModal(modal);
+}
+
+// Modal handler
+export async function handleModal(interaction: ModalSubmitInteraction) {
+  if (!interaction.customId.startsWith('feedback_modal_')) return;
+  
+  const title = interaction.fields.getTextInputValue('title');
+  const description = interaction.fields.getTextInputValue('description');
+  
+  // Save to database
+  await saveFeedback({
+    userId: interaction.user.id,
+    title,
+    description,
+    type: interaction.customId.replace('feedback_modal_', ''),
+  });
+  
+  await interaction.reply({
+    content: '✅ Thank you for your feedback!',
+    ephemeral: true,
+  });
+}
+```
+
+---
+
+## 5. Event Handlers
+
+```typescript
+// src/events/ready.ts
+import { Client, Events } from 'discord.js';
+
+export const name = Events.ClientReady;
+export const once = true;
+
+export function execute(client: Client<true>) {
+  console.log(`✅ Logged in as ${client.user.tag}`);
+  
+  // Set presence
+  client.user.setPresence({
+    activities: [{ name: '/help', type: 0 }],
+    status: 'online',
+  });
+}
+
+// src/events/interactionCreate.ts
+import { Events, Interaction } from 'discord.js';
+
+export const name = Events.InteractionCreate;
+
+export async function execute(interaction: Interaction) {
+  if (interaction.isChatInputCommand()) {
+    const command = interaction.client.commands.get(interaction.commandName);
+    
+    if (!command) {
+      console.error(`Command ${interaction.commandName} not found.`);
+      return;
+    }
+    
+    try {
+      await command.execute(interaction);
+    } catch (error) {
+      console.error(error);
+      
+      const reply = {
+        content: 'There was an error executing this command!',
+        ephemeral: true,
+      };
+      
+      if (interaction.replied || interaction.deferred) {
+        await interaction.followUp(reply);
+      } else {
+        await interaction.reply(reply);
+      }
+    }
+  }
+  
+  if (interaction.isButton()) {
+    // Handle button interactions
+  }
+  
+  if (interaction.isModalSubmit()) {
+    // Handle modal submissions
+  }
+}
+```
+
+---
+
+## 6. Deploy Commands
+
+```typescript
+// src/utils/deploy-commands.ts
+import { REST, Routes } from 'discord.js';
+import fs from 'fs';
+import path from 'path';
+
+const commands = [];
+const commandsPath = path.join(__dirname, '../commands');
+const commandFiles = fs.readdirSync(commandsPath).filter(f => f.endsWith('.ts'));
+
+for (const file of commandFiles) {
+  const command = require(path.join(commandsPath, file));
+  commands.push(command.data.toJSON());
+}
+
+const rest = new REST({ version: '10' }).setToken(process.env.DISCORD_TOKEN!);
+
+async function deploy() {
+  try {
+    console.log(`Deploying ${commands.length} commands...`);
+    
+    // Guild commands (instant update, for development)
+    await rest.put(
+      Routes.applicationGuildCommands(
+        process.env.CLIENT_ID!,
+        process.env.GUILD_ID!
+      ),
+      { body: commands }
+    );
+    
+    // Global commands (takes ~1 hour to propagate)
+    // await rest.put(
+    //   Routes.applicationCommands(process.env.CLIENT_ID!),
+    //   { body: commands }
+    // );
+    
+    console.log('✅ Commands deployed!');
+  } catch (error) {
+    console.error(error);
+  }
+}
+
+deploy();
+```
+
+---
+
+## 7. Database Integration
+
+```typescript
+// src/db/index.ts
+import { PrismaClient } from '@prisma/client';
+
+export const prisma = new PrismaClient();
+
+// Command with database
+export async function execute(interaction: ChatInputCommandInteraction) {
+  // Get or create user
+  const user = await prisma.user.upsert({
+    where: { discordId: interaction.user.id },
+    update: {},
+    create: {
+      discordId: interaction.user.id,
+      username: interaction.user.username,
+    },
+  });
+  
+  // Update user stats
+  await prisma.user.update({
+    where: { id: user.id },
+    data: {
+      commandsUsed: { increment: 1 },
+      lastActive: new Date(),
+    },
+  });
+}
+```
+
+---
+
+## 8. Anti-Patterns
+
+### ❌ No Error Handling
+
+```typescript
+// WRONG
+await interaction.reply('Hello');
+
+// CORRECT
+try {
+  await interaction.reply('Hello');
+} catch (error) {
+  console.error('Reply failed:', error);
+}
+```
+
+### ❌ Not Using Ephemeral for Errors
+
+```typescript
+// WRONG
+await interaction.reply('Error occurred!');
+
+// CORRECT
+await interaction.reply({ content: 'Error!', ephemeral: true });
+```
+
+---
+
+## Related Skills
+
+- `nodejs-best-practices` - Node.js patterns
+- `database-design` - Persistence
+- `api-patterns` - API integration

package/.agent/skills/email-sequence/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: email-sequence
+description: "Strategies for building automated email flows. Covers onboarding, abandonment recovery, newsletter management, and deliverability optimization."
+version: "1.0.0"
+---
+
+# 📧 Email Sequence
+
+You are an Email Marketing Automator. You build "set and forget" flows that nurture leads, onboard users, and win back lost customers. You focus on deliverability, segmentation, and Timing.
+
+---
+
+## When to Use This Skill
+
+- Designing user onboarding email flows
+- Implementing cart or checkout abandonment recovery
+- Building educational email courses
+- Managing periodic newsletters
+- Re-engagement campaigns for inactive users
+
+---
+
+## Capabilities
+
+- `onboarding-flows`
+- `abandonment-recovery`
+- `email-segmentation`
+- `deliverability-optimization`
+- `personalized-dynamic-content`
+
+---
+
+## 1. The Onboarding Flow Pattern
+
+| Day | Subject | Goal |
+|-----|---------|------|
+| Day 0 | "Welcome to [App]! Here's your first step." | Verification + Immediate Value |
+| Day 1 | "How to [Core Feature] in 30 seconds." | Feature adoption |
+| Day 3 | "See how [User X] used [App] to save 5 hours." | Social proof + Inspiration |
+| Day 5 | "Questions? Let's jump on a call." | Objection handling / Sales |
+| Day 7 | "Your trial is ending. Don't lose your data." | Conversion to paid |
+
+---
+
+## 2. Deliverability Checklist
+
+- [ ] **SPF/DKIM/DMARC**: Ensure domain authentication is set up correctly.
+- [ ] **List Hygiene**: Regularly remove "ghost" subscribers (unopened for 90 days).
+- [ ] **Mobile-First**: Use single-column layouts that look great on phones.
+- [ ] **Unsubscribe**: Make it easy to leave (keeps you out of the Spam folder).
+
+---
+
+## 3. Automation Triggers
+
+```javascript
+// Triggering an Inngest or BullMQ flow for email
+inngest.send({
+  name: 'user/signed_up',
+  data: {
+    email: 'user@example.com',
+    plan: 'trial'
+  }
+})
+```
+
+---
+
+## Related Skills
+
+- `copywriting` - Writing the actual emails
+- `inngest` - Technical infrastructure for flows
+- `analytics-tracking` - Measuring open and click rates

package/.agent/skills/ethical-hacking-methodology/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: ethical-hacking-methodology
+description: "The complete phase-by-phase methodology for ethical hacking: Reconnaissance, Scanning, Gaining Access, Maintaining Access, and Clearing Tracks."
+version: "1.0.0"
+---
+
+# 🕵️ Ethical Hacking Methodology
+
+You are a professional penetration tester who follows a structured methodology to ensure comprehensive security audits. You understand that hacking is 80% preparation and 20% execution.
+
+---
+
+## The 5 Phases of Hacking
+
+### 1. Reconnaissance (Information Gathering)
+The most critical phase. Gathering as much data as possible about the target.
+- **Passive**: OSINT, Google Dorking, Whois, social media.
+- **Active**: Interacting directly with the target (e.g., calling the help desk).
+
+### 2. Scanning & Enumeration
+Identifying live systems, open ports, and services.
+- **Tools**: Nmap, Masscan, Netdiscover.
+- **Goal**: Find the entry point (e.g., an outdated WordPress version or an open FTP port).
+
+### 3. Gaining Access (Exploitation)
+Where the actual "hacking" happens.
+- **Web**: SQLi, XSS, IDOR.
+- **System**: Buffer overflows, default credentials.
+- **Social**: Phishing, Pretexting.
+
+### 4. Maintaining Access (Persistence)
+Ensuring you can get back in even if the system reboots.
+- **Methods**: Backdoors, Rootkits, new user accounts, scheduled tasks.
+
+### 5. Clearing Tracks
+Avoiding detection by the Blue Team/SOC.
+- **Actions**: Deleting logs, hiding files, tunneling traffic through VPNs/Tor.
+
+---
+
+## Cyber Kill Chain vs. Hacking Phases
+
+| Hacking Phase | Cyber Kill Chain |
+|---------------|------------------|
+| Reconnaissance | Recon |
+| Scanning | Weaponization |
+| Gaining Access | Delivery / Exploitation |
+| Maintaining Access | Installation / Command & Control |
+| Clearing Tracks | Action on Objectives |
+
+---
+
+## Best Practices
+
+| Rule | Rationale |
+|------|-----------|
+| **Get Permission** | Never hack anything you don't own or have explicit written consent for. |
+| **Document Everything** | A pentest is only as good as the Final Report. |
+| **Stay Within Scope** | Do not touch systems that are not explicitly mentioned in the contract. |
+
+---
+
+## Related Skills
+
+- `vulnerability-scanner` - For the Scanning phase
+- `red-team-tactics` - Advanced persistence and evasion
+- `burp-suite-testing` - Specialized web reconnaissance