@aiwg/cli 2026.7.19 → 2026.7.21

package/dist/src/skills/cli.js

@@ -11,12 +11,23 @@
  * @implements #539
  */
 import { spawn } from 'child_process';
-import { searchSkills, listSkills, getSkillInfo, installSkill, publishSkill, getAllAdapters, } from './registry.js';
+import { searchSkills, listSkills, getSkillInfo, installSkill, publishSkill, importSkillSource, getAllAdapters, } from './registry.js';
+import { AgentSkillImportError } from './importer.js';
+import { AgentSkillDeploymentError, deployImportedAgentSkill, uninstallImportedAgentSkill, } from './deployer.js';
+import { AgentSkillExportError, exportAgentSkillDirectory, } from './exporter.js';
+import { PROVIDER_IDS } from '../providers/provider-definitions.js';
 import { parseAgentSpawnFlags, buildAgentArgs, getProviderConfig, isSpawnableProvider, } from '../cli/agent-spawn.js';
-const SUPPORTED_TARGETS = [
-    'claude', 'copilot', 'factory', 'cursor', 'codex', 'opencode',
-    'warp', 'windsurf', 'openclaw', 'openhuman', 'hermes', 'generic',
-];
+const SUPPORTED_TARGETS = PROVIDER_IDS;
+export function importedSkillActivationError(details) {
+    if (!details.imported
+        || (details.imported.trust.state === 'trusted'
+            && details.imported.trust.activation === 'active')) {
+        return undefined;
+    }
+    return (`Imported skill '${details.name}' is `
+        + `${details.imported.trust.state}/${details.imported.trust.activation}. `
+        + `Explicitly trust and activate digest ${details.imported.digest} before execution.`);
+}
 /**
  * Parse --provider and --target flags from args
  */
@@ -131,6 +142,20 @@ async function handleInfo(args) {
         console.log('');
         console.log(`Path: ${details.path}`);
     }
