botlearn 0.0.1 → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 BotLearn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,25 +1,106 @@
 # botlearn
 
-Official Node.js SDK for [BotLearn.ai](https://www.botlearn.ai/) - AI-powered bot learning platform.
+BotLearn OpenClaw Skills SDK — types, validator, and utilities for `@botlearn/*` skill packages.
 
 ## Installation
 
 ```bash
+# Install the SDK (for building custom skills or tools)
 npm install botlearn
-# or
-pnpm add botlearn
-# or
-yarn add botlearn
+
+# Install individual skills into your Agent
+npm install @botlearn/google-search
+npm install @botlearn/code-gen
+clawhub install @botlearn/google-search
+```
+
+## Skills
+
+### Information Retrieval (5)
+
+| Skill | Description | Dependencies |
+|-------|-------------|-------------|
+| `@botlearn/google-search` | Web search query optimization and result curation | — |
+| `@botlearn/academic-search` | Academic paper discovery and literature review | google-search |
+| `@botlearn/rss-manager` | RSS/Atom feed monitoring, deduplication, and digest generation | — |
+| `@botlearn/twitter-intel` | Twitter/X intelligence gathering and trend analysis | — |
+| `@botlearn/reddit-tracker` | Reddit trend detection and cross-subreddit correlation | — |
+
+### Content Processing (5)
+
+| Skill | Description | Dependencies |
+|-------|-------------|-------------|
+| `@botlearn/summarizer` | Multi-format content summarization with discourse analysis | — |
+| `@botlearn/translator` | Context-aware translation with terminology management | — |
+| `@botlearn/rewriter` | Audience-adaptive content rewriting and style transformation | summarizer |
+| `@botlearn/keyword-extractor` | Multi-layer keyword and keyphrase extraction | — |
+| `@botlearn/sentiment-analyzer` | Aspect-level sentiment analysis with sarcasm detection | — |
+
+### Programming Assistance (5)
+
+| Skill | Description | Dependencies |
+|-------|-------------|-------------|
+| `@botlearn/code-gen` | Multi-language code generation with architecture-aware design | — |
+| `@botlearn/code-review` | Security, performance, and quality code review (OWASP Top 10) | — |
+| `@botlearn/debugger` | Systematic bug diagnosis and root cause analysis | code-review |
+| `@botlearn/refactor` | Design-pattern-driven code refactoring | code-review |
+| `@botlearn/doc-gen` | API documentation and README generation | code-gen |
+
+### Creative Generation (5)
+
+| Skill | Description | Dependencies |
+|-------|-------------|-------------|
+| `@botlearn/brainstorm` | Structured creative ideation (SCAMPER, Six Hats, TRIZ) | — |
+| `@botlearn/storyteller` | Narrative craft across genres and structures | — |
+| `@botlearn/writer` | Long-form article writing with argument frameworks | summarizer, keyword-extractor |
+| `@botlearn/copywriter` | Persuasion-framework-driven marketing copy | sentiment-analyzer |
+| `@botlearn/social-media` | Platform-native social media content creation | copywriter |
+
+## Skill Package Structure
+
+Each skill is an independent npm package with a standardized structure:
+
+```
+@botlearn/<skill-name>/        # npm package
+├── package.json               # npm package config
+├── manifest.json              # Skill metadata: category, benchmark dimension
+├── skill.md                   # Role definition, triggers, activation rules
+├── knowledge/
+│   ├── domain.md              # Domain expertise
+│   ├── best-practices.md      # Quality standards
+│   └── anti-patterns.md       # Common mistakes to avoid
+├── strategies/
+│   └── main.md                # Step-by-step behavioral strategy
+└── tests/
+    ├── smoke.json             # 1 task, < 60s, pass threshold 60/100
+    └── benchmark.json         # 10 tasks (3 easy, 4 medium, 3 hard)
 ```
 
-## Usage
+## SDK API
 
 ```typescript
-import { hello } from 'botlearn';
+import { validateManifest } from "botlearn";
+import type { SkillManifest, ValidationResult } from "botlearn";
 
-console.log(hello('Bot')); // Hello, Bot!
+// Validate a manifest
+const result: ValidationResult = validateManifest(manifest, knownSkillNames);
+console.log(result.valid, result.errors);
 ```
 
+## Publishing
+
+Each skill is published independently to npm:
+
+```bash
+cd packages/skills/google-search
+npm publish --access public    # publishes @botlearn/google-search
+```
+
+## Compatibility
+
+- OpenClaw Agent: `>=0.5.0`
+- Node.js: `>=18`
+
 ## License
 
 MIT

package/dist/index.cjs

@@ -0,0 +1,172 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  VALID_CATEGORIES: () => VALID_CATEGORIES,
+  VALID_DIMENSIONS: () => VALID_DIMENSIONS,
+  validateManifest: () => validateManifest
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/validator.ts
+var VALID_CATEGORIES = [
+  "information-retrieval",
+  "content-processing",
+  "programming-assistance",
+  "creative-generation"
+];
+var VALID_DIMENSIONS = [
+  "information-retrieval",
+  "content-understanding",
+  "logical-reasoning",
+  "code-generation",
+  "creative-generation"
+];
+var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?$/;
+var SEMVER_RANGE_RE = /^(?:[~^]?\d+\.\d+\.\d+(?:-[\w.]+)?|>=?\d+\.\d+\.\d+)$/;
+var SKILL_NAME_RE = /^@botlearn\/[a-z][a-z0-9-]*$/;
+function validateManifest(manifest, knownSkillNames) {
+  const errors = [];
+  if (manifest === null || typeof manifest !== "object") {
+    return { valid: false, errors: [{ field: "(root)", message: "Manifest must be a non-null object" }] };
+  }
+  const m = manifest;
+  requireString(m, "name", errors);
+  requireString(m, "version", errors);
+  requireString(m, "description", errors);
+  requireString(m, "author", errors);
+  if (typeof m.name === "string" && !SKILL_NAME_RE.test(m.name)) {
+    errors.push({
+      field: "name",
+      message: `Name must match @botlearn/<kebab-case>, got "${m.name}"`
+    });
+  }
+  if (typeof m.version === "string" && !SEMVER_RE.test(m.version)) {
+    errors.push({
+      field: "version",
+      message: `Version must be valid semver, got "${m.version}"`
+    });
+  }
+  if (!VALID_CATEGORIES.includes(m.category)) {
+    errors.push({
+      field: "category",
+      message: `Category must be one of: ${VALID_CATEGORIES.join(", ")}`
+    });
+  }
+  if (!VALID_DIMENSIONS.includes(m.benchmarkDimension)) {
+    errors.push({
+      field: "benchmarkDimension",
+      message: `benchmarkDimension must be one of: ${VALID_DIMENSIONS.join(", ")}`
+    });
+  }
+  if (typeof m.expectedImprovement !== "number" || m.expectedImprovement < 0) {
+    errors.push({
+      field: "expectedImprovement",
+      message: "expectedImprovement must be a non-negative number"
+    });
+  }
+  if (m.dependencies !== void 0) {
+    if (typeof m.dependencies !== "object" || m.dependencies === null) {
+      errors.push({
+        field: "dependencies",
+        message: "dependencies must be an object"
+      });
+    } else {
+      const deps = m.dependencies;
+      for (const [depName, depVersion] of Object.entries(deps)) {
+        if (!SKILL_NAME_RE.test(depName)) {
+          errors.push({
+            field: `dependencies.${depName}`,
+            message: `Dependency name must match @botlearn/<kebab-case>`
+          });
+        }
+        if (typeof depVersion !== "string" || !SEMVER_RANGE_RE.test(depVersion)) {
+          errors.push({
+            field: `dependencies.${depName}`,
+            message: `Dependency version must be a valid semver range, got "${String(depVersion)}"`
+          });
+        }
+        if (knownSkillNames && !knownSkillNames.includes(depName)) {
+          errors.push({
+            field: `dependencies.${depName}`,
+            message: `Unknown dependency "${depName}" \u2014 not in known skills list`
+          });
+        }
+      }
+    }
+  }
+  if (typeof m.compatibility !== "object" || m.compatibility === null) {
+    errors.push({
+      field: "compatibility",
+      message: "compatibility must be an object with an openclaw field"
+    });
+  } else {
+    const compat = m.compatibility;
+    if (typeof compat.openclaw !== "string" || !SEMVER_RANGE_RE.test(compat.openclaw)) {
+      errors.push({
+        field: "compatibility.openclaw",
+        message: `compatibility.openclaw must be a valid semver range`
+      });
+    }
+  }
+  if (typeof m.files !== "object" || m.files === null) {
+    errors.push({
+      field: "files",
+      message: "files must be an object"
+    });
+  } else {
+    const files = m.files;
+    requireString(files, "skill", errors, "files.skill");
+    requireStringArray(files, "knowledge", errors, "files.knowledge");
+    requireStringArray(files, "strategies", errors, "files.strategies");
+    requireString(files, "smokeTest", errors, "files.smokeTest");
+    requireString(files, "benchmark", errors, "files.benchmark");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function requireString(obj, field, errors, displayField) {
+  if (typeof obj[field] !== "string" || obj[field].length === 0) {
+    errors.push({
+      field: displayField ?? field,
+      message: `${displayField ?? field} is required and must be a non-empty string`
+    });
+  }
+}
+function requireStringArray(obj, field, errors, displayField) {
+  const val = obj[field];
+  if (!Array.isArray(val) || val.length === 0) {
+    errors.push({
+      field: displayField ?? field,
+      message: `${displayField ?? field} must be a non-empty array of strings`
+    });
+  } else if (val.some((item) => typeof item !== "string")) {
+    errors.push({
+      field: displayField ?? field,
+      message: `${displayField ?? field} must contain only strings`
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  VALID_CATEGORIES,
+  VALID_DIMENSIONS,
+  validateManifest
+});

package/dist/index.d.cts

@@ -0,0 +1,150 @@
+type SkillCategory = "information-retrieval" | "content-processing" | "programming-assistance" | "creative-generation";
+type BenchmarkDimension = "information-retrieval" | "content-understanding" | "logical-reasoning" | "code-generation" | "creative-generation";
+type Difficulty = "easy" | "medium" | "hard";
+type Priority = "high" | "medium" | "low";
+type SkillPhase = "retrieval" | "reasoning" | "verification" | "reflection";
+type IssueSeverity = "critical" | "high" | "medium" | "low";
+interface SkillManifest {
+    name: string;
+    version: string;
+    description: string;
+    category: SkillCategory;
+    author: string;
+    benchmarkDimension: BenchmarkDimension;
+    expectedImprovement: number;
+    dependencies: Record<string, string>;
+    compatibility: {
+        openclaw: string;
+    };
+    files: {
+        skill: string;
+        knowledge: string[];
+        strategies: string[];
+        smokeTest: string;
+        benchmark: string;
+    };
+}
+interface RubricItem {
+    criterion: string;
+    weight: number;
+    scoring: {
+        5: string;
+        3: string;
+        1: string;
+        0: string;
+    };
+}
+interface SmokeTestTask {
+    id: string;
+    description: string;
+    input: string;
+    rubric: RubricItem[];
+    passThreshold: number;
+}
+interface SmokeTest {
+    version: string;
+    timeout: number;
+    tasks: SmokeTestTask[];
+}
+interface BenchmarkTask {
+    id: string;
+    difficulty: Difficulty;
+    description: string;
+    input: string;
+    rubric: RubricItem[];
+    expectedScoreWithout: number;
+    expectedScoreWith: number;
+}
+interface BenchmarkTest {
+    version: string;
+    dimension: BenchmarkDimension;
+    tasks: BenchmarkTask[];
+}
+interface MemoryDocument {
+    id: string;
+    content: string;
+    metadata: {
+        domain: string;
+        topic: string;
+        priority: Priority;
+        ttl?: string;
+    };
+}
+interface MemoryInjectRequest {
+    skillName: string;
+    documents: MemoryDocument[];
+}
+interface MemoryInjectResponse {
+    injected: number;
+    skipped: number;
+    errors: string[];
+}
+interface MemoryRollbackRequest {
+    skillName: string;
+}
+interface StrategyDocument {
+    id: string;
+    content: string;
+    steps: number;
+}
+interface SkillRegisterRequest {
+    skillName: string;
+    definition: string;
+    strategies: StrategyDocument[];
+    triggers: string[];
+}
+interface SkillRegisterResponse {
+    registered: boolean;
+    activeSkills: string[];
+}
+interface SkillUnregisterRequest {
+    skillName: string;
+}
+interface BenchmarkRunRequest {
+    tasks: Array<{
+        id: string;
+        input: string;
+        rubric: RubricItem[];
+    }>;
+    judgeModel: string;
+    runs: number;
+}
+interface TaskResult {
+    taskId: string;
+    output: string;
+    scores: number[];
+    medianScore: number;
+    rubricBreakdown: Array<{
+        criterion: string;
+        score: number;
+        feedback: string;
+    }>;
+}
+interface BenchmarkRunResponse {
+    results: TaskResult[];
+    aggregateScore: number;
+}
+interface SkillError {
+    skill: string;
+    phase: SkillPhase;
+    message: string;
+    recoverable: boolean;
+    suggestion?: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+interface ValidationError {
+    field: string;
+    message: string;
+}
+
+declare const VALID_CATEGORIES: SkillCategory[];
+declare const VALID_DIMENSIONS: BenchmarkDimension[];
+/**
+ * Validate a SkillManifest object and return all discovered errors.
+ */
+declare function validateManifest(manifest: unknown, knownSkillNames?: string[]): ValidationResult;
+
+export { type BenchmarkDimension, type BenchmarkRunRequest, type BenchmarkRunResponse, type BenchmarkTask, type BenchmarkTest, type Difficulty, type IssueSeverity, type MemoryDocument, type MemoryInjectRequest, type MemoryInjectResponse, type MemoryRollbackRequest, type Priority, type RubricItem, type SkillCategory, type SkillError, type SkillManifest, type SkillPhase, type SkillRegisterRequest, type SkillRegisterResponse, type SkillUnregisterRequest, type SmokeTest, type SmokeTestTask, type StrategyDocument, type TaskResult, VALID_CATEGORIES, VALID_DIMENSIONS, type ValidationError, type ValidationResult, validateManifest };

package/dist/index.d.ts

@@ -1,10 +1,150 @@
+type SkillCategory = "information-retrieval" | "content-processing" | "programming-assistance" | "creative-generation";
+type BenchmarkDimension = "information-retrieval" | "content-understanding" | "logical-reasoning" | "code-generation" | "creative-generation";
+type Difficulty = "easy" | "medium" | "hard";
+type Priority = "high" | "medium" | "low";
+type SkillPhase = "retrieval" | "reasoning" | "verification" | "reflection";
+type IssueSeverity = "critical" | "high" | "medium" | "low";
+interface SkillManifest {
+    name: string;
+    version: string;
+    description: string;
+    category: SkillCategory;
+    author: string;
+    benchmarkDimension: BenchmarkDimension;
+    expectedImprovement: number;
+    dependencies: Record<string, string>;
+    compatibility: {
+        openclaw: string;
+    };
+    files: {
+        skill: string;
+        knowledge: string[];
+        strategies: string[];
+        smokeTest: string;
+        benchmark: string;
+    };
+}
+interface RubricItem {
+    criterion: string;
+    weight: number;
+    scoring: {
+        5: string;
+        3: string;
+        1: string;
+        0: string;
+    };
+}
+interface SmokeTestTask {
+    id: string;
+    description: string;
+    input: string;
+    rubric: RubricItem[];
+    passThreshold: number;
+}
+interface SmokeTest {
+    version: string;
+    timeout: number;
+    tasks: SmokeTestTask[];
+}
+interface BenchmarkTask {
+    id: string;
+    difficulty: Difficulty;
+    description: string;
+    input: string;
+    rubric: RubricItem[];
+    expectedScoreWithout: number;
+    expectedScoreWith: number;
+}
+interface BenchmarkTest {
+    version: string;
+    dimension: BenchmarkDimension;
+    tasks: BenchmarkTask[];
+}
+interface MemoryDocument {
+    id: string;
+    content: string;
+    metadata: {
+        domain: string;
+        topic: string;
+        priority: Priority;
+        ttl?: string;
+    };
+}
+interface MemoryInjectRequest {
+    skillName: string;
+    documents: MemoryDocument[];
+}
+interface MemoryInjectResponse {
+    injected: number;
+    skipped: number;
+    errors: string[];
+}
+interface MemoryRollbackRequest {
+    skillName: string;
+}
+interface StrategyDocument {
+    id: string;
+    content: string;
+    steps: number;
+}
+interface SkillRegisterRequest {
+    skillName: string;
+    definition: string;
+    strategies: StrategyDocument[];
+    triggers: string[];
+}
+interface SkillRegisterResponse {
+    registered: boolean;
+    activeSkills: string[];
+}
+interface SkillUnregisterRequest {
+    skillName: string;
+}
+interface BenchmarkRunRequest {
+    tasks: Array<{
+        id: string;
+        input: string;
+        rubric: RubricItem[];
+    }>;
+    judgeModel: string;
+    runs: number;
+}
+interface TaskResult {
+    taskId: string;
+    output: string;
+    scores: number[];
+    medianScore: number;
+    rubricBreakdown: Array<{
+        criterion: string;
+        score: number;
+        feedback: string;
+    }>;
+}
+interface BenchmarkRunResponse {
+    results: TaskResult[];
+    aggregateScore: number;
+}
+interface SkillError {
+    skill: string;
+    phase: SkillPhase;
+    message: string;
+    recoverable: boolean;
+    suggestion?: string;
+}
+interface ValidationResult {
+    valid: boolean;
+    errors: ValidationError[];
+}
+interface ValidationError {
+    field: string;
+    message: string;
+}
+
+declare const VALID_CATEGORIES: SkillCategory[];
+declare const VALID_DIMENSIONS: BenchmarkDimension[];
 /**
- * Botlearn - A Node.js toolkit for bot learning
- */
-declare const version = "0.0.1";
-/**
- * 示例函数
+ * Validate a SkillManifest object and return all discovered errors.
  */
-declare function hello(name?: string): string;
+declare function validateManifest(manifest: unknown, knownSkillNames?: string[]): ValidationResult;
 
-export { hello, version };
+export { type BenchmarkDimension, type BenchmarkRunRequest, type BenchmarkRunResponse, type BenchmarkTask, type BenchmarkTest, type Difficulty, type IssueSeverity, type MemoryDocument, type MemoryInjectRequest, type MemoryInjectResponse, type MemoryRollbackRequest, type Priority, type RubricItem, type SkillCategory, type SkillError, type SkillManifest, type SkillPhase, type SkillRegisterRequest, type SkillRegisterResponse, type SkillUnregisterRequest, type SmokeTest, type SmokeTestTask, type StrategyDocument, type TaskResult, VALID_CATEGORIES, VALID_DIMENSIONS, type ValidationError, type ValidationResult, validateManifest };

package/dist/index.js

@@ -1,36 +1,143 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+// src/validator.ts
+var VALID_CATEGORIES = [
+  "information-retrieval",
+  "content-processing",
+  "programming-assistance",
+  "creative-generation"
+];
+var VALID_DIMENSIONS = [
+  "information-retrieval",
+  "content-understanding",
+  "logical-reasoning",
+  "code-generation",
+  "creative-generation"
+];
+var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[\w.]+)?(?:\+[\w.]+)?$/;
+var SEMVER_RANGE_RE = /^(?:[~^]?\d+\.\d+\.\d+(?:-[\w.]+)?|>=?\d+\.\d+\.\d+)$/;
+var SKILL_NAME_RE = /^@botlearn\/[a-z][a-z0-9-]*$/;
+function validateManifest(manifest, knownSkillNames) {
+  const errors = [];
+  if (manifest === null || typeof manifest !== "object") {
+    return { valid: false, errors: [{ field: "(root)", message: "Manifest must be a non-null object" }] };
+  }
+  const m = manifest;
+  requireString(m, "name", errors);
+  requireString(m, "version", errors);
+  requireString(m, "description", errors);
+  requireString(m, "author", errors);
+  if (typeof m.name === "string" && !SKILL_NAME_RE.test(m.name)) {
+    errors.push({
+      field: "name",
+      message: `Name must match @botlearn/<kebab-case>, got "${m.name}"`
+    });
+  }
+  if (typeof m.version === "string" && !SEMVER_RE.test(m.version)) {
+    errors.push({
+      field: "version",
+      message: `Version must be valid semver, got "${m.version}"`
+    });
+  }
+  if (!VALID_CATEGORIES.includes(m.category)) {
+    errors.push({
+      field: "category",
+      message: `Category must be one of: ${VALID_CATEGORIES.join(", ")}`
+    });
+  }
+  if (!VALID_DIMENSIONS.includes(m.benchmarkDimension)) {
+    errors.push({
+      field: "benchmarkDimension",
+      message: `benchmarkDimension must be one of: ${VALID_DIMENSIONS.join(", ")}`
+    });
+  }
+  if (typeof m.expectedImprovement !== "number" || m.expectedImprovement < 0) {
+    errors.push({
+      field: "expectedImprovement",
+      message: "expectedImprovement must be a non-negative number"
+    });
+  }
+  if (m.dependencies !== void 0) {
+    if (typeof m.dependencies !== "object" || m.dependencies === null) {
+      errors.push({
+        field: "dependencies",
+        message: "dependencies must be an object"
+      });
+    } else {
+      const deps = m.dependencies;
+      for (const [depName, depVersion] of Object.entries(deps)) {
+        if (!SKILL_NAME_RE.test(depName)) {
+          errors.push({
+            field: `dependencies.${depName}`,
+            message: `Dependency name must match @botlearn/<kebab-case>`
+          });
+        }
+        if (typeof depVersion !== "string" || !SEMVER_RANGE_RE.test(depVersion)) {
+          errors.push({
+            field: `dependencies.${depName}`,
+            message: `Dependency version must be a valid semver range, got "${String(depVersion)}"`
+          });
+        }
+        if (knownSkillNames && !knownSkillNames.includes(depName)) {
+          errors.push({
+            field: `dependencies.${depName}`,
+            message: `Unknown dependency "${depName}" \u2014 not in known skills list`
+          });
+        }
+      }
+    }
+  }
+  if (typeof m.compatibility !== "object" || m.compatibility === null) {
+    errors.push({
+      field: "compatibility",
+      message: "compatibility must be an object with an openclaw field"
+    });
+  } else {
+    const compat = m.compatibility;
+    if (typeof compat.openclaw !== "string" || !SEMVER_RANGE_RE.test(compat.openclaw)) {
+      errors.push({
+        field: "compatibility.openclaw",
+        message: `compatibility.openclaw must be a valid semver range`
+      });
+    }
+  }
+  if (typeof m.files !== "object" || m.files === null) {
+    errors.push({
+      field: "files",
+      message: "files must be an object"
+    });
+  } else {
+    const files = m.files;
+    requireString(files, "skill", errors, "files.skill");
+    requireStringArray(files, "knowledge", errors, "files.knowledge");
+    requireStringArray(files, "strategies", errors, "files.strategies");
+    requireString(files, "smokeTest", errors, "files.smokeTest");
+    requireString(files, "benchmark", errors, "files.benchmark");
+  }
+  return { valid: errors.length === 0, errors };
+}
+function requireString(obj, field, errors, displayField) {
+  if (typeof obj[field] !== "string" || obj[field].length === 0) {
+    errors.push({
+      field: displayField ?? field,
+      message: `${displayField ?? field} is required and must be a non-empty string`
+    });
   }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  hello: () => hello,
-  version: () => version
-});
-module.exports = __toCommonJS(index_exports);
-var version = "0.0.1";
-function hello(name = "World") {
-  return `Hello, ${name}!`;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  hello,
-  version
-});
-//# sourceMappingURL=index.js.map
+function requireStringArray(obj, field, errors, displayField) {
+  const val = obj[field];
+  if (!Array.isArray(val) || val.length === 0) {
+    errors.push({
+      field: displayField ?? field,
+      message: `${displayField ?? field} must be a non-empty array of strings`
+    });
+  } else if (val.some((item) => typeof item !== "string")) {
+    errors.push({
+      field: displayField ?? field,
+      message: `${displayField ?? field} must contain only strings`
+    });
+  }
+}
+export {
+  VALID_CATEGORIES,
+  VALID_DIMENSIONS,
+  validateManifest
+};

package/package.json

@@ -1,45 +1,48 @@
 {
   "name": "botlearn",
-  "version": "0.0.1",
-  "description": "Official Node.js SDK for BotLearn.ai - AI-powered bot learning platform",
-  "homepage": "https://www.botlearn.ai",
-  "type": "commonjs",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "types": "./dist/index.d.ts",
+  "version": "0.1.0",
+  "description": "BotLearn OpenClaw Skills SDK — types, validator, and utilities for @botlearn/* skill packages",
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs",
-      "default": "./dist/index.js"
-    },
-    "./package.json": "./package.json"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
   },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "README.md"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "check-types": "tsc --noEmit",
-    "prepublishOnly": "pnpm build"
-  },
   "keywords": [
-    "bot",
-    "learning",
-    "toolkit"
+    "botlearn",
+    "openclaw",
+    "skills",
+    "agent"
   ],
-  "author": "",
+  "author": "BotLearn",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/readai-team/botlearn-awesome-skills.git",
+    "directory": "packages/botlearn"
+  },
+  "homepage": "https://github.com/readai-team/botlearn-awesome-skills/tree/main/packages/botlearn",
+  "bugs": {
+    "url": "https://github.com/readai-team/botlearn-awesome-skills/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "devDependencies": {
-    "@repo/typescript-config": "workspace:*",
-    "@types/node": "^22.10.5",
-    "tsup": "^8.3.5",
-    "typescript": "^5.7.3"
+    "tsup": "^8.0.0",
+    "typescript": "^5.4.0"
   },
