@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/skills/adapters/local.js

@@ -0,0 +1,335 @@
+/**
+ * Local Registry Adapter
+ *
+ * Scans agentic/code/ for skill manifests and SKILL.md files.
+ * Also checks deployed skills in the current project's provider directory.
+ *
+ * @implements #539
+ */
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { getProviderDefinition, resolveProviderPathValue, } from '../../providers/provider-definitions.js';
+const _scriptDir = path.dirname(fileURLToPath(import.meta.url));
+const AIWG_ROOT = process.env.AIWG_ROOT || path.resolve(_scriptDir, '../../../');
+function resolveSkillFallbackPath(target, projectDir, name) {
+    const definition = getProviderDefinition(target);
+    if (!definition)
+        return path.join(projectDir, `.${target}/skills`, name);
+    const basePath = definition.skillNamespace.pathType === 'home-dir'
+        ? `~/${definition.skillNamespace.skillsBaseDir}`
+        : definition.skillNamespace.skillsBaseDir;
+    return path.join(resolveProviderPathValue(basePath, projectDir), name);
+}
+/**
+ * Parse YAML-like frontmatter from SKILL.md content
+ */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return {};
+    const result = {};
+    for (const line of match[1].split('\n')) {
+        const kv = line.match(/^(\w+):\s*(.+)$/);
+        if (kv) {
+            result[kv[1]] = kv[2].replace(/^['"]|['"]$/g, '');
+        }
+    }
+    return result;
+}
+/**
+ * Parse platforms from frontmatter value like "[claude-code, hermes, openclaw]"
+ */
+function parsePlatforms(value) {
+    if (!value)
+        return [];
+    return value
+        .replace(/^\[|\]$/g, '')
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+/**
+ * Extract triggers section from SKILL.md content
+ */
+function extractTriggers(content) {
+    const triggerSection = content.match(/## Triggers\n\n([\s\S]*?)(?:\n##|\n$)/);
+    if (!triggerSection)
+        return [];
+    return triggerSection[1]
+        .split('\n')
+        .filter((line) => line.startsWith('- '))
+        .map((line) => line.replace(/^- ["']?|["']?$/g, '').trim())
+        .filter(Boolean);
+}
+/**
+ * Recursively find all manifest.json files under a directory
+ */
+function findManifests(dir) {
+    const results = [];
+    if (!fs.existsSync(dir))
+        return results;
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            // Check for skills/manifest.json pattern
+            const manifestPath = path.join(fullPath, 'skills', 'manifest.json');
+            if (fs.existsSync(manifestPath)) {
+                results.push(manifestPath);
+            }
+            // Recurse into subdirectories
+            results.push(...findManifests(fullPath));
+        }
+    }
+    return results;
+}
+/**
+ * Deduplicate manifests — keep the shallowest path for each manifest
+ */
+function deduplicateManifests(paths) {
+    const seen = new Set();
+    return paths.filter((p) => {
+        if (seen.has(p))
+            return false;
+        seen.add(p);
+        return true;
+    });
+}
+export class LocalAdapter {
+    id = 'local';
+    name = 'Local (AIWG Installation)';
+    cachedSkills = null;
+    async isAvailable() {
+        return fs.existsSync(path.join(AIWG_ROOT, 'agentic', 'code'));
+    }
+    async list() {
+        if (this.cachedSkills)
+            return this.cachedSkills;
+        const skills = [];
+        const agenticDir = path.join(AIWG_ROOT, 'agentic', 'code');
+        if (!fs.existsSync(agenticDir))
+            return skills;
+        // Find all manifest.json files in frameworks/ and addons/
+        const frameworksDir = path.join(agenticDir, 'frameworks');
+        const addonsDir = path.join(agenticDir, 'addons');
+        const manifestPaths = deduplicateManifests([
+            ...findManifests(frameworksDir),
+            ...findManifests(addonsDir),
+        ]);
+        for (const manifestPath of manifestPaths) {
+            try {
+                const raw = fs.readFileSync(manifestPath, 'utf-8');
+                const manifest = JSON.parse(raw);
+                const skillsDir = path.dirname(manifestPath);
+                // Derive package name from path
+                // e.g., agentic/code/frameworks/sdlc-complete/skills/manifest.json → sdlc-complete
+                const parts = manifestPath.split(path.sep);
+                const frameworkIdx = parts.indexOf('frameworks');
+                const addonIdx = parts.indexOf('addons');
+                const packageName = frameworkIdx >= 0
+                    ? parts[frameworkIdx + 1]
+                    : addonIdx >= 0
+                        ? parts[addonIdx + 1]
+                        : manifest.name;
+                for (const skill of manifest.skills) {
+                    // Try to read SKILL.md for platform info
+                    const skillMdPath = path.join(skillsDir, skill.name, 'SKILL.md');
+                    let platforms = [];
+                    if (fs.existsSync(skillMdPath)) {
+                        const content = fs.readFileSync(skillMdPath, 'utf-8');
+                        const fm = parseFrontmatter(content);
+                        platforms = parsePlatforms(fm.platforms);
+                    }
+                    skills.push({
+                        name: skill.name,
+                        description: skill.description,
+                        source: 'local',
+                        package: packageName,
+                        platforms,
+                        installed: true,
+                    });
+                }
+            }
+            catch {
+                // Skip malformed manifests
+            }
+        }
+        // Also scan for SKILL.md files not in any manifest (standalone skills)
+        const skillMdPaths = this.findSkillMds(agenticDir);
+        const knownNames = new Set(skills.map((s) => s.name));
+        for (const skillMdPath of skillMdPaths) {
+            const skillName = path.basename(path.dirname(skillMdPath));
+            if (knownNames.has(skillName))
+                continue;
+            try {
+                const content = fs.readFileSync(skillMdPath, 'utf-8');
+                const fm = parseFrontmatter(content);
+                const platforms = parsePlatforms(fm.platforms);
+                // Extract description from first paragraph after frontmatter
+                const bodyMatch = content.match(/---\n\n# .+\n\n(.+)/);
+                const description = bodyMatch
+                    ? bodyMatch[1].slice(0, 120)
+                    : `Skill: ${skillName}`;
+                // Derive package
+                const parts = skillMdPath.split(path.sep);
+                const frameworkIdx = parts.indexOf('frameworks');
+                const addonIdx = parts.indexOf('addons');
+                const packageName = frameworkIdx >= 0
+                    ? parts[frameworkIdx + 1]
+                    : addonIdx >= 0
+                        ? parts[addonIdx + 1]
+                        : 'unknown';
+                skills.push({
+                    name: skillName,
+                    description,
+                    source: 'local',
+                    package: packageName,
+                    platforms,
+                    installed: true,
+                });
+            }
+            catch {
+                // Skip unreadable files
+            }
+        }
+        this.cachedSkills = skills;
+        return skills;
+    }
+    async search(query) {
+        const all = await this.list();
+        const q = query.toLowerCase();
+        return all.filter((s) => s.name.toLowerCase().includes(q) ||
+            s.description.toLowerCase().includes(q) ||
+            (s.package && s.package.toLowerCase().includes(q)));
+    }
+    async info(name) {
+        const all = await this.list();
+        const match = all.find((s) => s.name === name);
+        if (!match)
+            return undefined;
+        // Find the SKILL.md for full details
+        const agenticDir = path.join(AIWG_ROOT, 'agentic', 'code');
+        const skillMdPaths = this.findSkillMds(agenticDir);
+        const skillMdPath = skillMdPaths.find((p) => path.basename(path.dirname(p)) === name);
+        const details = { ...match };
+        if (skillMdPath) {
+            const content = fs.readFileSync(skillMdPath, 'utf-8');
+            details.path = skillMdPath;
+            details.triggers = extractTriggers(content);
+            details.content = content;
+        }
+        // Check manifest for scripts
+        const manifestPaths = deduplicateManifests([
+            ...findManifests(path.join(agenticDir, 'frameworks')),
+            ...findManifests(path.join(agenticDir, 'addons')),
+        ]);
+        for (const manifestPath of manifestPaths) {
+            try {
+                const raw = fs.readFileSync(manifestPath, 'utf-8');
+                const manifest = JSON.parse(raw);
+                const skillEntry = manifest.skills.find((s) => s.name === name);
+                if (skillEntry) {
+                    details.triggers = details.triggers?.length
+                        ? details.triggers
+                        : skillEntry.triggers;
+                    details.scripts = skillEntry.scripts;
+                    details.version = manifest.version;
+                    break;
+                }
+            }
+            catch {
+                // Skip
+            }
+        }
+        return details;
+    }
+    async install(name, options) {
+        const details = await this.info(name);
+        if (!details || !details.path) {
+            throw new Error(`Skill '${name}' not found in local registry`);
+        }
+        const target = options.target || 'claude';
+        const projectDir = options.projectDir;
+        // Use PlatformSkillResolver for cross-platform path resolution
+        let targetDir;
+        try {
+            const { PlatformSkillResolver } = await import('../../smiths/skillsmith/platform-resolver.js');
+            targetDir = PlatformSkillResolver.getSkillPath(target, projectDir, name);
+        }
+        catch {
+            targetDir = resolveSkillFallbackPath(target, projectDir, name);
+        }
+        // Copy skill directory to target
+        const sourceDir = path.dirname(details.path);
+        fs.mkdirSync(targetDir, { recursive: true });
+        const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(sourceDir, entry.name);
+            const destPath = path.join(targetDir, entry.name);
+            if (entry.isFile()) {
+                fs.copyFileSync(srcPath, destPath);
+            }
+            else if (entry.isDirectory()) {
+                fs.cpSync(srcPath, destPath, { recursive: true });
+            }
+        }
+        // Codex `agents/openai.yaml` UI sidecar (#1129 PUW-028).
+        // Additive — sidecar absence is graceful. Failures here are non-fatal.
+        if (target === 'codex') {
+            try {
+                const { emitCodexSidecar } = await import('../../smiths/skillsmith/codex-sidecar.js');
+                const skillMdPath = path.join(targetDir, 'SKILL.md');
+                let metadata = {};
+                try {
+                    const skillContent = fs.readFileSync(skillMdPath, 'utf8');
+                    const fmMatch = /^---\s*\n([\s\S]*?)\n---/.exec(skillContent);
+                    if (fmMatch) {
+                        const yaml = await import('js-yaml');
+                        const fm = yaml.load(fmMatch[1]);
+                        if (fm && typeof fm === 'object') {
+                            metadata = fm;
+                        }
+                    }
+                }
+                catch {
+                    // Frontmatter parse failure → fall through with empty metadata;
+                    // sidecar will use folder name as display_name.
+                }
+                await emitCodexSidecar(targetDir, metadata);
+            }
+            catch (err) {
+                // Sidecar emission must never block the deploy. Log and move on.
+                console.warn(`Warning: Codex sidecar emission failed for ${name}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    /**
+     * Find all SKILL.md files recursively
+     */
+    findSkillMds(dir) {
+        const results = [];
+        if (!fs.existsSync(dir))
+            return results;
+        const walk = (currentDir) => {
+            try {
+                const entries = fs.readdirSync(currentDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = path.join(currentDir, entry.name);
+                    if (entry.isDirectory()) {
+                        walk(fullPath);
+                    }
+                    else if (entry.name === 'SKILL.md') {
+                        results.push(fullPath);
+                    }
+                }
+            }
+            catch {
+                // Permission error or similar — skip
+            }
+        };
+        walk(dir);
+        return results;
+    }
+}
+//# sourceMappingURL=local.js.map

package/dist/src/skills/adapters/openclaw.js

@@ -0,0 +1,316 @@
+/**
+ * OpenClaw Registry Adapter
+ *
+ * Delegates to the `openclaw` CLI for skill operations.
+ * Parses CLI output to provide structured results.
+ * Falls back gracefully when OpenClaw is not installed.
+ *
+ * @implements #539
+ * @see https://docs.openclaw.ai
+ */
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { getProviderDefinition, resolveProviderPathValue, } from '../../providers/provider-definitions.js';
+function resolveSkillFallbackPath(target, projectDir, name) {
+    const definition = getProviderDefinition(target);
+    if (!definition)
+        return path.join(projectDir, `.${target}/skills`, name);
+    const basePath = definition.skillNamespace.pathType === 'home-dir'
+        ? `~/${definition.skillNamespace.skillsBaseDir}`
+        : definition.skillNamespace.skillsBaseDir;
+    return path.join(resolveProviderPathValue(basePath, projectDir), name);
+}
+/**
+ * Execute an openclaw CLI command and return stdout
+ */
+function runOpenClaw(args) {
+    try {
+        return execSync(`openclaw ${args}`, {
+            encoding: 'utf-8',
+            timeout: 30000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse openclaw skills list output into SkillResult[]
+ *
+ * Expected format is newline-separated entries. We handle both
+ * structured JSON output (if openclaw supports --json) and
+ * plain text output by scanning ~/.openclaw/skills/ directly.
+ */
+function parseSkillsFromDirectory() {
+    const results = [];
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const skillsDir = path.join(homeDir, '.openclaw', 'skills');
+    if (!fs.existsSync(skillsDir))
+        return results;
+    try {
+        for (const skillMdPath of findSkillMarkdownFiles(skillsDir)) {
+            const skillDir = path.dirname(skillMdPath);
+            const name = path.basename(skillDir);
+            const content = fs.readFileSync(skillMdPath, 'utf-8');
+            // Extract description from first paragraph after heading
+            const descMatch = content.match(/^# .+\n\n(.+)/m);
+            const description = descMatch
+                ? descMatch[1].slice(0, 120)
+                : `Skill: ${name}`;
+            // Extract platforms from frontmatter
+            const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+            let platforms = [];
+            if (fmMatch) {
+                const platformLine = fmMatch[1]
+                    .split('\n')
+                    .find((l) => l.startsWith('platforms:'));
+                if (platformLine) {
+                    platforms = platformLine
+                        .replace(/^platforms:\s*\[?/, '')
+                        .replace(/\]?\s*$/, '')
+                        .split(',')
+                        .map((s) => s.trim())
+                        .filter(Boolean);
+                }
+            }
+            results.push({
+                name,
+                description,
+                source: 'openclaw',
+                platforms,
+                installed: true,
+            });
+        }
+    }
+    catch {
+        // Permission error or similar
+    }
+    return results;
+}
+function findSkillMarkdownFiles(skillsDir) {
+    const found = [];
+    if (!fs.existsSync(skillsDir))
+        return found;
+    for (const entry of fs.readdirSync(skillsDir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const direct = path.join(skillsDir, entry.name, 'SKILL.md');
+        if (fs.existsSync(direct)) {
+            found.push(direct);
+            continue;
+        }
+        // OpenClaw supports one namespace level under ~/.openclaw/skills/
+        // (for example ~/.openclaw/skills/aiwg/<skill>/SKILL.md).
+        const namespaceDir = path.join(skillsDir, entry.name);
+        for (const child of fs.readdirSync(namespaceDir, { withFileTypes: true })) {
+            if (!child.isDirectory())
+                continue;
+            const nested = path.join(namespaceDir, child.name, 'SKILL.md');
+            if (fs.existsSync(nested))
+                found.push(nested);
+        }
+    }
+    return found;
+}
+function findSkillDir(name) {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+    const skillsDir = path.join(homeDir, '.openclaw', 'skills');
+    const direct = path.join(skillsDir, name);
+    if (fs.existsSync(path.join(direct, 'SKILL.md')))
+        return direct;
+    const namespaced = path.join(skillsDir, 'aiwg', name);
+    if (fs.existsSync(path.join(namespaced, 'SKILL.md')))
+        return namespaced;
+    if (fs.existsSync(skillsDir)) {
+        for (const skillMd of findSkillMarkdownFiles(skillsDir)) {
+            if (path.basename(path.dirname(skillMd)) === name)
+                return path.dirname(skillMd);
+        }
+    }
+    return null;
+}
+export class OpenClawAdapter {
+    id = 'openclaw';
+    name = 'OpenClaw CLI';
+    cachedSkills = null;
+    async isAvailable() {
+        // Check for openclaw CLI or the ~/.openclaw/skills/ directory
+        const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+        const openclawDir = path.join(homeDir, '.openclaw');
+        if (fs.existsSync(openclawDir))
+            return true;
+        try {
+            execSync('openclaw --version 2>/dev/null', { encoding: 'utf-8' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async list() {
+        if (this.cachedSkills)
+            return this.cachedSkills;
+        // Try openclaw CLI with JSON output first
+        const jsonOutput = runOpenClaw('skills list --json 2>/dev/null');
+        if (jsonOutput) {
+            try {
+                const parsed = JSON.parse(jsonOutput);
+                if (Array.isArray(parsed)) {
+                    this.cachedSkills = parsed.map((s) => ({
+                        name: s.name || s.id,
+                        description: s.description || '',
+                        source: 'openclaw',
+                        platforms: s.platforms || [],
+                        installed: true,
+                    }));
+                    return this.cachedSkills;
+                }
+            }
+            catch {
+                // Fall through to directory scan
+            }
+        }
+        // Fall back to reading ~/.openclaw/skills/ directly
+        this.cachedSkills = parseSkillsFromDirectory();
+        return this.cachedSkills;
+    }
+    async search(query) {
+        // Try CLI delegation first
+        const cliOutput = runOpenClaw(`skills search "${query}" --json 2>/dev/null`);
+        if (cliOutput) {
+            try {
+                const parsed = JSON.parse(cliOutput);
+                if (Array.isArray(parsed)) {
+                    return parsed.map((s) => ({
+                        name: s.name || s.id,
+                        description: s.description || '',
+                        source: 'openclaw',
+                        platforms: s.platforms || [],
+                        installed: s.installed ?? false,
+                    }));
+                }
+            }
+            catch {
+                // Fall through to local filter
+            }
+        }
+        // Fall back to filtering local skills
+        const all = await this.list();
+        const q = query.toLowerCase();
+        return all.filter((s) => s.name.toLowerCase().includes(q) ||
+            s.description.toLowerCase().includes(q));
+    }
+    async info(name) {
+        const skillDir = findSkillDir(name);
+        const skillMdPath = skillDir ? path.join(skillDir, 'SKILL.md') : '';
+        if (!skillMdPath || !fs.existsSync(skillMdPath)) {
+            // Try CLI
+            const cliOutput = runOpenClaw(`skills info "${name}" --json 2>/dev/null`);
+            if (cliOutput) {
+                try {
+                    const parsed = JSON.parse(cliOutput);
+                    return {
+                        name: parsed.name || name,
+                        description: parsed.description || '',
+                        source: 'openclaw',
+                        platforms: parsed.platforms || [],
+                        triggers: parsed.triggers || [],
+                        version: parsed.version,
+                    };
+                }
+                catch {
+                    return undefined;
+                }
+            }
+            return undefined;
+        }
+        const content = fs.readFileSync(skillMdPath, 'utf-8');
+        // Parse frontmatter
+        const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+        let platforms = [];
+        if (fmMatch) {
+            const platformLine = fmMatch[1]
+                .split('\n')
+                .find((l) => l.startsWith('platforms:'));
+            if (platformLine) {
+                platforms = platformLine
+                    .replace(/^platforms:\s*\[?/, '')
+                    .replace(/\]?\s*$/, '')
+                    .split(',')
+                    .map((s) => s.trim())
+                    .filter(Boolean);
+            }
+        }
+        // Extract triggers
+        const triggerSection = content.match(/## Triggers\n\n([\s\S]*?)(?:\n##|\n$)/);
+        const triggers = triggerSection
+            ? triggerSection[1]
+                .split('\n')
+                .filter((line) => line.startsWith('- '))
+                .map((line) => line.replace(/^- ["']?|["']?$/g, '').trim())
+                .filter(Boolean)
+            : [];
+        // Extract description
+        const descMatch = content.match(/^# .+\n\n(.+)/m);
+        const description = descMatch ? descMatch[1] : `Skill: ${name}`;
+        return {
+            name,
+            description,
+            source: 'openclaw',
+            platforms,
+            triggers,
+            path: skillMdPath,
+            content,
+            installed: true,
+        };
+    }
+    async install(name, options) {
+        // Try openclaw CLI install first
+        const cliResult = runOpenClaw(`skills install "${name}" 2>/dev/null`);
+        if (cliResult !== null) {
+            // CLI handled it — if target is different from openclaw, copy to target
+            if (options.target && options.target !== 'openclaw') {
+                const homeDir = process.env.HOME || process.env.USERPROFILE || '';
+                const sourceDir = path.join(homeDir, '.openclaw', 'skills', name);
+                if (fs.existsSync(sourceDir)) {
+                    await this.copyToTarget(name, sourceDir, options);
+                }
+            }
+            return;
+        }
+        // If CLI not available but skill exists in ~/.openclaw/skills/, copy it
+        const sourceDir = findSkillDir(name);
+        if (sourceDir && fs.existsSync(sourceDir)) {
+            await this.copyToTarget(name, sourceDir, options);
+            return;
+        }
+        throw new Error(`Skill '${name}' not found in OpenClaw. ` +
+            `Ensure it's installed via 'openclaw skills install ${name}' or available at ~/.openclaw/skills/${name}/ or ~/.openclaw/skills/aiwg/${name}/`);
+    }
+    async copyToTarget(name, sourceDir, options) {
+        const target = options.target || 'openclaw';
+        let targetDir;
+        try {
+            const { PlatformSkillResolver } = await import('../../smiths/skillsmith/platform-resolver.js');
+            targetDir = PlatformSkillResolver.getSkillPath(target, options.projectDir, name);
+        }
+        catch {
+            targetDir = resolveSkillFallbackPath(target, options.projectDir, name);
+        }
+        fs.mkdirSync(targetDir, { recursive: true });
+        const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+        for (const entry of entries) {
+            const srcPath = path.join(sourceDir, entry.name);
+            const destPath = path.join(targetDir, entry.name);
+            if (entry.isFile()) {
+                fs.copyFileSync(srcPath, destPath);
+            }
+            else if (entry.isDirectory()) {
+                fs.cpSync(srcPath, destPath, { recursive: true });
+            }
+        }
+    }
+}
+//# sourceMappingURL=openclaw.js.map