@rbbtsn0w/adg 0.1.0-alpha.1 → 0.1.0-beta.2

package/dist/vendor/skills/src/sync.js

@@ -0,0 +1,404 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { readdir, stat } from 'fs/promises';
+import { join, sep } from 'path';
+import { homedir } from 'os';
+import { parseSkillMd } from "./skills.js";
+import { installSkillForAgent, getCanonicalPath } from "./installer.js";
+import { detectInstalledAgents, agents, getUniversalAgents, getVisibleUniversalAgents, getNonUniversalAgents, } from "./agents.js";
+import { searchMultiselect } from "./prompts/search-multiselect.js";
+import { addSkillToLocalLock, computeSkillFolderHash, readLocalLock } from "./local-lock.js";
+import { track } from "./telemetry.js";
+import { detectAgent, getAgentType } from "./detect-agent.js";
+const isCancelled = (value) => typeof value === 'symbol';
+/**
+ * Shortens a path for display: replaces homedir with ~ and cwd with .
+ */
+function shortenPath(fullPath, cwd) {
+    const home = homedir();
+    if (fullPath === home || fullPath.startsWith(home + sep)) {
+        return '~' + fullPath.slice(home.length);
+    }
+    if (fullPath === cwd || fullPath.startsWith(cwd + sep)) {
+        return '.' + fullPath.slice(cwd.length);
+    }
+    return fullPath;
+}
+/**
+ * Crawl node_modules for SKILL.md files.
+ * Searches both top-level packages and scoped packages (@org/pkg).
+ * Returns discovered skills with their source package name.
+ */
+async function discoverNodeModuleSkills(cwd) {
+    const nodeModulesDir = join(cwd, 'node_modules');
+    const skills = [];
+    let topNames;
+    try {
+        topNames = await readdir(nodeModulesDir);
+    }
+    catch {
+        return skills;
+    }
+    const processPackageDir = async (pkgDir, packageName) => {
+        // Check for SKILL.md at package root
+        const rootSkill = await parseSkillMd(join(pkgDir, 'SKILL.md'));
+        if (rootSkill) {
+            skills.push({ ...rootSkill, packageName });
+            return;
+        }
+        // Check common skill locations within the package
+        const searchDirs = [pkgDir, join(pkgDir, 'skills'), join(pkgDir, '.agents', 'skills')];
+        for (const searchDir of searchDirs) {
+            try {
+                const entries = await readdir(searchDir);
+                for (const name of entries) {
+                    const skillDir = join(searchDir, name);
+                    try {
+                        const s = await stat(skillDir);
+                        if (!s.isDirectory())
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const skill = await parseSkillMd(join(skillDir, 'SKILL.md'));
+                    if (skill) {
+                        skills.push({ ...skill, packageName });
+                    }
+                }
+            }
+            catch {
+                // Directory doesn't exist
+            }
+        }
+    };
+    await Promise.all(topNames.map(async (name) => {
+        if (name.startsWith('.'))
+            return;
+        const fullPath = join(nodeModulesDir, name);
+        try {
+            const s = await stat(fullPath);
+            if (!s.isDirectory())
+                return;
+        }
+        catch {
+            return;
+        }
+        if (name.startsWith('@')) {
+            // Scoped package: read @org/* entries
+            try {
+                const scopeNames = await readdir(fullPath);
+                await Promise.all(scopeNames.map(async (scopedName) => {
+                    const scopedPath = join(fullPath, scopedName);
+                    try {
+                        const s = await stat(scopedPath);
+                        if (!s.isDirectory())
+                            return;
+                    }
+                    catch {
+                        return;
+                    }
+                    await processPackageDir(scopedPath, `${name}/${scopedName}`);
+                }));
+            }
+            catch {
+                // Scope directory not readable
+            }
+        }
+        else {
+            await processPackageDir(fullPath, name);
+        }
+    }));
+    return skills;
+}
+export async function runSync(args, options = {}) {
+    const cwd = process.cwd();
+    // Auto-enable non-interactive mode when running inside an AI agent
+    const agentResult = await detectAgent();
+    if (agentResult.isAgent) {
+        options.yes = true;
+        if (!options.agent || options.agent.length === 0) {
+            const mappedAgent = getAgentType(agentResult.agent.name);
+            if (mappedAgent) {
+                const agentList = [mappedAgent];
+                for (const ua of getUniversalAgents()) {
+                    if (!agentList.includes(ua))
+                        agentList.push(ua);
+                }
+                options.agent = agentList;
+            }
+        }
+    }
+    console.log();
+    if (!agentResult.isAgent) {
+        p.intro(pc.bgCyan(pc.black(' skills experimental_sync ')));
+    }
+    if (agentResult.isAgent) {
+        p.log.info(pc.bgCyan(pc.black(pc.bold(` ${agentResult.agent.name} `))) +
+            ' ' +
+            'Agent detected — installing non-interactively');
+    }
+    const spinner = p.spinner();
+    // 1. Discover skills from node_modules
+    spinner.start('Scanning node_modules for skills...');
+    const discoveredSkills = await discoverNodeModuleSkills(cwd);
+    if (discoveredSkills.length === 0) {
+        spinner.stop(pc.yellow('No skills found'));
+        p.outro(pc.dim('No SKILL.md files found in node_modules.'));
+        return;
+    }
+    spinner.stop(`Found ${pc.green(String(discoveredSkills.length))} skill${discoveredSkills.length > 1 ? 's' : ''} in node_modules`);
+    // Show discovered skills
+    for (const skill of discoveredSkills) {
+        p.log.info(`${pc.cyan(skill.name)} ${pc.dim(`from ${skill.packageName}`)}`);
+        if (skill.description) {
+            p.log.message(pc.dim(`  ${skill.description}`));
+        }
+    }
+    // 2. Check which skills are already up-to-date via local lock
+    const localLock = await readLocalLock(cwd);
+    const toInstall = [];
+    const upToDate = [];
+    if (options.force) {
+        toInstall.push(...discoveredSkills);
+        p.log.info(pc.dim('Force mode: reinstalling all skills'));
+    }
+    else {
+        for (const skill of discoveredSkills) {
+            const existingEntry = localLock.skills[skill.name];
+            if (existingEntry) {
+                // Compute current hash and compare
+                const currentHash = await computeSkillFolderHash(skill.path);
+                if (currentHash === existingEntry.computedHash) {
+                    upToDate.push(skill.name);
+                    continue;
+                }
+            }
+            toInstall.push(skill);
+        }
+        if (upToDate.length > 0) {
+            p.log.info(pc.dim(`${upToDate.length} skill${upToDate.length !== 1 ? 's' : ''} already up to date`));
+        }
+        if (toInstall.length === 0) {
+            console.log();
+            p.outro(pc.green('All skills are up to date.'));
+            return;
+        }
+    }
+    p.log.info(`${toInstall.length} skill${toInstall.length !== 1 ? 's' : ''} to install/update`);
+    // 3. Select agents
+    let targetAgents;
+    const validAgents = Object.keys(agents);
+    const universalAgents = getUniversalAgents();
+    const visibleUniversalAgents = getVisibleUniversalAgents();
+    if (options.agent?.includes('*')) {
+        targetAgents = validAgents;
+        p.log.info(`Installing to all ${targetAgents.length} agents`);
+    }
+    else if (options.agent && options.agent.length > 0) {
+        const invalidAgents = options.agent.filter((a) => !validAgents.includes(a));
+        if (invalidAgents.length > 0) {
+            p.log.error(`Invalid agents: ${invalidAgents.join(', ')}`);
+            p.log.info(`Valid agents: ${validAgents.join(', ')}`);
+            process.exit(1);
+        }
+        targetAgents = options.agent;
+    }
+    else {
+        spinner.start('Loading agents...');
+        const installedAgents = await detectInstalledAgents();
+        const totalAgents = Object.keys(agents).length;
+        spinner.stop(`${totalAgents} agents`);
+        if (installedAgents.length === 0) {
+            if (options.yes) {
+                targetAgents = universalAgents;
+                p.log.info('Installing to universal agents');
+            }
+            else {
+                const otherAgents = getNonUniversalAgents();
+                const otherChoices = otherAgents.map((a) => ({
+                    value: a,
+                    label: agents[a].displayName,
+                    hint: agents[a].skillsDir,
+                }));
+                const selected = await searchMultiselect({
+                    message: 'Which agents do you want to install to?',
+                    items: otherChoices,
+                    initialSelected: [],
+                    lockedSection: {
+                        title: 'Universal (.agents/skills)',
+                        items: visibleUniversalAgents.map((a) => ({
+                            value: a,
+                            label: agents[a].displayName,
+                        })),
+                        hiddenCount: universalAgents.length - visibleUniversalAgents.length,
+                    },
+                });
+                if (isCancelled(selected)) {
+                    p.cancel('Sync cancelled');
+                    process.exit(0);
+                }
+                targetAgents = selected;
+            }
+        }
+        else if (installedAgents.length === 1 || options.yes) {
+            // Ensure universal agents are included
+            targetAgents = [...installedAgents];
+            for (const ua of universalAgents) {
+                if (!targetAgents.includes(ua)) {
+                    targetAgents.push(ua);
+                }
+            }
+        }
+        else {
+            const otherAgents = getNonUniversalAgents().filter((a) => installedAgents.includes(a));
+            const otherChoices = otherAgents.map((a) => ({
+                value: a,
+                label: agents[a].displayName,
+                hint: agents[a].skillsDir,
+            }));
+            const selected = await searchMultiselect({
+                message: 'Which agents do you want to install to?',
+                items: otherChoices,
+                initialSelected: installedAgents.filter((a) => !universalAgents.includes(a)),
+                lockedSection: {
+                    title: 'Universal (.agents/skills)',
+                    items: visibleUniversalAgents.map((a) => ({
+                        value: a,
+                        label: agents[a].displayName,
+                    })),
+                    hiddenCount: universalAgents.length - visibleUniversalAgents.length,
+                },
+            });
+            if (isCancelled(selected)) {
+                p.cancel('Sync cancelled');
+                process.exit(0);
+            }
+            targetAgents = selected;
+        }
+    }
+    // 4. Build summary
+    const summaryLines = [];
+    for (const skill of toInstall) {
+        const canonicalPath = getCanonicalPath(skill.name, { global: false });
+        const shortCanonical = shortenPath(canonicalPath, cwd);
+        summaryLines.push(`${pc.cyan(skill.name)} ${pc.dim(`← ${skill.packageName}`)}`);
+        summaryLines.push(`  ${pc.dim(shortCanonical)}`);
+    }
+    console.log();
+    p.note(summaryLines.join('\n'), 'Sync Summary');
+    if (!options.yes) {
+        const confirmed = await p.confirm({ message: 'Proceed with sync?' });
+        if (p.isCancel(confirmed) || !confirmed) {
+            p.cancel('Sync cancelled');
+            process.exit(0);
+        }
+    }
+    // 5. Install skills (always project-scoped, always symlink)
+    spinner.start('Syncing skills...');
+    const results = [];
+    for (const skill of toInstall) {
+        for (const agent of targetAgents) {
+            const result = await installSkillForAgent(skill, agent, {
+                global: false,
+                cwd,
+                mode: 'symlink',
+            });
+            results.push({
+                skill: skill.name,
+                packageName: skill.packageName,
+                agent: agents[agent].displayName,
+                success: result.success,
+                path: result.path,
+                canonicalPath: result.canonicalPath,
+                error: result.error,
+            });
+        }
+    }
+    spinner.stop('Sync complete');
+    // 6. Update local lock file
+    const successful = results.filter((r) => r.success);
+    const failed = results.filter((r) => !r.success);
+    const successfulSkillNames = new Set(successful.map((r) => r.skill));
+    for (const skill of toInstall) {
+        if (successfulSkillNames.has(skill.name)) {
+            try {
+                const computedHash = await computeSkillFolderHash(skill.path);
+                await addSkillToLocalLock(skill.name, {
+                    source: skill.packageName,
+                    sourceType: 'node_modules',
+                    computedHash,
+                }, cwd);
+            }
+            catch {
+                // Don't fail sync if lock file update fails
+            }
+        }
+    }
+    // 7. Display results
+    console.log();
+    if (successful.length > 0) {
+        const bySkill = new Map();
+        for (const r of successful) {
+            const skillResults = bySkill.get(r.skill) || [];
+            skillResults.push(r);
+            bySkill.set(r.skill, skillResults);
+        }
+        const resultLines = [];
+        for (const [skillName, skillResults] of bySkill) {
+            const firstResult = skillResults[0];
+            const pkg = toInstall.find((s) => s.name === skillName)?.packageName;
+            if (firstResult.canonicalPath) {
+                const shortPath = shortenPath(firstResult.canonicalPath, cwd);
+                resultLines.push(`${pc.green('✓')} ${skillName} ${pc.dim(`← ${pkg}`)}`);
+                resultLines.push(`  ${pc.dim(shortPath)}`);
+            }
+            else {
+                resultLines.push(`${pc.green('✓')} ${skillName} ${pc.dim(`← ${pkg}`)}`);
+            }
+        }
+        const skillCount = bySkill.size;
+        const title = pc.green(`Synced ${skillCount} skill${skillCount !== 1 ? 's' : ''}`);
+        p.note(resultLines.join('\n'), title);
+    }
+    if (failed.length > 0) {
+        console.log();
+        p.log.error(pc.red(`Failed to install ${failed.length}`));
+        for (const r of failed) {
+            p.log.message(`  ${pc.red('✗')} ${r.skill} → ${r.agent}: ${pc.dim(r.error)}`);
+        }
+    }
+    // Track telemetry
+    track({
+        event: 'experimental_sync',
+        skillCount: String(toInstall.length),
+        successCount: String(successfulSkillNames.size),
+        agents: targetAgents.join(','),
+    });
+    console.log();
+    p.outro(pc.green('Done!') + pc.dim('  Review skills before use; they run with full agent permissions.'));
+}
+export function parseSyncOptions(args) {
+    const options = {};
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '-y' || arg === '--yes') {
+            options.yes = true;
+        }
+        else if (arg === '-f' || arg === '--force') {
+            options.force = true;
+        }
+        else if (arg === '-a' || arg === '--agent') {
+            options.agent = options.agent || [];
+            i++;
+            let nextArg = args[i];
+            while (i < args.length && nextArg && !nextArg.startsWith('-')) {
+                options.agent.push(nextArg);
+                i++;
+                nextArg = args[i];
+            }
+            i--;
+        }
+    }
+    return { options };
+}

