clawpowers 1.1.4 → 2.2.0

package/src/skills/loader.ts

@@ -0,0 +1,193 @@
+/**
+ * ClawPowers Agent — Skill Loader
+ * Discovers skills from skill directories, validates SKILL.md frontmatter.
+ */
+
+import { readdirSync, readFileSync, existsSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import type { SkillManifest, SkillRequirements, Profile } from '../types.js';
+
+// ─── YAML Frontmatter Parser ──────────────────────────────────────────────────
+
+interface ParsedFrontmatter {
+  name?: string;
+  description?: string;
+  metadata?: {
+    openclaw?: {
+      requires?: {
+        bins?: string[];
+        env?: string[];
+        config?: string[];
+      };
+    };
+  };
+}
+
+/**
+ * Parse YAML frontmatter from a SKILL.md file content.
+ * Expects format: ---\n<yaml>\n---\n<content>
+ */
+export function parseFrontmatter(content: string): ParsedFrontmatter {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match?.[1]) {
+    return {};
+  }
+
+  const yamlText = match[1];
+  const result: ParsedFrontmatter = {};
+
+  // Simple YAML parser for our known structure
+  const lines = yamlText.split('\n');
+  let currentKey = '';
+  let inRequires = false;
+  let requiresKey = '';
+  const requires: { bins?: string[]; env?: string[]; config?: string[] } = {};
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === '' || trimmed.startsWith('#')) continue;
+
+    // Top-level keys
+    const topLevel = line.match(/^(\w+):\s*(.*)$/);
+    if (topLevel?.[1]) {
+      currentKey = topLevel[1];
+      const val = topLevel[2]?.trim().replace(/^["']|["']$/g, '') ?? '';
+      if (currentKey === 'name' && val) result.name = val;
+      if (currentKey === 'description' && val) result.description = val;
+      inRequires = false;
+      continue;
+    }
+
+    // metadata.openclaw.requires detection
+    if (trimmed === 'openclaw:') continue;
+    if (trimmed === 'requires:') {
+      inRequires = true;
+      continue;
+    }
+
+    if (inRequires) {
+      const reqKey = trimmed.match(/^(\w+):\s*(.*)$/);
+      if (reqKey?.[1]) {
+        requiresKey = reqKey[1];
+        // Inline array: bins: ["node", "git"]
+        const inlineArr = reqKey[2]?.match(/\[(.*)\]/);
+        if (inlineArr?.[1]) {
+          const items = inlineArr[1].split(',').map(s => s.trim().replace(/^["']|["']$/g, ''));
+          if (requiresKey === 'bins') requires.bins = items;
+          if (requiresKey === 'env') requires.env = items;
+          if (requiresKey === 'config') requires.config = items;
+        }
+        continue;
+      }
+      // List item under requires key
+      const listItem = trimmed.match(/^-\s*["']?(.+?)["']?$/);
+      if (listItem?.[1] && requiresKey) {
+        if (requiresKey === 'bins') {
+          requires.bins = requires.bins ?? [];
+          requires.bins.push(listItem[1]);
+        }
+        if (requiresKey === 'env') {
+          requires.env = requires.env ?? [];
+          requires.env.push(listItem[1]);
+        }
+        if (requiresKey === 'config') {
+          requires.config = requires.config ?? [];
+          requires.config.push(listItem[1]);
+        }
+      }
+    }
+  }
+
+  if (Object.keys(requires).length > 0) {
+    result.metadata = { openclaw: { requires } };
+  }
+
+  return result;
+}
+
+// ─── Skill Discovery ──────────────────────────────────────────────────────────
+
+/**
+ * Load a single skill manifest from a directory containing SKILL.md
+ */
+export function loadSkillManifest(skillDir: string): SkillManifest | null {
+  const skillMdPath = join(skillDir, 'SKILL.md');
+  if (!existsSync(skillMdPath)) {
+    return null;
+  }
+
+  const content = readFileSync(skillMdPath, 'utf-8');
+  const frontmatter = parseFrontmatter(content);
+
+  if (!frontmatter.name || !frontmatter.description) {
+    return null;
+  }
+
+  let requirements: SkillRequirements | null = null;
+  const req = frontmatter.metadata?.openclaw?.requires;
+  if (req) {
+    requirements = {
+      bins: req.bins ?? [],
+      env: req.env ?? [],
+      config: req.config ?? [],
+    };
+  }
+
+  return {
+    name: frontmatter.name,
+    description: frontmatter.description,
+    path: skillDir,
+    requirements,
+  };
+}
+
+/**
+ * Discover all skills in a directory. Each subdirectory with a valid SKILL.md
+ * becomes a skill manifest.
+ */
+export function discoverSkills(skillsDir: string): SkillManifest[] {
+  if (!existsSync(skillsDir)) {
+    return [];
+  }
+
+  const entries = readdirSync(skillsDir);
+  const manifests: SkillManifest[] = [];
+
+  for (const entry of entries) {
+    const fullPath = join(skillsDir, entry);
+    if (!statSync(fullPath).isDirectory()) continue;
+
+    const manifest = loadSkillManifest(fullPath);
+    if (manifest) {
+      manifests.push(manifest);
+    }
+  }
+
+  return manifests.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+/**
+ * Filter skills based on active profile.
+ * Returns only skills that are listed in the profile's skill list.
+ */
+export function getActiveSkills(
+  allSkills: SkillManifest[],
+  profile: Profile
+): SkillManifest[] {
+  const profileSkillSet = new Set(profile.skills);
+  return allSkills.filter(skill => profileSkillSet.has(skill.name));
+}
+
+/**
+ * List skills with their active/inactive status for a given profile.
+ */
+export function listSkillsWithStatus(
+  allSkills: SkillManifest[],
+  profile: Profile
+): Array<{ skill: SkillManifest; active: boolean }> {
+  const profileSkillSet = new Set(profile.skills);
+  return allSkills.map(skill => ({
+    skill,
+    active: profileSkillSet.has(skill.name),
+  }));
+}

package/.claude-plugin/manifest.json

@@ -1,19 +0,0 @@
-{
-  "name": "clawpowers",
-  "version": "1.0.0",
-  "description": "Skills framework with runtime execution, persistent memory, self-improvement, and agent payments.",
-  "author": "AI Agent Economy",
-  "homepage": "https://github.com/up2itnow0822/clawpowers",
-  "license": "MIT",
-  "hooks": {
-    "session_start": "hooks/session-start"
-  },
-  "skills_directory": "skills/",
-  "runtime_directory": "runtime/",
-  "capabilities": [
-    "skill_injection",
-    "persistent_state",
-    "outcome_metrics",
-    "rsi_feedback"
-  ]
-}

package/.codex/INSTALL.md

@@ -1,36 +0,0 @@
-# ClawPowers for Codex — Installation
-
-Fetch and follow these instructions to install ClawPowers skills in your Codex session.
-
-## Quick Install
-
-Paste this into your Codex session:
-
-```
-Fetch and follow instructions from https://raw.githubusercontent.com/up2itnow0822/clawpowers/main/.codex/INSTALL.md
-```
-
-## What Gets Installed
-
-ClawPowers injects 20 skills into your agent context:
-
-- **14 Core Development Skills** — TDD, subagent orchestration, systematic debugging, code review, git worktrees, planning, and more
-- **6 Extended Skills** — Agent payments (x402), security auditing, content pipeline, market intelligence, lead prospecting, and metacognitive learning
-
-## Manual Setup
-
-If the quick install fails, copy the contents of `skills/using-clawpowers/SKILL.md` from the repository root and paste it into your Codex session context.
-
-## Runtime Layer (Optional)
-
-For persistent memory and self-improvement features:
-
-```bash
-npx clawpowers init
-```
-
-This creates `~/.clawpowers/` with state, metrics, checkpoints, and feedback directories.
-
-## Skills Reference
-
-Once installed, skills activate automatically when Codex recognizes matching task patterns. See `skills/using-clawpowers/SKILL.md` for the full trigger map.

package/.cursor-plugin/manifest.json

@@ -1,21 +0,0 @@
-{
-  "name": "clawpowers",
-  "version": "1.0.0",
-  "description": "Skills framework with runtime execution, persistent memory, self-improvement, and agent payments for Cursor AI.",
-  "author": "AI Agent Economy",
-  "homepage": "https://github.com/up2itnow0822/clawpowers",
-  "license": "MIT",
-  "hooks": {
-    "session_start": "hooks/session-start"
-  },
-  "skills_directory": "skills/",
-  "runtime_directory": "runtime/",
-  "inject_on_start": true,
-  "inject_skill": "using-clawpowers",
-  "capabilities": [
-    "skill_injection",
-    "persistent_state",
-    "outcome_metrics",
-    "rsi_feedback"
-  ]
-}

package/.opencode/INSTALL.md

@@ -1,52 +0,0 @@
-# ClawPowers for OpenCode — Installation
-
-Fetch and follow these instructions to install ClawPowers skills in your OpenCode session.
-
-## Quick Install
-
-Paste this into your OpenCode session:
-
-```
-Fetch and follow instructions from https://raw.githubusercontent.com/up2itnow0822/clawpowers/main/.opencode/INSTALL.md
-```
-
-## What Gets Installed
-
-ClawPowers injects 20 skills into your agent context:
-
-- **14 Core Development Skills** — TDD, subagent orchestration, systematic debugging, code review, git worktrees, planning, and more
-- **6 Extended Skills** — Agent payments (x402), security auditing, content pipeline, market intelligence, lead prospecting, and metacognitive learning
-
-## Session Hook Setup
-
-To auto-inject ClawPowers on every OpenCode session start, add to your OpenCode configuration:
-
-```json
-{
-  "hooks": {
-    "session_start": "bash /path/to/clawpowers/hooks/session-start"
-  }
-}
-```
-
-## Manual Context Injection
-
-Copy the contents of `skills/using-clawpowers/SKILL.md` and prepend it to your OpenCode session context. This gives you all skill triggers without the runtime layer.
-
-## Runtime Layer (Optional)
-
-For persistent memory, outcome tracking, and self-improvement:
-
-```bash
-npx clawpowers init
-```
-
-Creates `~/.clawpowers/` with:
-- `state/` — cross-session key-value store
-- `metrics/` — JSONL outcome logs per skill
-- `checkpoints/` — resumable workflow state
-- `feedback/` — RSI analysis outputs
-
-## Skills Reference
-
-Skills activate on pattern recognition. See `skills/using-clawpowers/SKILL.md` for the full list of 20 skills and their trigger conditions.

package/ARCHITECTURE.md

@@ -1,69 +0,0 @@
-# ClawPowers Architecture
-
-## Design Principles
-
-1. **Skills execute, not just instruct.** Every skill can invoke tools, persist state, and measure outcomes.
-2. **Simplicity is a feature.** Complex functionality, simple interface. One SKILL.md per skill. Zero mandatory dependencies.
-3. **Progressive enhancement.** Works as static markdown (like competitors). Gains runtime powers when the persistence layer is available.
-4. **Platform-agnostic.** Same skills, same format, every platform: Claude Code, Cursor, Codex, OpenCode, Gemini CLI.
-5. **Self-improving.** The system gets better at helping you the more you use it.
-
-## Skill Format
-
-Every skill is a directory containing a `SKILL.md` with YAML frontmatter:
-
-```yaml
----
-name: skill-name
-description: When to trigger this skill
-version: 1.0.0
-requires:
-  tools: []          # Optional: CLI tools needed (e.g., git, npm, trivy)
-  runtime: false     # Optional: true if skill needs persistence layer
-metrics:
-  tracks: []         # What outcomes this skill measures
-  improves: []       # What parameters RSI can adjust
----
-```
-
-## Runtime Layer (Optional, Additive)
-
-The runtime layer lives at `~/.clawpowers/` and provides three services:
-
-### 1. Persistence (`runtime/persistence/`)
-- File-based key-value store for cross-session state
-- Checkpoint system for resumable workflows
-- Schema: flat file key-value store under `state/`
-
-### 2. Metrics (`runtime/metrics/`)
-- Outcome tracking per skill execution
-- Time-to-completion, success rate, error patterns
-- Statistical process control for anomaly detection
-- Export to JSON for dashboard consumption
-
-### 3. Feedback (`runtime/feedback/`)
-- RSI engine: measure → analyze → adapt cycle
-- Parameter adjustment recommendations
-- Skill effectiveness scoring
-- Anti-pattern detection from execution history
-
-## Session Hook
-
-The session-start hook (`hooks/session-start`) injects the `using-clawpowers` skill content into the agent context. This is the only mandatory injection — all other skills load on-demand via trigger matching.
-
-The hook:
-1. Detects platform (Claude Code, Cursor, Codex, OpenCode, Gemini)
-2. Reads `skills/using-clawpowers/SKILL.md`
-3. Outputs platform-appropriate JSON for context injection
-4. Optionally initializes persistence layer if not present
-
-## Graceful Degradation
-
-If the runtime layer is not installed:
-- Skills still function as static methodology guides (same as competitors)
-- Persistence features degrade to session-only memory
-- Metrics are not collected
-- RSI feedback is not available
-- All extended skills that require tool execution note the limitation
-
-This means ClawPowers works everywhere Superpowers works, and does more everywhere the runtime is available.