-  "engines": {
-    "node": ">=18"
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit"
   }
-}
+}

package/dist/index.d.mts

@@ -1,10 +0,0 @@
-/**
- * Botlearn - A Node.js toolkit for bot learning
- */
-declare const version = "0.0.1";
-/**
- * 示例函数
- */
-declare function hello(name?: string): string;
-
-export { hello, version };

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Botlearn - A Node.js toolkit for bot learning\n */\n\nexport const version = '0.0.1';\n\n/**\n * 示例函数\n */\nexport function hello(name = 'World'): string {\n  return `Hello, ${name}!`;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIO,IAAM,UAAU;AAKhB,SAAS,MAAM,OAAO,SAAiB;AAC5C,SAAO,UAAU,IAAI;AACvB;","names":[]}

package/dist/index.mjs

@@ -1,10 +0,0 @@
-// src/index.ts
-var version = "0.0.1";
-function hello(name = "World") {
-  return `Hello, ${name}!`;
-}
-export {
-  hello,
-  version
-};
-//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/**\n * Botlearn - A Node.js toolkit for bot learning\n */\n\nexport const version = '0.0.1';\n\n/**\n * 示例函数\n */\nexport function hello(name = 'World'): string {\n  return `Hello, ${name}!`;\n}\n"],"mappings":";AAIO,IAAM,UAAU;AAKhB,SAAS,MAAM,OAAO,SAAiB;AAC5C,SAAO,UAAU,IAAI;AACvB;","names":[]}