package/dist/vendor/skills/src/telemetry.js

@@ -0,0 +1,101 @@
+const TELEMETRY_URL = 'https://add-skill.vercel.sh/t';
+const AUDIT_URL = 'https://add-skill.vercel.sh/audit';
+let cliVersion = null;
+let detectedAgentName = null;
+/**
+ * Set the detected AI agent name for telemetry tracking.
+ * Called once during agent detection, then included in all telemetry events.
+ */
+export function setDetectedAgent(agentName) {
+    detectedAgentName = agentName;
+}
+function isCI() {
+    return !!(process.env.CI ||
+        process.env.GITHUB_ACTIONS ||
+        process.env.GITLAB_CI ||
+        process.env.CIRCLECI ||
+        process.env.TRAVIS ||
+        process.env.BUILDKITE ||
+        process.env.JENKINS_URL ||
+        process.env.TEAMCITY_VERSION);
+}
+function isEnabled() {
+    return !process.env.DISABLE_TELEMETRY && !process.env.DO_NOT_TRACK;
+}
+export function setVersion(version) {
+    cliVersion = version;
+}
+/**
+ * Fetch security audit results for skills from the audit API.
+ * Returns null on any error or timeout — never blocks installation.
+ */
+export async function fetchAuditData(source, skillSlugs, timeoutMs = 3000) {
+    if (skillSlugs.length === 0)
+        return null;
+    try {
+        const params = new URLSearchParams({
+            source,
+            skills: skillSlugs.join(','),
+        });
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), timeoutMs);
+        const response = await fetch(`${AUDIT_URL}?${params.toString()}`, {
+            signal: controller.signal,
+        });
+        clearTimeout(timeout);
+        if (!response.ok)
+            return null;
+        return (await response.json());
+    }
+    catch {
+        return null;
+    }
+}
+// Pending telemetry promises — awaited before CLI exit so we don't lose data,
+// but never block the main workflow.
+const pendingTelemetry = [];
+export function track(data) {
+    if (!isEnabled())
+        return;
+    try {
+        const params = new URLSearchParams();
+        // Add version
+        if (cliVersion) {
+            params.set('v', cliVersion);
+        }
+        // Add CI flag if running in CI
+        if (isCI()) {
+            params.set('ci', '1');
+        }
+        // Add detected AI agent name
+        if (detectedAgentName) {
+            params.set('agent', detectedAgentName);
+        }
+        // Add event data
+        for (const [key, value] of Object.entries(data)) {
+            if (value !== undefined && value !== null) {
+                params.set(key, String(value));
+            }
+        }
+        // Fire and forget during the workflow, but track the promise so
+        // flushTelemetry() can await it before the process exits.
+        const p = fetch(`${TELEMETRY_URL}?${params.toString()}`)
+            .catch(() => { })
+            .then(() => { });
+        pendingTelemetry.push(p);
+    }
+    catch {
+        // Silently fail - telemetry should never break the CLI
+    }
+}
+/**
+ * Wait for all in-flight telemetry requests to settle.
+ * Called once at CLI exit so the process doesn't hang on open sockets
+ * but also doesn't drop data by exiting too early.
+ */
+export async function flushTelemetry(timeoutMs = 5000) {
+    if (pendingTelemetry.length === 0)
+        return;
+    const timeout = new Promise((resolve) => setTimeout(resolve, timeoutMs));
+    await Promise.race([Promise.all(pendingTelemetry), timeout]);
+}

