@wabot-dev/create 0.0.3 → 2.0.0-beta.0

package/lib/skills/install.mjs

@@ -2,7 +2,8 @@ import fs from 'fs/promises'
 import os from 'os'
 import path from 'path'
 
-import { getSkill, listSkillNames } from './registry.mjs'
+import { getSkill, listSkillNames, listSkills } from './registry.mjs'
+import { resolveFrameworkSkillsDir } from './framework-source.mjs'
 
 const supportedAgents = {
   codex: ['.codex', 'skills'],
@@ -10,12 +11,75 @@ const supportedAgents = {
   agents: ['.agents', 'skills'],
 }
 
+export function listSupportedAgents() {
+  return Object.keys(supportedAgents)
+}
+
+export async function installSkillsInProject(projectDir, agents, skillNames) {
+  if (!projectDir) {
+    throw new Error('installSkillsInProject: projectDir is required')
+  }
+
+  const resolvedAgents = (agents && agents.length > 0 ? agents : ['claude']).map((agent) => {
+    if (!supportedAgents[agent]) {
+      throw new Error(
+        `Unsupported agent "${agent}". Supported: ${Object.keys(supportedAgents).join(', ')}`,
+      )
+    }
+    return agent
+  })
+
+  const skillsDir = resolveFrameworkSkillsDir(projectDir)
+  const skills =
+    skillNames && skillNames.length > 0
+      ? skillNames.map((name) => requireSkill(name, skillsDir))
+      : listSkills(skillsDir)
+
+  const installations = []
+
+  for (const agent of resolvedAgents) {
+    const baseDir = path.join(projectDir, ...supportedAgents[agent])
+    await fs.mkdir(baseDir, { recursive: true })
+
+    for (const skill of skills) {
+      const installDir = path.join(baseDir, skill.name)
+      try {
+        await fs.cp(skill.sourceDir, installDir, {
+          recursive: true,
+          force: false,
+          errorOnExist: true,
+        })
+        installations.push({ agent, skill: skill.name, installDir, status: 'installed' })
+      } catch (error) {
+        if (error?.code === 'ERR_FS_CP_EEXIST' || error?.code === 'EEXIST') {
+          installations.push({ agent, skill: skill.name, installDir, status: 'skipped' })
+          continue
+        }
+        throw error
+      }
+    }
+  }
+
+  return { agents: resolvedAgents, skills: skills.map((skill) => skill.name), installations }
+}
+
+function requireSkill(name, skillsDir) {
+  const skill = getSkill(name, skillsDir)
+  if (!skill) {
+    throw new Error(
+      `Unknown skill "${name}". Available skills: ${listSkillNames(skillsDir).join(', ')}`,
+    )
+  }
+  return skill
+}
+
 export async function installSkill(skillName, options, cwd = process.cwd()) {
-  const skill = getSkill(skillName)
+  const skillsDir = resolveFrameworkSkillsDir(cwd)
+  const skill = getSkill(skillName, skillsDir)
 
   if (!skill) {
     throw new Error(
-      `Unknown skill "${skillName}". Available skills: ${listSkillNames().join(', ')}`,
+      `Unknown skill "${skillName}". Available skills: ${listSkillNames(skillsDir).join(', ')}`,
     )
   }
 

package/lib/skills/registry.mjs

@@ -1,17 +1,34 @@
-import { fileURLToPath } from 'url'
+import fs from 'fs'
+import path from 'path'
 
-const skillDefinitions = {
-  'wabot-framework': {
-    name: 'wabot-framework',
-    sourceDir: fileURLToPath(new URL('../../skills/wabot-framework', import.meta.url)),
-    description: 'Wabot Framework packaged skill',
-  },
+import { resolveFrameworkSkillsDir } from './framework-source.mjs'
+
+// Skills are owned and versioned by @wabot-dev/framework. The registry discovers
+// them from the framework's packaged `skills/` directory rather than bundling its
+// own copy, so adding a skill upstream requires no change here.
+
+export function listSkillNames(skillsDir = resolveFrameworkSkillsDir()) {
+  return fs
+    .readdirSync(skillsDir, { withFileTypes: true })
+    .filter(
+      (entry) =>
+        entry.isDirectory() && fs.existsSync(path.join(skillsDir, entry.name, 'SKILL.md')),
+    )
+    .map((entry) => entry.name)
+    .sort()
 }
 
-export function getSkill(skillName) {
-  return skillDefinitions[skillName] ?? null
+export function listSkills(skillsDir = resolveFrameworkSkillsDir()) {
+  return listSkillNames(skillsDir).map((name) => ({
+    name,
+    sourceDir: path.join(skillsDir, name),
+  }))
 }
 
-export function listSkillNames() {
-  return Object.keys(skillDefinitions).sort()
-}
+export function getSkill(name, skillsDir = resolveFrameworkSkillsDir()) {
+  const sourceDir = path.join(skillsDir, name)
+  if (!fs.existsSync(path.join(sourceDir, 'SKILL.md'))) {
+    return null
+  }
+  return { name, sourceDir }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wabot-dev/create",
-  "version": "0.0.3",
+  "version": "2.0.0-beta.0",
   "description": "Project creator for Wabot Framework",
   "license": "ISC",
   "author": "",
@@ -11,9 +11,11 @@
   },
   "files": [
     "bin",
-    "lib",
-    "skills"
+    "lib"
   ],
+  "scripts": {
+    "test:smoke": "node scripts/smoke-skills-bulk-install.mjs && node scripts/smoke-skill-installer.mjs"
+  },
   "dependencies": {
     "chalk": "^5.4.1",
     "commander": "^14.0.0",

package/skills/wabot-framework/SKILL.md

@@ -1,32 +0,0 @@
----
-name: wabot-framework
-description: Use when building, reviewing, or debugging apps with @wabot-dev/framework. This skill is self-contained and includes offline examples for project setup, dependency injection, mindsets, external function modules, validation, persistence, chat controllers, REST and socket controllers, async commands, cron, auth, logger, and locking.
----
-
-# Wabot Framework
-
-Use this skill for Wabot application work. It is self-contained: read the bundled examples first and do not depend on web access for normal tasks.
-
-## How To Use
-
-Load the reference file that matches the request:
-
-- `references/quickstart.md` for project bootstrap and first run
-- `references/core-patterns.md` for dependency injection and service lifecycles
-- `references/mindset-and-chat.md` for bot personality, tools, and chat routing
-- `references/validation-and-data.md` for DTOs, validation, and `Mapper`
-- `references/persistence.md` for entities, repositories, and PostgreSQL persistence
-- `references/controllers-and-auth.md` for REST, socket, and JWT auth
-- `references/async-and-cron.md` for commands and scheduled work
-- `references/ops.md` for logger and locking
-- `references/full-example.md` for an end-to-end sales bot app
-
-## Rules
-
-- Keep prose in Spanish when explaining to the team.
-- Keep code identifiers in English.
-- Use `@wabot-dev/framework` imports in examples.
-- Do not invent APIs. If a detail is not covered by the bundled examples, say what is missing instead of guessing.
-- Keep controllers thin and push business logic into services or modules.
-- Use `@scoped()` only when request, chat, or socket isolation matters.
-- Prefer the smallest example that demonstrates the pattern.

package/skills/wabot-framework/agents/openai.yaml

@@ -1,5 +0,0 @@
-interface:
-  display_name: "Wabot Framework"
-  short_description: "Build apps with @wabot-dev/framework"
-  default_prompt: "Use this skill to implement, review, or debug Wabot applications using the bundled offline examples and reference files."
-

package/skills/wabot-framework/references/async-and-cron.md

@@ -1,57 +0,0 @@
-# Async And Cron
-
-Use this when scheduling work in the background or recurring jobs.
-
-## Command and handler
-
-```typescript
-import { command, commandHandler, type ICommandHandler } from '@wabot-dev/framework'
-import { isString } from '@wabot-dev/framework'
-
-@command('save-test-tag')
-export class SaveTestTag {
-  @isString()
-  value!: string
-}
-
-@commandHandler(SaveTestTag)
-export class SaveTestTagHandler implements ICommandHandler<SaveTestTag> {
-  constructor(private tags: TagRepository) {}
-
-  async handle(input: SaveTestTag) {
-    await this.tags.save(input.value)
-  }
-}
-```
-
-## Run or schedule a command
-
-```typescript
-import { Async } from '@wabot-dev/framework'
-
-const job = await async.runCommand(SaveTestTag, { value: 'hello' })
-await async.scheduleCommand(SaveTestTag, { value: 'later' }, { minutes: 10 })
-```
-
-## Cron handler
-
-```typescript
-import { cron } from '@wabot-dev/framework'
-
-@cron({ name: 'sync-leads', cron: '0 * * * *' })
-export class SyncLeadsCron {
-  constructor(private leadService: LeadService) {}
-
-  async handle() {
-    await this.leadService.sync()
-  }
-}
-```
-
-## Good practice
-
-- Use commands for one-off background work.
-- Use cron for repeated schedules.
-- Keep command DTOs validated and small.
-- Keep cron handlers idempotent because they can run many times.
-

package/skills/wabot-framework/references/controllers-and-auth.md

@@ -1,104 +0,0 @@
-# Controllers And Auth
-
-Use this when exposing HTTP endpoints, socket events, or protected routes.
-
-## REST controller
-
-```typescript
-import { IncomingMessage } from 'http'
-import { onPost, restController } from '@wabot-dev/framework'
-
-class PaymentService {
-  processWebhook(rawBody: string) {
-    return { ok: true, rawBody }
-  }
-}
-
-@restController('/webhooks/bold')
-export class BoldWebhookController {
-  constructor(private paymentService: PaymentService) {}
-
-  @onPost({
-    disableJsonParser: true,
-    disableUrlEncodedParser: true,
-  })
-  async receiveWebhook(request: IncomingMessage) {
-    const rawBody = await this.readRawBody(request)
-    return this.paymentService.processWebhook(rawBody)
-  }
-}
-```
-
-## Socket controller
-
-```typescript
-import { jwtHandshakeGuard, onSocketEvent, socketController } from '@wabot-dev/framework'
-
-@jwtHandshakeGuard()
-@socketController('/sales')
-export class SalesSocketController {
-  @onSocketEvent('message')
-  async onMessage(payload: { text: string }) {
-    return { ok: true, received: payload.text }
-  }
-}
-```
-
-## JWT and API key auth
-
-Use JWT when the client already has a signed token. Use API keys when the client should present a shared secret.
-
-```typescript
-import {
-  apiKeyGuard,
-  apiKeyHandshakeGuard,
-  jwtGuard,
-  jwtHandshakeGuard,
-  onGet,
-  onPost,
-  restController,
-  socketController,
-} from '@wabot-dev/framework'
-
-class CreateLeadDto {
-  name!: string
-}
-
-class LeadService {
-  async create(body: CreateLeadDto) {
-    return { created: true, lead: body }
-  }
-}
-
-@restController('/api/leads')
-export class LeadApiController {
-  constructor(private leadService: LeadService) {}
-
-  @apiKeyGuard()
-  @onGet()
-  async listLeads() {
-    return []
-  }
-
-  @jwtGuard()
-  @onPost()
-  async createLead(body: CreateLeadDto) {
-    return this.leadService.create(body)
-  }
-}
-
-@socketController('/lead-room')
-@jwtHandshakeGuard()
-export class LeadRoomSocketController {}
-
-@apiKeyHandshakeGuard()
-@socketController('/api-room')
-export class ApiRoomSocketController {}
-```
-
-## Rule of thumb
-
-- REST for request/response workflows, webhooks, and admin APIs.
-- Socket for live events and long-lived sessions.
-- JWT when the client already has a signed token.
-- API key when the client should present a shared secret.

package/skills/wabot-framework/references/core-patterns.md

@@ -1,83 +0,0 @@
-# Core Patterns
-
-Use this when deciding how to register and inject services.
-
-## Lifecycles
-
-| Decorator | Use for | Example |
-| --- | --- | --- |
-| `@singleton()` | Shared clients, repositories, config, caches | one DB repository for the app |
-| `@injectable()` | Stateless services and modules | calculators, adapters, helpers |
-| `@scoped(Lifecycle.ContainerScoped)` | Request/chat/socket-local state | auth context, request context |
-
-## Singleton example
-
-```typescript
-import { singleton } from '@wabot-dev/framework'
-
-@singleton()
-export class ProductRepository {
-  private products = new Map<string, string>()
-
-  save(id: string, name: string) {
-    this.products.set(id, name)
-  }
-}
-```
-
-## Injectable example
-
-```typescript
-import { injectable } from '@wabot-dev/framework'
-
-@injectable()
-export class QuoteCalculator {
-  total(base: number, discount: number) {
-    return base - base * discount
-  }
-}
-```
-
-## Scoped example
-
-```typescript
-import { Lifecycle, scoped } from '@wabot-dev/framework'
-
-@scoped(Lifecycle.ContainerScoped)
-export class RequestContext {
-  private userId?: string
-
-  setUserId(userId: string) {
-    this.userId = userId
-  }
-
-  requireUserId() {
-    if (!this.userId) throw new Error('Unauthorized')
-    return this.userId
-  }
-}
-```
-
-## Token injection
-
-```typescript
-import { container, inject, injectable } from '@wabot-dev/framework'
-
-container.register('SMTP_HOST', { useValue: 'smtp.example.com' })
-container.register('SMTP_PORT', { useValue: 587 })
-
-@injectable()
-export class Mailer {
-  constructor(
-    @inject('SMTP_HOST') private smtpHost: string,
-    @inject('SMTP_PORT') private smtpPort: number,
-  ) {}
-}
-```
-
-## Rule of thumb
-
-- Use singleton for shared infrastructure.
-- Use injectable for pure business logic.
-- Use scoped only when state must not leak across requests or chats.
-