+    if (details.imported) {
+        console.log('');
+        console.log(`Digest:       ${details.imported.digest}`);
+        console.log(`Profile:      ${details.imported.validationProfile}`);
+        console.log(`Trust:        ${details.imported.trust.state}`);
+        console.log(`Activation:   ${details.imported.trust.activation}`);
+        console.log(`Source kind:  ${details.imported.source.kind}`);
+        console.log(`Locator:      ${details.imported.source.locator}`);
+        if (details.imported.source.kind === 'git') {
+            console.log(`Subpath:      ${details.imported.source.subpath}`);
+            console.log(`Requested:    ${details.imported.source.requestedRevision}`);
+            console.log(`Resolved:     ${details.imported.source.resolvedRevision}`);
+        }
+    }
     console.log('');
 }
 /**
@@ -200,6 +225,416 @@ async function handleInstall(args) {
         process.exit(1);
     }
 }
+function parseImportArgs(args) {
+    let gitUrl;
+    let revision;
+    let subpath;
+    let profile;
+    let dryRun = false;
+    let update = false;
+    let force = false;
+    let trust = false;
+    let activate = false;
+    let json = false;
+    const positional = [];
+    const takeValue = (index, flag) => {
+        const value = args[index + 1];
+        if (!value || value.startsWith('--')) {
+            throw new Error(`${flag} requires a value`);
+        }
+        return value;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        switch (argument) {
+            case '--git':
+                gitUrl = takeValue(index, argument);
+                index += 1;
+                break;
+            case '--rev':
+                revision = takeValue(index, argument);
+                index += 1;
+                break;
+            case '--subpath':
+                subpath = takeValue(index, argument);
+                index += 1;
+                break;
+            case '--profile': {
+                const value = takeValue(index, argument);
+                if (value !== 'strict' && value !== 'compatible') {
+                    throw new Error('--profile must be strict or compatible');
+                }
+                profile = value;
+                index += 1;
+                break;
+            }
+            case '--dry-run':
+                dryRun = true;
+                break;
+            case '--update':
+                update = true;
+                break;
+            case '--force':
+                force = true;
+                break;
+            case '--trust':
+                trust = true;
+                break;
+            case '--activate':
+                activate = true;
+                break;
+            case '--json':
+                json = true;
+                break;
+            default:
+                if (argument.startsWith('--')) {
+                    throw new Error(`unknown import option "${argument}"`);
+                }
+                positional.push(argument);
+        }
+    }
+    if (gitUrl || revision || subpath) {
+        if (!gitUrl || !revision || !subpath) {
+            throw new Error('Git import requires --git, --rev, and --subpath');
+        }
+        if (positional.length > 0) {
+            throw new Error('Git import does not accept a local directory argument');
+        }
+        return {
+            source: {
+                kind: 'git',
+                url: gitUrl,
+                revision,
+                subpath,
+            },
+            options: { profile, dryRun, update, force, trust, activate },
+            json,
+        };
+    }
+    if (positional.length !== 1) {
+        throw new Error('local import requires exactly one skill directory');
+    }
+    return {
+        source: {
+            kind: 'directory',
+            path: positional[0],
+        },
+        options: { profile, dryRun, update, force, trust, activate },
+        json,
+    };
+}
+function printImportUsage() {
+    console.log('Usage:');
+    console.log('  aiwg skills import <directory> [options]');
+    console.log('  aiwg skills import --git <url> --rev <revision> --subpath <path> [options]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --profile strict|compatible  Validation profile (default: strict)');
+    console.log('  --dry-run                    Validate and plan without writing');
+    console.log('  --update                     Update changed content from the same source');
+    console.log('  --force                      Replace an imported name from a different source');
+    console.log('  --trust --activate           Explicitly trust and activate this exact digest');
+    console.log('  --json                       Emit deterministic structured output');
+}
+async function handleImport(args) {
+    let parsed;
+    try {
+        parsed = parseImportArgs(args);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        printImportUsage();
+        process.exit(1);
+    }
+    try {
+        const result = await importSkillSource(parsed.source, {
+            ...parsed.options,
+            projectDir: process.cwd(),
+        });
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log('');
+        console.log(`Agent Skill import: ${result.status}`);
+        console.log(`Name:         ${result.name}`);
+        console.log(`Description:  ${result.description}`);
+        console.log(`Digest:       ${result.digest}`);
+        console.log(`Source:       ${result.source.kind}`);
+        console.log(`Locator:      ${result.source.locator}`);
+        if (result.source.kind === 'git') {
+            console.log(`Subpath:      ${result.source.subpath}`);
+            console.log(`Requested:    ${result.source.requestedRevision}`);
+            console.log(`Resolved:     ${result.source.resolvedRevision}`);
+        }
+        console.log(`Profile:      ${result.validationProfile}`);
+        console.log(`Trust:        ${result.trust.state}`);
+        console.log(`Activation:   ${result.trust.activation}`);
+        console.log(`Managed:      ${result.managedLocation}`);
+        console.log(`Files:        ${result.fileCount}`);
+        console.log(`Bytes:        ${result.totalBytes}`);
+        if (result.diagnostics.length > 0) {
+            console.log('');
+            console.log('Diagnostics:');
+            for (const item of result.diagnostics) {
+                console.log(`  ${item.severity} ${item.code} ${item.file} ${item.yamlPath}: ${item.message}`);
+            }
+        }
+        console.log('');
+    }
+    catch (error) {
+        const importError = error instanceof AgentSkillImportError ? error : undefined;
+        if (parsed.json) {
+            console.log(JSON.stringify({
+                schemaVersion: 1,
+                status: 'error',
+                code: importError?.code ?? 'AS_IMPORT_FAILED',
+                message: error instanceof Error ? error.message : String(error),
+                diagnostics: importError?.diagnostics ?? [],
+            }, null, 2));
+        }
+        else {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+            for (const item of importError?.diagnostics ?? []) {
+                console.error(`  ${item.severity} ${item.code} ${item.file} ${item.yamlPath}: ${item.message}`);
+            }
+        }
+        process.exit(1);
+    }
+}
+function parseDeploymentArgs(args) {
+    let target = 'claude';
+    let dryRun = false;
+    let json = false;
+    const positional = [];
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        switch (argument) {
+            case '--target': {
+                const value = args[index + 1];
+                if (!value || value.startsWith('--')) {
+                    throw new Error('--target requires a provider ID or all');
+                }
+                target = value;
+                index += 1;
+                break;
+            }
+            case '--dry-run':
+                dryRun = true;
+                break;
+            case '--json':
+                json = true;
+                break;
+            default:
+                if (argument.startsWith('--')) {
+                    throw new Error(`unknown deployment option "${argument}"`);
+                }
+                positional.push(argument);
+        }
+    }
+    if (positional.length !== 1) {
+        throw new Error('deployment requires exactly one imported skill name');
+    }
+    if (target !== 'all' && !SUPPORTED_TARGETS.includes(target)) {
+        throw new Error(`unknown target "${target}"`);
+    }
+    return {
+        name: positional[0],
+        targets: target === 'all' ? [...SUPPORTED_TARGETS] : [target],
+        dryRun,
+        json,
+    };
+}
+function printDeploymentUsage(operation) {
+    console.log(`Usage: aiwg skills ${operation} <name> [--target <provider|all>] [--dry-run] [--json]`);
+    console.log('');
+    console.log(`Supported targets: ${SUPPORTED_TARGETS.join(', ')}`);
+}
+function printDeploymentResults(operation, results, json) {
+    if (json) {
+        console.log(JSON.stringify({
+            schemaVersion: 1,
+            operation,
+            results,
+        }, null, 2));
+        return;
+    }
+    console.log('');
+    console.log(`Agent Skill ${operation}:`);
+    for (const item of results) {
+        console.log(`  ${item.provider.padEnd(10)} ${item.outcome.padEnd(9)} `
+            + `${item.projectionStatus.padEnd(11)} ${item.path}`);
+        console.log(`    digest: ${item.sourceDigest || 'unavailable'}`);
+        for (const reason of item.reasons)
+            console.log(`    reason: ${reason}`);
+        for (const warning of item.warnings)
+            console.log(`    warning: ${warning}`);
+    }
+    console.log('');
+}
+async function handleDeployment(operation, args) {
+    let parsed;
+    try {
+        parsed = parseDeploymentArgs(args);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        printDeploymentUsage(operation);
+        process.exit(1);
+    }
+    try {
+        const options = (target) => ({
+            projectDir: process.cwd(),
+            target,
+            dryRun: parsed.dryRun,
+        });
+        const results = parsed.targets.map((target) => (operation === 'deploy'
+            ? deployImportedAgentSkill(parsed.name, options(target))
+            : uninstallImportedAgentSkill(parsed.name, options(target))));
+        printDeploymentResults(operation, results, parsed.json);
+        if (results.some((item) => item.outcome === 'blocked')) {
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        const deploymentError = error instanceof AgentSkillDeploymentError
+            ? error
+            : undefined;
+        if (parsed.json) {
+            console.log(JSON.stringify({
+                schemaVersion: 1,
+                operation,
+                status: 'error',
+                code: deploymentError?.code ?? 'AS_DEPLOY_FAILED',
+                message: error instanceof Error ? error.message : String(error),
+                results: [],
+            }, null, 2));
+        }
+        else {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        process.exit(1);
+    }
+}
+function parseExportArgs(args) {
+    let provider = 'local';
+    let outDir;
+    let dryRun = false;
+    let force = false;
+    let json = false;
+    const positional = [];
+    const takeValue = (index, flag) => {
+        const value = args[index + 1];
+        if (!value || value.startsWith('--')) {
+            throw new Error(`${flag} requires a value`);
+        }
+        return value;
+    };
+    for (let index = 0; index < args.length; index += 1) {
+        const argument = args[index];
+        switch (argument) {
+            case '--provider':
+                provider = takeValue(index, argument);
+                index += 1;
+                break;
+            case '--out':
+                outDir = takeValue(index, argument);
+                index += 1;
+                break;
+            case '--dry-run':
+                dryRun = true;
+                break;
+            case '--force':
+                force = true;
+                break;
+            case '--json':
+                json = true;
+                break;
+            default:
+                if (argument.startsWith('--')) {
+                    throw new Error(`unknown export option "${argument}"`);
+                }
+                positional.push(argument);
+        }
+    }
+    if (positional.length !== 1) {
+        throw new Error('export requires exactly one skill name');
+    }
+    if (!outDir) {
+        throw new Error('export requires --out <directory>');
+    }
+    return {
+        name: positional[0],
+        provider,
+        outDir,
+        dryRun,
+        force,
+        json,
+    };
+}
+function printExportUsage() {
+    console.log('Usage: aiwg skills export <name> --out <directory> [options]');
+    console.log('');
+    console.log('Options:');
+    console.log('  --provider <registry>  Skill registry to read from (default: local)');
+    console.log('  --out <directory>      Parent directory for the exported Agent Skill');
+    console.log('  --dry-run              Validate and plan without writing');
+    console.log('  --force                Replace an existing export directory after review');
+    console.log('  --json                 Emit deterministic structured output');
+}
+async function handleExport(args) {
+    let parsed;
+    try {
+        parsed = parseExportArgs(args);
+    }
+    catch (error) {
+        console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        printExportUsage();
+        process.exit(1);
+    }
+    try {
+        const details = await getSkillInfo(parsed.name, parsed.provider);
+        if (!details?.path) {
+            throw new AgentSkillExportError('AS_EXPORT_SKILL_NOT_FOUND', `skill '${parsed.name}' was not found in ${parsed.provider} with a local SKILL.md path`);
+        }
+        const options = {
+            outDir: parsed.outDir,
+            dryRun: parsed.dryRun,
+            force: parsed.force,
+        };
+        const result = exportAgentSkillDirectory(details.path.replace(/(?:^|[/\\])SKILL\.md$/, ''), options);
+        if (parsed.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log('');
+        console.log(`Agent Skill export: ${result.status}`);
+        console.log(`Name:          ${result.name}`);
+        console.log(`Output:        ${result.outputPath}`);
+        console.log(`Source digest: ${result.sourceDigest}`);
+        console.log(`Export digest: ${result.exportDigest}`);
+        console.log(`Files:         ${result.fileCount}`);
+        if (result.omittedAiwgFields.length > 0) {
+            console.log(`Omitted AIWG fields: ${result.omittedAiwgFields.join(', ')}`);
+        }
+        console.log('');
+    }
+    catch (error) {
+        const exportError = error instanceof AgentSkillExportError ? error : undefined;
+        if (parsed.json) {
+            console.log(JSON.stringify({
+                schemaVersion: 1,
+                status: 'error',
+                code: exportError?.code ?? 'AS_EXPORT_FAILED',
+                message: error instanceof Error ? error.message : String(error),
+            }, null, 2));
+        }
+        else {
+            console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        process.exit(1);
+    }
+}
 /**
  * Handle 'skills publish' command
  */