package/dist/vendor/skills/src/test-utils.js

@@ -0,0 +1,59 @@
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { stripTerminalEscapes } from "./sanitize.js";
+// const PROJECT_ROOT = join(import.meta.dirname, '..');
+const CLI_PATH = join(import.meta.dirname, 'cli.ts');
+export function stripAnsi(str) {
+    return stripTerminalEscapes(str);
+}
+export function stripLogo(str) {
+    return str
+        .split('\n')
+        .filter((line) => !line.includes('███') && !line.includes('╔') && !line.includes('╚'))
+        .join('\n')
+        .replace(/^\n+/, '');
+}
+export function hasLogo(str) {
+    return str.includes('███') || str.includes('╔') || str.includes('╚');
+}
+export function runCli(args, cwd, env, timeout) {
+    try {
+        const output = execSync(`node "${CLI_PATH}" ${args.join(' ')}`, {
+            encoding: 'utf-8',
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            env: env ? { ...process.env, ...env } : undefined,
+            timeout: timeout ?? 30000,
+        });
+        return { stdout: stripAnsi(output), stderr: '', exitCode: 0 };
+    }
+    catch (error) {
+        return {
+            stdout: stripAnsi(error.stdout || ''),
+            stderr: stripAnsi(error.stderr || ''),
+            exitCode: error.status || 1,
+        };
+    }
+}
+export function runCliOutput(args, cwd) {
+    const result = runCli(args, cwd);
+    return result.stdout || result.stderr;
+}
+export function runCliWithInput(args, input, cwd) {
+    try {
+        const output = execSync(`node "${CLI_PATH}" ${args.join(' ')}`, {
+            encoding: 'utf-8',
+            cwd,
+            input: input + '\n',
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { stdout: stripAnsi(output), stderr: '', exitCode: 0 };
+    }
+    catch (error) {
+        return {
+            stdout: stripAnsi(error.stdout || ''),
+            stderr: stripAnsi(error.stderr || ''),
+            exitCode: error.status || 1,
+        };
+    }
+}

package/dist/vendor/skills/src/types.js

@@ -0,0 +1 @@
+export {};

package/dist/vendor/skills/src/update-source.js

@@ -0,0 +1,76 @@
+export function formatSourceInput(sourceUrl, ref) {
+    if (!ref) {
+        return sourceUrl;
+    }
+    return `${sourceUrl}#${ref}`;
+}
+/**
+ * Derive the skill's folder path from a SKILL.md-terminated skillPath.
+ * Returns '' when the skill lives at the repo root.
+ */
+function deriveSkillFolder(skillPath) {
+    let folder = skillPath;
+    if (folder.endsWith('/SKILL.md')) {
+        folder = folder.slice(0, -9);
+    }
+    else if (folder.endsWith('SKILL.md')) {
+        folder = folder.slice(0, -8);
+    }
+    if (folder.endsWith('/')) {
+        folder = folder.slice(0, -1);
+    }
+    return folder;
+}
+/**
+ * Whether a skill folder can be safely appended to the given source as a
+ * subpath. Only true for sources the source-parser can resolve as a
+ * GitHub/GitLab tree URL — owner/repo shorthand or an HTTPS URL on those
+ * hosts. Full SSH URLs (`git@host:owner/repo.git`) and generic Git URLs
+ * (anything ending in `.git`, or hosts other than github.com/gitlab.com)
+ * cannot have a subpath appended without producing an unclonable URL.
+ */
+function supportsAppendedSubpath(source) {
+    if (source.startsWith('git@'))
+        return false;
+    if (source.endsWith('.git'))
+        return false;
+    if (source.startsWith('http://') || source.startsWith('https://')) {
+        try {
+            const host = new URL(source).hostname;
+            return host === 'github.com' || host === 'gitlab.com';
+        }
+        catch {
+            return false;
+        }
+    }
+    return true;
+}
+function appendFolderAndRef(source, skillPath, ref) {
+    if (!supportsAppendedSubpath(source)) {
+        return formatSourceInput(source, ref);
+    }
+    const folder = deriveSkillFolder(skillPath);
+    const withFolder = folder ? `${source}/${folder}` : source;
+    return ref ? `${withFolder}#${ref}` : withFolder;
+}
+/**
+ * Build the source argument for `skills add` during update.
+ * Uses shorthand form for path-targeted updates to avoid branch/path ambiguity.
+ */
+export function buildUpdateInstallSource(entry) {
+    if (!entry.skillPath) {
+        return formatSourceInput(entry.sourceUrl, entry.ref);
+    }
+    return appendFolderAndRef(entry.source, entry.skillPath, entry.ref);
+}
+/**
+ * Build the source argument for `skills add` during project-level update.
+ * Local lock entries don't carry `sourceUrl`, so we fall back to the bare
+ * `source` identifier when no `skillPath` is available.
+ */
+export function buildLocalUpdateSource(entry) {
+    if (!entry.skillPath) {
+        return formatSourceInput(entry.source, entry.ref);
+    }
+    return appendFolderAndRef(entry.source, entry.skillPath, entry.ref);
+}