@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/cli/git-hooks.js

@@ -0,0 +1,250 @@
+/**
+ * Git Hook Installer
+ *
+ * Installs and manages git pre-commit and pre-push hooks for AIWG validation.
+ */
+import { readFile, writeFile, chmod, access, mkdir } from 'fs/promises';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { constants } from 'fs';
+/**
+ * Git Hook Installer
+ */
+export class GitHookInstaller {
+    projectRoot;
+    hooksDir;
+    constructor(projectRoot) {
+        this.projectRoot = projectRoot;
+        this.hooksDir = resolve(projectRoot, '.git', 'hooks');
+    }
+    /**
+     * Install pre-commit hook
+     */
+    async installPreCommitHook(options = {}) {
+        const hookContent = this.generatePreCommitHook(options.configPath);
+        await this.installHook('pre-commit', hookContent, options);
+    }
+    /**
+     * Install pre-push hook
+     */
+    async installPrePushHook(options = {}) {
+        const hookContent = this.generatePrePushHook(options.configPath);
+        await this.installHook('pre-push', hookContent, options);
+    }
+    /**
+     * Uninstall hooks
+     */
+    async uninstallHooks(projectRoot) {
+        const hooksToRemove = ['pre-commit', 'pre-push'];
+        for (const hookType of hooksToRemove) {
+            const hookPath = resolve(projectRoot, '.git', 'hooks', hookType);
+            if (existsSync(hookPath)) {
+                const content = await readFile(hookPath, 'utf-8');
+                // Only remove if it's our hook
+                if (content.includes('# AIWG')) {
+                    // Check if there's other content
+                    const lines = content.split('\n');
+                    const aiwgStart = lines.findIndex(l => l.includes('# AIWG'));
+                    const aiwgEnd = lines.findIndex((l, i) => i > aiwgStart && l.includes('# END AIWG'));
+                    if (aiwgStart >= 0 && aiwgEnd >= 0) {
+                        // Remove only AIWG section
+                        const beforeAiwg = lines.slice(0, aiwgStart);
+                        const afterAiwg = lines.slice(aiwgEnd + 1);
+                        // Check if the content before AIWG is just shebang (part of our hook)
+                        const beforeContent = beforeAiwg.filter(l => l.trim().length > 0);
+                        const isOnlyShebang = beforeContent.length <= 1 && beforeContent.every(l => l.startsWith('#!'));
+                        // Check if after AIWG is meaningful content
+                        const afterContent = afterAiwg.filter(l => l.trim().length > 0);
+                        if (isOnlyShebang && afterContent.length === 0) {
+                            // File only contains our hook (shebang + AIWG), remove entirely
+                            await this.removeFile(hookPath);
+                        }
+                        else {
+                            // There's other content, keep it
+                            const newContent = [...beforeAiwg, ...afterAiwg].join('\n');
+                            if (newContent.trim().length > 0) {
+                                await writeFile(hookPath, newContent, 'utf-8');
+                            }
+                            else {
+                                // File would be empty, remove it
+                                await this.removeFile(hookPath);
+                            }
+                        }
+                    }
+                    else {
+                        // Entire file is AIWG hook, remove it
+                        await this.removeFile(hookPath);
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * Check if hook is installed
+     */
+    isInstalled(hookType) {
+        const hookPath = resolve(this.hooksDir, hookType);
+        if (!existsSync(hookPath)) {
+            return false;
+        }
+        try {
+            const content = require('fs').readFileSync(hookPath, 'utf-8');
+            return content.includes('# AIWG');
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get hook content
+     */
+    async getHookContent(hookType) {
+        const hookPath = resolve(this.hooksDir, hookType);
+        if (!existsSync(hookPath)) {
+            return null;
+        }
+        return await readFile(hookPath, 'utf-8');
+    }
+    /**
+     * Verify git repository
+     */
+    isGitRepository() {
+        return existsSync(resolve(this.projectRoot, '.git'));
+    }
+    // Private methods
+    async installHook(hookType, content, options) {
+        // Verify git repository
+        if (!this.isGitRepository()) {
+            throw new Error('Not a git repository');
+        }
+        // Ensure hooks directory exists
+        if (!existsSync(this.hooksDir)) {
+            await mkdir(this.hooksDir, { recursive: true });
+        }
+        const hookPath = resolve(this.hooksDir, hookType);
+        // Check if hook already exists
+        if (existsSync(hookPath) && !options.force && !options.append) {
+            throw new Error(`Hook ${hookType} already exists. Use --force to overwrite or --append to add to existing hook.`);
+        }
+        let finalContent = content;
+        if (options.append && existsSync(hookPath)) {
+            // Append to existing hook
+            const existing = await readFile(hookPath, 'utf-8');
+            // Check if AIWG section already exists
+            if (existing.includes('# AIWG')) {
+                throw new Error(`AIWG hook already exists in ${hookType}. Use --force to overwrite.`);
+            }
+            finalContent = `${existing}\n\n${content}`;
+        }
+        // Write hook file
+        await writeFile(hookPath, finalContent, 'utf-8');
+        // Make executable
+        await chmod(hookPath, 0o755);
+    }
+    generatePreCommitHook(configPath) {
+        const configArg = configPath ? ` --config ${configPath}` : '';
+        return `#!/bin/sh
+# AIWG pre-commit hook
+# Validates staged markdown and text files before commit
+
+echo "Running AIWG validation..."
+
+# Get staged files
+STAGED_FILES=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\\.(md|txt)$' || true)
+
+if [ -z "$STAGED_FILES" ]; then
+  echo "No markdown or text files to validate"
+  exit 0
+fi
+
+# Run AIWG workflow
+node tools/cli/aiwg.mjs workflow $STAGED_FILES${configArg}
+RESULT=$?
+
+if [ $RESULT -ne 0 ]; then
+  echo ""
+  echo "AIWG validation failed. Please fix issues before committing."
+  echo "To bypass this check, use: git commit --no-verify"
+  exit 1
+fi
+
+echo "AIWG validation passed"
+exit 0
+
+# END AIWG
+`;
+    }
+    generatePrePushHook(configPath) {
+        const configArg = configPath ? ` --config ${configPath}` : '';
+        return `#!/bin/sh
+# AIWG pre-push hook
+# Validates all markdown and text files before push
+
+echo "Running AIWG validation before push..."
+
+# Find all markdown and text files
+FILES=$(find . -type f \\( -name "*.md" -o -name "*.txt" \\) -not -path "*/node_modules/*" -not -path "*/.git/*" || true)
+
+if [ -z "$FILES" ]; then
+  echo "No markdown or text files to validate"
+  exit 0
+fi
+
+# Run AIWG workflow
+node tools/cli/aiwg.mjs workflow $FILES${configArg}
+RESULT=$?
+
+if [ $RESULT -ne 0 ]; then
+  echo ""
+  echo "AIWG validation failed. Please fix issues before pushing."
+  echo "To bypass this check, use: git push --no-verify"
+  exit 1
+fi
+
+echo "AIWG validation passed"
+exit 0
+
+# END AIWG
+`;
+    }
+    async removeFile(path) {
+        const fs = await import('fs/promises');
+        await fs.unlink(path);
+    }
+    /**
+     * List all installed hooks
+     */
+    async listInstalledHooks() {
+        const installed = [];
+        const hookTypes = ['pre-commit', 'pre-push'];
+        for (const hookType of hookTypes) {
+            if (this.isInstalled(hookType)) {
+                installed.push(hookType);
+            }
+        }
+        return installed;
+    }
+    /**
+     * Validate hook installation
+     */
+    async validateHook(hookType) {
+        const hookPath = resolve(this.hooksDir, hookType);
+        if (!existsSync(hookPath)) {
+            return { valid: false, error: 'Hook file does not exist' };
+        }
+        try {
+            // Check if executable
+            await access(hookPath, constants.X_OK);
+        }
+        catch {
+            return { valid: false, error: 'Hook file is not executable' };
+        }
+        // Check if contains AIWG marker
+        const content = await readFile(hookPath, 'utf-8');
+        if (!content.includes('# AIWG')) {
+            return { valid: false, error: 'Hook does not contain AIWG marker' };
+        }
+        return { valid: true };
+    }
+}
+//# sourceMappingURL=git-hooks.js.map

package/dist/src/cli/handlers/agentcard.js

@@ -0,0 +1,206 @@
+/**
+ * AgentCard CLI handler — `aiwg agentcard <verb> ...`.
+ *
+ * Verbs:
+ *   verify  Fetch an agentic-sandbox AgentCard from the well-known route,
+ *           /v1/extendedAgentCard, or legacy /v1/card, then verify its
+ *           Ed25519 JWS signature against a supplied JWKS.
+ *
+ * @implements @src/a2a/agent-card.ts
+ * @issue #1253
+ */
+import { fetchAgentCard } from '../../a2a/agent-card.js';
+import { loadJwkSet } from '../../a2a/jws.js';
+import { AiwgError, EXIT_CODES, handlerResultFromError } from '../errors.js';
+function parseVerifyArgs(args) {
+    const get = (name) => {
+        const idx = args.indexOf(name);
+        if (idx >= 0 && idx + 1 < args.length)
+            return args[idx + 1];
+        return undefined;
+    };
+    const host = get('--host');
+    const instance = get('--instance');
+    if (!host) {
+        throw new AiwgError({
+            code: 'ERR_AGENTCARD_MISSING_HOST',
+            message: 'Missing --host',
+            exitCode: EXIT_CODES.USAGE,
+            hint: 'Example: aiwg agentcard verify --host https://exec.test --instance inst-1 --jwks /path/to/jwks.json',
+        });
+    }
+    if (!instance) {
+        throw new AiwgError({
+            code: 'ERR_AGENTCARD_MISSING_INSTANCE',
+            message: 'Missing --instance',
+            exitCode: EXIT_CODES.USAGE,
+            hint: 'Example: aiwg agentcard verify --host https://exec.test --instance inst-1 --jwks /path/to/jwks.json',
+        });
+    }
+    const jwks = get('--jwks');
+    const bearer = get('--bearer');
+    const skipVerify = args.includes('--skip-verify');
+    const json = args.includes('--json');
+    if (!jwks && !skipVerify) {
+        throw new AiwgError({
+            code: 'ERR_AGENTCARD_MISSING_JWKS',
+            message: '--jwks is required unless --skip-verify is set',
+            exitCode: EXIT_CODES.USAGE,
+            hint: 'Provide a JWKS file path or URL; or pass --skip-verify to bypass signature verification.',
+        });
+    }
+    const result = { host, instance, skipVerify, json };
+    if (jwks !== undefined)
+        result.jwks = jwks;
+    if (bearer !== undefined)
+        result.bearer = bearer;
+    return result;
+}
+async function loadJwksFromSource(source) {
+    if (/^https?:\/\//i.test(source)) {
+        const resp = await fetch(source);
+        if (resp.status !== 200) {
+            throw new AiwgError({
+                code: 'ERR_AGENTCARD_JWKS_FETCH',
+                message: `JWKS fetch failed: ${source} returned ${resp.status}`,
+                exitCode: EXIT_CODES.GENERAL,
+            });
+        }
+        return loadJwkSet(await resp.text());
+    }
+    const { readFile } = await import('node:fs/promises');
+    return loadJwkSet(await readFile(source, 'utf8'));
+}
+async function handleVerify(args) {
+    const parsed = parseVerifyArgs(args);
+    const opts = {
+        skipVerify: parsed.skipVerify,
+    };
+    if (parsed.bearer !== undefined)
+        opts.bearer = parsed.bearer;
+    if (parsed.jwks !== undefined && !parsed.skipVerify) {
+        opts.jwks = await loadJwksFromSource(parsed.jwks);
+    }
+    let verified;
+    try {
+        verified = await fetchAgentCard(parsed.host, parsed.instance, opts);
+    }
+    catch (err) {
+        const message = err.message;
+        if (parsed.json) {
+            console.log(JSON.stringify({
+                ok: false,
+                host: parsed.host,
+                instance: parsed.instance,
+                error: message,
+            }, null, 2));
+        }
+        else {
+            console.error(`AgentCard verification FAILED for ${parsed.host}/${parsed.instance}`);
+            console.error(`  ${message}`);
+        }
+        return { exitCode: EXIT_CODES.GENERAL };
+    }
+    if (parsed.json) {
+        console.log(JSON.stringify({
+            ok: true,
+            host: parsed.host,
+            instance: parsed.instance,
+            verifiedAt: verified.verifiedAt,
+            kid: verified.kid,
+            skipVerify: parsed.skipVerify,
+            card: {
+                name: verified.card.name,
+                protocolVersion: verified.card.protocolVersion,
+                url: verified.card.url,
+                version: verified.card.version,
+                preferredTransport: verified.card.preferredTransport,
+                capabilities: verified.card.capabilities,
+                skills: verified.card.skills,
+            },
+        }, null, 2));
+    }
+    else {
+        const banner = parsed.skipVerify ? '(verification SKIPPED)' : 'VERIFIED';
+        console.log(`AgentCard ${banner} for ${parsed.host}/${parsed.instance}`);
+        console.log(`  name:               ${verified.card.name}`);
+        console.log(`  protocolVersion:    ${verified.card.protocolVersion}`);
+        console.log(`  url:                ${verified.card.url}`);
+        console.log(`  version:            ${verified.card.version}`);
+        if (verified.card.preferredTransport) {
+            console.log(`  preferredTransport: ${verified.card.preferredTransport}`);
+        }
+        if (verified.kid) {
+            console.log(`  signing kid:        ${verified.kid}`);
+        }
+        console.log(`  verifiedAt:         ${verified.verifiedAt}`);
+        const exts = verified.card.capabilities?.extensions ?? [];
+        if (exts.length > 0) {
+            console.log(`  extensions:`);
+            for (const e of exts) {
+                const tag = e.required ? '[required]' : '[optional]';
+                console.log(`    ${tag} ${e.uri}`);
+            }
+        }
+        const skills = verified.card.skills ?? [];
+        if (skills.length > 0) {
+            console.log(`  skills (${skills.length}):`);
+            for (const s of skills.slice(0, 5)) {
+                console.log(`    - ${s.id}${s.name ? ' (' + s.name + ')' : ''}`);
+            }
+            if (skills.length > 5)
+                console.log(`    ... and ${skills.length - 5} more`);
+        }
+    }
+    return { exitCode: 0 };
+}
+function printUsage() {
+    console.log('Usage: aiwg agentcard <verb> [options]');
+    console.log('');
+    console.log('Verbs:');
+    console.log('  verify  Fetch and verify an AgentCard JWS signature');
+    console.log('');
+    console.log('verify options:');
+    console.log('  --host <url>        Executor host (e.g. https://exec.test)');
+    console.log('  --instance <id>     Instance id (UUIDv7)');
+    console.log('  --jwks <path|url>   JWKS file path or URL (required unless --skip-verify)');
+    console.log('  --bearer <token>    Optional bearer token for the card endpoint');
+    console.log('  --skip-verify       Skip JWS verification (NOT recommended)');
+    console.log('  --json              Emit JSON output');
+}
+/**
+ * agentcard command handler — dispatches on the first positional arg.
+ */
+export const agentcardHandler = {
+    id: 'agentcard',
+    name: 'AgentCard',
+    description: 'Fetch and verify an agentic-sandbox AgentCard',
+    category: 'toolsmith',
+    aliases: [],
+    async execute(ctx) {
+        try {
+            const args = ctx.args;
+            const verb = args[0];
+            if (!verb || verb === '--help' || verb === '-h') {
+                printUsage();
+                return { exitCode: verb ? 0 : EXIT_CODES.USAGE };
+            }
+            const rest = args.slice(1);
+            switch (verb) {
+                case 'verify':
+                    return await handleVerify(rest);
+                default:
+                    throw new AiwgError({
+                        code: 'ERR_AGENTCARD_UNKNOWN_VERB',
+                        message: `Unknown verb: ${verb}`,
+                        exitCode: EXIT_CODES.USAGE,
+                        hint: "Run 'aiwg agentcard --help' for usage.",
+                    });
+            }
+        }
+        catch (err) {
+            return handlerResultFromError(err);
+        }
+    },
+};
+//# sourceMappingURL=agentcard.js.map

package/dist/src/cli/handlers/artifacts.js

@@ -0,0 +1,76 @@
+import { getProjectDir } from '../../config/aiwg-config.js';
+import { moveProjectArtifacts } from '../../artifacts/move.js';
+function usage() {
+    return [
+        'aiwg artifacts — Manage the project AIWG artifact root',
+        '',
+        'Usage:',
+        '  aiwg artifacts move --to <path> [--from <path>] [--dry-run] [--force] [--no-reindex] [--no-sync]',
+        '',
+        'Notes:',
+        '  --to points at the artifact directory itself, not its parent.',
+        '  AIWG_ARTIFACTS_PATH overrides the generated .aiwg-location pointer.',
+    ].join('\n');
+}
+function valueAfter(args, flag) {
+    const index = args.indexOf(flag);
+    if (index < 0)
+        return undefined;
+    const value = args[index + 1];
+    return value && !value.startsWith('-') ? value : undefined;
+}
+export const artifactsHandler = {
+    id: 'artifacts',
+    name: 'Project Artifacts',
+    description: 'Move or inspect the configured project AIWG artifact root',
+    category: 'index',
+    aliases: ['artifact'],
+    async execute(ctx) {
+        const action = ctx.args.find(arg => !arg.startsWith('-')) ?? 'help';
+        if (action === 'help' || ctx.args.includes('--help') || ctx.args.includes('-h')) {
+            return { exitCode: 0, message: usage() };
+        }
+        if (action !== 'move') {
+            return { exitCode: 1, message: `Unknown artifacts action: ${action}\n\n${usage()}` };
+        }
+        const to = valueAfter(ctx.args, '--to');
+        if (!to) {
+            return { exitCode: 1, message: `Error: --to <path> is required.\n\n${usage()}` };
+        }
+        try {
+            const result = await moveProjectArtifacts({
+                projectDir: getProjectDir(ctx, ctx.args),
+                from: valueAfter(ctx.args, '--from'),
+                to,
+                dryRun: ctx.dryRun || ctx.args.includes('--dry-run'),
+                force: ctx.args.includes('--force'),
+                reindex: !ctx.args.includes('--no-reindex'),
+                syncFortemi: !ctx.args.includes('--no-sync'),
+            });
+            const verb = result.dryRun ? 'Would move' : 'Moved';
+            return {
+                exitCode: 0,
+                message: [
+                    `${verb} AIWG artifacts`,
+                    `  From: ${result.from}`,
+                    `  To:   ${result.to}`,
+                    `  Pointer: ${result.pointerPath} -> ${result.pointerValue}`,
+                    `  Gitignore: ${result.gitignoreUpdated ? (result.dryRun ? 'would update' : 'updated') : 'already configured'}`,
+                    `  Reindex: ${result.reindexed ? 'rebuilt project graph' : result.dryRun ? 'would rebuild project graph' : 'skipped'}`,
+                    `  Fortemi sync: ${result.fortemiSynced ? 'updated' : result.dryRun ? 'would update' : 'skipped'}`,
+                    '',
+                    'If AIWG_ARTIFACTS_PATH is set in the shell, update it to the new path or unset it so .aiwg-location is used.',
+                ].join('\n'),
+            };
+        }
+        catch (error) {
+            return {
+                exitCode: 1,
+                error: error instanceof Error ? error : new Error(String(error)),
+                message: `Artifact move failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    },
+};
+export const artifactsHandlers = [artifactsHandler];
+//# sourceMappingURL=artifacts.js.map