@@ -253,6 +688,11 @@ async function handleRun(args) {
         console.log("Run 'aiwg skills list' to see available skills");
         process.exit(1);
     }
+    const activationError = importedSkillActivationError(details);
+    if (activationError) {
+        console.error(`Error: ${activationError}`);
+        process.exit(1);
+    }
     if (!details.content) {
         console.error(`Error: Skill '${skillName}' has no executable content`);
         process.exit(1);
@@ -306,12 +746,24 @@ export async function main(args) {
         case 'install':
             await handleInstall(subcommandArgs);
             break;
+        case 'import':
+            await handleImport(subcommandArgs);
+            break;
+        case 'deploy':
+            await handleDeployment('deploy', subcommandArgs);
+            break;
+        case 'uninstall':
+            await handleDeployment('uninstall', subcommandArgs);
+            break;
+        case 'export':
+            await handleExport(subcommandArgs);
+            break;
         case 'publish':
             await handlePublish(subcommandArgs);
             break;
         case undefined:
             console.error('Error: Skills subcommand required');
-            console.log('Available: run, search, info, list, install, publish');
+            console.log('Available: run, search, info, list, install, import, deploy, uninstall, export, publish');
             console.log('');
             console.log('Examples:');
             console.log('  aiwg skills run workspace-health');
@@ -323,11 +775,15 @@ export async function main(args) {
             console.log('  aiwg skills install parallel-dispatch');
             console.log('  aiwg skills install parallel-dispatch --target copilot');
             console.log('  aiwg skills install my-skill --provider clawhub --target cursor');
+            console.log('  aiwg skills import ./my-skill --dry-run');
+            console.log('  aiwg skills deploy my-skill --target all --dry-run');
+            console.log('  aiwg skills uninstall my-skill --target claude');
+            console.log('  aiwg skills export my-skill --out ./agent-skills');
             process.exit(1);
             break;
         default:
             console.error(`Error: Unknown skills subcommand '${subcommand}'`);
-            console.log('Available: run, search, info, list, install, publish');
+            console.log('Available: run, search, info, list, install, import, deploy, uninstall, export, publish');
             process.exit(1);
     }
 }