netlify-cli 27.11.2 → 27.12.0

package/dist/commands/base-command.js

@@ -248,7 +248,7 @@ export default class BaseCommand extends Command {
         };
         help.longestSubcommandTermLength = (command) => getCommands(command).reduce((max, cmd) => Math.max(max, cmd.name().length), 0);
         /** override the longestOptionTermLength to react on hide options flag */
-        help.longestOptionTermLength = (command, helper) => (command.noBaseOptions === false &&
+        help.longestOptionTermLength = (command, helper) => (!command.noBaseOptions &&
             helper.visibleOptions(command).reduce((max, option) => Math.max(max, helper.optionTerm(option).length), 0)) ||
             0;
         help.formatHelp = (command, helper) => {
@@ -284,7 +284,7 @@ export default class BaseCommand extends Command {
             if (argumentList.length !== 0) {
                 output = [...output, chalk.bold('ARGUMENTS'), formatHelpList(argumentList), ''];
             }
-            if (command.#noBaseOptions === false) {
+            if (!command.#noBaseOptions) {
                 // Options
                 const optionList = helper
                     .visibleOptions(command)

package/dist/commands/dev/dev.js

@@ -91,7 +91,7 @@ export const dev = async (options, command) => {
         log(`${NETLIFYDEVLOG} Injecting environment variable values for ${chalk.yellow('all scopes')}`);
     }
     env = await getDotEnvVariables({ devConfig, env, site });
-    const { accountId, addonsUrls, capabilities, siteUrl, timeouts } = await getSiteInformation({
+    const { accountId, capabilities, siteUrl, timeouts } = await getSiteInformation({
         // inherited from base command --offline
         offline: options.offline,
         api,
@@ -217,7 +217,6 @@ export const dev = async (options, command) => {
     };
     const inspectSettings = generateInspectSettings(options.edgeInspect, options.edgeInspectBrk);
     await startProxyServer({
-        addonsUrls,
         aiGatewayContext,
         api,
         blobsContext,

package/dist/commands/env/env-clone.js

@@ -30,7 +30,7 @@ const cloneEnvVars = async ({ api, force, siteFrom, siteTo }) => {
     const siteId = siteTo.id;
     // @ts-expect-error TS(7031) FIXME: Binding element 'key' implicitly has an 'any' type... Remove this comment to see the full error message
     const envVarsToDelete = envelopeTo.filter(({ key }) => keysFrom.includes(key));
-    if (envVarsToDelete.length !== 0 && Boolean(force) === false) {
+    if (envVarsToDelete.length !== 0 && !force) {
         await promptEnvCloneOverwrite(siteTo.id, envVarsToDelete);
     }
     // delete marked env vars in parallel

package/dist/commands/env/env-set.js

@@ -34,7 +34,7 @@ const setInEnvelope = async ({ api, context, force, key, scope, secret, siteInfo
     // @ts-expect-error TS(7006) FIXME: Parameter 'envVar' implicitly has an 'any' type.
     const existing = envelopeVariables.find((envVar) => envVar.key === key);
     // Checks if --force is passed and if it is an existing variaible, then we need to prompt the user
-    if (Boolean(force) === false && existing) {
+    if (!force && existing) {
         await promptOverwriteEnvVariable(key);
     }
     const params = { accountId, siteId, key };

package/dist/commands/env/env-unset.js

@@ -21,7 +21,7 @@ const unsetInEnvelope = async ({ api, context, force, key, siteInfo }) => {
         // if not, no need to call delete; return early
         return env;
     }
-    if (Boolean(force) === false) {
+    if (!force) {
         await promptOverwriteEnvVariable(key);
     }
     const params = { accountId, siteId, key };

package/dist/commands/functions/functions-create.js

@@ -5,13 +5,12 @@ import { createRequire } from 'module';
 import path, { dirname, join, relative } from 'path';
 import process from 'process';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { confirm, input, search, select, Separator } from '@inquirer/prompts';
+import { input, search, select, Separator } from '@inquirer/prompts';
 import { findUp } from 'find-up';
 import fuzzy from 'fuzzy';
 import fetch from 'node-fetch';
 import { createSpinner } from 'nanospinner';
 import { fileExistsAsync } from '../../lib/fs.js';
-import { getAddons, getCurrentAddon, getSiteData } from '../../utils/addons/prepare.js';
 import { NETLIFYDEVERR, NETLIFYDEVLOG, NETLIFYDEVWARN, chalk, logAndThrowError, log, } from '../../utils/command-helpers.js';
 import { copyTemplateDir } from '../../utils/copy-template-dir/copy-template-dir.js';
 import { getDotEnvVariables, injectEnvVariables } from '../../utils/dev.js';
@@ -313,8 +312,7 @@ const downloadFromURL = async function (command, options, argumentName, function
     // read, execute, and delete function template file if exists
     const fnTemplateFile = path.join(fnFolder, '.netlify-function-template.mjs');
     if (await fileExistsAsync(fnTemplateFile)) {
-        const { default: { addons = [], onComplete }, } = await import(pathToFileURL(fnTemplateFile).href);
-        await installAddons(command, addons, path.resolve(fnFolder));
+        const { default: { onComplete }, } = await import(pathToFileURL(fnTemplateFile).href);
         await handleOnComplete({ command, onComplete });
         // delete
         await unlink(fnTemplateFile);
@@ -400,7 +398,7 @@ const scaffoldFromTemplate = async function (command, options, argumentName, fun
         log(`${NETLIFYDEVLOG} Open in browser: https://github.com/netlify/cli/issues/new`);
     }
     else {
-        const { addons = [], lang, name: templateName, onComplete } = chosenTemplate;
+        const { lang, name: templateName, onComplete } = chosenTemplate;
         const pathToTemplate = path.join(templatesDir, lang, templateName);
         if (!fs.existsSync(pathToTemplate)) {
             throw new Error(`There isn't a corresponding directory to the selected name. Template '${templateName}' is misconfigured`);
@@ -435,33 +433,12 @@ const scaffoldFromTemplate = async function (command, options, argumentName, fun
         if (funcType === 'edge') {
             await registerEFInToml(name, command.netlify);
         }
-        await installAddons(command, addons, path.resolve(functionPath));
         await handleOnComplete({ command, onComplete });
         log();
         log(chalk.greenBright(`Function created!`));
     }
 };
 const TEMPLATE_PERMISSIONS = 0o777;
-// @ts-expect-error TS(7031) FIXME: Binding element 'addonName' implicitly has an 'any... Remove this comment to see the full error message
-const createFunctionAddon = async function ({ addonName, addons, api, siteData, siteId }) {
-    try {
-        const addon = getCurrentAddon({ addons, addonName });
-        if (addon && addon.id) {
-            log(`The "${addonName} add-on" already exists for ${siteData.name}`);
-            return false;
-        }
-        await api.createServiceInstance({
-            siteId,
-            addon: addonName,
-            body: { config: {} },
-        });
-        log(`Add-on "${addonName}" created for ${siteData.name}`);
-        return true;
-    }
-    catch (error_) {
-        return logAndThrowError(error_.message);
-    }
-};
 /**
  *
  * @param {object} config
@@ -481,73 +458,6 @@ const handleOnComplete = async ({ command, onComplete }) => {
         await onComplete.call(command);
     }
 };
-/**
- *
- * @param {object} config
- * @param {*} config.addonCreated
- * @param {*} config.addonDidInstall
- * @param {import('../base-command.js').default} config.command
- * @param {string} config.fnPath
- */
-// @ts-expect-error TS(7031) FIXME: Binding element 'addonCreated' implicitly has an '... Remove this comment to see the full error message
-const handleAddonDidInstall = async ({ addonCreated, addonDidInstall, command, fnPath }) => {
-    const { config } = command.netlify;
-    if (!addonCreated || !addonDidInstall) {
-        return;
-    }
-    const confirmPostInstall = await confirm({
-        message: `This template has an optional setup script that runs after addon install. This can be helpful for first time users to try out templates. Run the script?`,
-        default: false,
-    });
-    if (!confirmPostInstall) {
-        return;
-    }
-    await injectEnvVariables({
-        devConfig: { ...config.dev },
-        env: command.netlify.cachedConfig.env,
-        site: command.netlify.site,
-    });
-    addonDidInstall(fnPath);
-};
-/**
- *
- * @param {import('../base-command.js').default} command
- * @param {*} functionAddons
- * @param {*} fnPath
- * @returns
- */
-// @ts-expect-error TS(7006) FIXME: Parameter 'command' implicitly has an 'any' type.
-const installAddons = async function (command, functionAddons, fnPath) {
-    if (functionAddons.length === 0) {
-        return;
-    }
-    const { api, site } = command.netlify;
-    const siteId = site.id;
-    if (!siteId) {
-        log('No project id found, please run inside a project directory or `netlify link`');
-        return false;
-    }
-    log(`${NETLIFYDEVLOG} checking Netlify APIs...`);
-    const [siteData, siteAddons] = await Promise.all([getSiteData({ api, siteId }), getAddons({ api, siteId })]);
-    // @ts-expect-error TS(7031) FIXME: Binding element 'addonDidInstall' implicitly has a... Remove this comment to see the full error message
-    const arr = functionAddons.map(async ({ addonDidInstall, addonName }) => {
-        log(`${NETLIFYDEVLOG} installing addon: ${chalk.yellow.inverse(addonName)}`);
-        try {
-            const addonCreated = await createFunctionAddon({
-                api,
-                addons: siteAddons,
-                siteId,
-                addonName,
-                siteData,
-            });
-            await handleAddonDidInstall({ addonCreated, addonDidInstall, command, fnPath });
-        }
-        catch (error_) {
-            return logAndThrowError(`${NETLIFYDEVERR} Error installing addon: ${error_}`);
-        }
-    });
-    return Promise.all(arr);
-};
 /**
  *
  * @param {string} funcName

package/dist/commands/init/index.js

@@ -4,6 +4,8 @@ export const createInitCommand = (program) => program
     .description('Configure continuous deployment for a new or existing project. To create a new project without continuous deployment, use `netlify sites:create`')
     .option('-m, --manual', 'Manually configure a git remote for CI')
     .option('--git-remote-name <name>', 'Name of Git remote to use. e.g. "origin"')
+    .option('--skip-agent-setup', 'Skip installing Netlify skills for AI coding agents into the project')
+    .option('--reset-context', 'Replace locally edited Netlify skills with the latest release, and migrate or delete edited copies under renamed or deprecated names')
     .addHelpText('after', () => {
     const docsUrl = 'https://docs.netlify.com/cli/get-started/';
     return `
@@ -12,6 +14,9 @@ For more information about getting started with Netlify CLI, see ${terminalLink(
 })
     .action(async (options, command) => {
     const { init } = await import('./init.js');
-    await init(options, command);
+    await init(options, command, {
+        setupAgentSkills: !options.skipAgentSetup,
+        resetContext: Boolean(options.resetContext),
+    });
 });
 //# sourceMappingURL=index.js.map

package/dist/commands/init/init.d.ts

@@ -6,7 +6,9 @@ type InitExitMessageCustomizer = (code: InitExitCode, defaultMessage: string) =>
 type InitExtraOptions = {
     customizeExitMessage?: InitExitMessageCustomizer | undefined;
     exitAfterConfiguringRepo?: boolean | undefined;
+    setupAgentSkills?: boolean | undefined;
+    resetContext?: boolean | undefined;
 };
-export declare const init: (options: OptionValues, command: BaseCommand, { customizeExitMessage, exitAfterConfiguringRepo }?: InitExtraOptions) => Promise<SiteInfo>;
+export declare const init: (options: OptionValues, command: BaseCommand, { customizeExitMessage, exitAfterConfiguringRepo, setupAgentSkills: shouldSetupAgentSkills, resetContext, }?: InitExtraOptions) => Promise<SiteInfo>;
 export {};
 //# sourceMappingURL=init.d.ts.map

package/dist/commands/init/init.js

@@ -7,6 +7,7 @@ import { configureRepo } from '../../utils/init/config.js';
 import { track } from '../../utils/telemetry/index.js';
 import { link } from '../link/link.js';
 import { sitesCreate } from '../sites/sites-create.js';
+import { setupAgentSkills } from '../../utils/init/agent-skills.js';
 import { getBuildSettings, saveNetlifyToml } from '../../utils/init/utils.js';
 import { LINKED_EXISTING_SITE_EXIT_CODE, LINKED_NEW_SITE_EXIT_CODE } from './constants.js';
 const persistState = ({ siteInfo, state }) => {
@@ -147,14 +148,33 @@ const logExistingRepoSetupAndExit = ({ repoUrl, siteName, customizeExitMessage,
     // TODO add support for changing GitHub repo in site:config command
     exit();
 };
-export const init = async (options, command, { customizeExitMessage, exitAfterConfiguringRepo = false } = {}) => {
-    command.setAnalyticsPayload({ manual: options.manual, force: options.force });
+const installAgentSkills = async (command, reset) => {
+    log();
+    const result = await setupAgentSkills({ workingDir: command.netlify.repositoryRoot, reset });
+    await track('sites_agentSkillsSetup', {
+        installed: result.installed,
+        directories: result.directories,
+        skillsVersion: result.skillsVersion,
+        resetContext: reset,
+        ...result.summary,
+    });
+};
+export const init = async (options, command, { customizeExitMessage, exitAfterConfiguringRepo = false, setupAgentSkills: shouldSetupAgentSkills = false, resetContext = false, } = {}) => {
+    command.setAnalyticsPayload({
+        manual: options.manual,
+        force: options.force,
+        skipAgentSetup: options.skipAgentSetup,
+        resetContext: options.resetContext,
+    });
     const { repositoryRoot, state } = command.netlify;
     const { siteInfo: existingSiteInfo } = command.netlify;
     // Check logged in status
     await command.authenticate();
     // Add .netlify to .gitignore file
     await ensureNetlifyIgnore(repositoryRoot);
+    if (shouldSetupAgentSkills) {
+        await installAgentSkills(command, resetContext);
+    }
     const repoUrl = getRepoUrl(existingSiteInfo);
     if (repoUrl && !options.force) {
         logExistingAndExit({ siteInfo: existingSiteInfo });

package/dist/commands/serve/serve.js

@@ -33,7 +33,7 @@ export const serve = async (options, command) => {
         log(`${NETLIFYDEVLOG} Injecting environment variable values for ${chalk.yellow('all scopes')}`);
     }
     env = await getDotEnvVariables({ devConfig, env, site });
-    const { accountId, addonsUrls, capabilities, siteUrl, timeouts } = await getSiteInformation({
+    const { accountId, capabilities, siteUrl, timeouts } = await getSiteInformation({
         // inherited from base command --offline
         offline: options.offline,
         api,
@@ -145,7 +145,6 @@ export const serve = async (options, command) => {
     };
     const inspectSettings = generateInspectSettings(options.edgeInspect, options.edgeInspectBrk);
     const url = await startProxyServer({
-        addonsUrls,
         blobsContext: runtimeBlobsContext,
         command,
         config: mergedConfig,

package/dist/commands/sites/sites-list.js

@@ -20,7 +20,7 @@ export const sitesList = async (options, command) => {
                 ssl_url: site.ssl_url,
                 account_name: site.account_name,
             };
-            if (site.build_settings && site.build_settings.repo_url) {
+            if (site.build_settings?.repo_url) {
                 siteInfo.repo_url = site.build_settings.repo_url;
             }
             return siteInfo;

package/dist/commands/unlink/unlink.js

@@ -13,7 +13,7 @@ export const unlink = async (_options, command) => {
     await track('sites_unlinked', {
         siteId: siteData.id || siteId,
     });
-    if (site && site.configPath) {
+    if (site?.configPath) {
         log(`Unlinked ${site.configPath} from ${siteData ? siteData.name : siteId}`);
     }
     else {

package/dist/lib/edge-functions/registry.js

@@ -235,7 +235,6 @@ export class EdgeFunctionsRegistryImpl {
         Object.entries(envConfig).forEach(([key, variable]) => {
             if (variable.sources.includes('ui') ||
                 variable.sources.includes('account') ||
-                variable.sources.includes('addons') ||
                 variable.sources.includes('internal') ||
                 variable.sources.some((source) => source.startsWith('.env'))) {
                 env[key] = variable.value;

package/dist/lib/exec-fetcher.js

@@ -105,7 +105,7 @@ export const shouldFetchLatestVersion = async ({ binPath, execArgs, execName, la
     if (!stdout) {
         return false;
     }
-    const match = stdout.match(new RegExp(pattern));
+    const match = new RegExp(pattern).exec(stdout);
     if (!match) {
         return false;
     }

package/dist/lib/functions/form-submissions-handler.js

@@ -46,7 +46,8 @@ export const createFormSubmissionHandler = function ({ functionsRegistry, siteUr
         }
         const originalUrl = new URL(req.url, 'http://localhost');
         req.url = `/.netlify/functions/${handlerName}${originalUrl.search}`;
-        const ct = parseContentType(req);
+        // A missing header parses to an empty type and takes the unsupported-type branch below.
+        const ct = parseContentType(req.headers['content-type'] ?? '');
         let fields = {};
         let files = {};
         if (ct.type.endsWith('/x-www-form-urlencoded')) {

package/dist/recipes/ai-context/context.js

@@ -73,7 +73,7 @@ export const parseContextFile = (contents) => {
     const result = {
         contents,
     };
-    const providerContext = contents.match(PROVIDER_CONTEXT_REGEX);
+    const providerContext = PROVIDER_CONTEXT_REGEX.exec(contents);
     if (providerContext) {
         const [, attributes, innerContents] = providerContext;
         result.innerContents = innerContents;
@@ -90,7 +90,7 @@ export const parseContextFile = (contents) => {
             }
         }
     }
-    const contextOverrides = contents.match(PROVIDER_CONTEXT_OVERRIDES_REGEX);
+    const contextOverrides = PROVIDER_CONTEXT_OVERRIDES_REGEX.exec(contents);
     if (contextOverrides) {
         const [overrideContents, , innerContents] = contextOverrides;
         result.overrides = {

package/dist/utils/dev.d.ts

@@ -22,7 +22,6 @@ interface GetSiteInformationOptions {
     siteInfo: SiteInfo;
 }
 export interface SiteInformationResult {
-    addonsUrls: Record<string, string>;
     siteUrl: string;
     accountId?: string;
     capabilities: {

package/dist/utils/dev.js

@@ -10,10 +10,6 @@ const ENV_VAR_SOURCES = {
         name: 'shared',
         printFn: chalk.magenta,
     },
-    addons: {
-        name: 'addon',
-        printFn: chalk.yellow,
-    },
     configFile: {
         name: 'netlify.toml file',
         printFn: chalk.green,
@@ -47,25 +43,6 @@ const getAccounts = async ({ api }) => {
         return logAndThrowError(`Failed retrieving user account: ${error_.message}. ${ERROR_CALL_TO_ACTION}`);
     }
 };
-// @ts-expect-error TS(7031) FIXME: Binding element 'api' implicitly has an 'any' type... Remove this comment to see the full error message
-const getAddons = async ({ api, site }) => {
-    try {
-        const addons = await api.listServiceInstancesForSite({ siteId: site.id });
-        return addons;
-    }
-    catch (error_) {
-        return logAndThrowError(`Failed retrieving addons for site ${chalk.yellow(site.id)}: ${error_.message}. ${ERROR_CALL_TO_ACTION}`);
-    }
-};
-// @ts-expect-error TS(7031) FIXME: Binding element 'addons' implicitly has an 'any' t... Remove this comment to see the full error message
-const getAddonsInformation = ({ addons, siteInfo }) => {
-    const urls = Object.fromEntries(
-    // @ts-expect-error TS(7006) FIXME: Parameter 'addon' implicitly has an 'any' type.
-    addons.map((addon) => [addon.service_slug, `${siteInfo.ssl_url}${addon.service_path}`]));
-    // @ts-expect-error TS(7006) FIXME: Parameter 'addon' implicitly has an 'any' type.
-    const env = Object.assign({}, ...addons.map((addon) => addon.env));
-    return { urls, env };
-};
 const getSiteAccount = ({ accounts, siteInfo }) => {
     const siteAccount = accounts.find((account) => account.slug === siteInfo.account_slug);
     if (!siteAccount) {
@@ -81,11 +58,9 @@ const BACKGROUND_FUNCTION_TIMEOUT = 900;
 export const getSiteInformation = async ({ api, offline, site, siteInfo, }) => {
     if (site.id && !offline) {
         validateSiteInfo({ site, siteInfo });
-        const [accounts, addons] = await Promise.all([getAccounts({ api }), getAddons({ api, site })]);
-        const { urls: addonsUrls } = getAddonsInformation({ siteInfo, addons });
+        const accounts = await getAccounts({ api });
         const account = getSiteAccount({ siteInfo, accounts });
         return {
-            addonsUrls,
             siteUrl: siteInfo.ssl_url,
             accountId: account?.id,
             capabilities: {
@@ -100,7 +75,6 @@ export const getSiteInformation = async ({ api, offline, site, siteInfo, }) => {
     }
     // best defaults we can have without retrieving site information
     return {
-        addonsUrls: {},
         siteUrl: '',
         capabilities: {
             aiGatewayDisabled: false,

package/dist/utils/env/index.js

@@ -180,7 +180,6 @@ export const getEnvelopeEnv = async ({ api, context = 'dev', env, key = '', raw
     }
     const generalEnv = filterEnvBySource(env, 'general');
     const internalEnv = filterEnvBySource(env, 'internal');
-    const addonsEnv = filterEnvBySource(env, 'addons');
     const configFileEnv = filterEnvBySource(env, 'configFile');
     // filter out configFile env vars if a non-configFile scope is passed
     const includeConfigEnvVars = /any|builds|post[-_]processing/.test(scope);
@@ -188,7 +187,6 @@ export const getEnvelopeEnv = async ({ api, context = 'dev', env, key = '', raw
     return {
         ...generalEnv,
         ...accountEnv,
-        ...(includeConfigEnvVars ? addonsEnv : {}),
         ...siteEnv,
         ...(includeConfigEnvVars ? configFileEnv : {}),
         ...internalEnv,
@@ -249,7 +247,7 @@ export const translateFromEnvelopeToMongo = (envVars = [], context = 'dev') => e
     .sort((a, b) => (a.key.toLowerCase() < b.key.toLowerCase() ? -1 : 1))
     .reduce((acc, cur) => {
     const envVar = cur.values.find((val) => [context, 'all'].includes((val.context_parameter ?? '') || val.context));
-    if (envVar && envVar.value) {
+    if (envVar?.value) {
         return {
             ...acc,
             [cur.key]: envVar.value,

package/dist/utils/get-repo-data.js

@@ -11,7 +11,7 @@ const getRepoData = async ({ remoteName, workingDir, }) => {
             util.promisify(gitconfiglocal)(workingDir),
             findUp('.git', { cwd: workingDir, type: 'directory' }),
         ]);
-        if (!gitDirectory || !gitConfig || !gitConfig.remote || Object.keys(gitConfig.remote).length === 0) {
+        if (!gitDirectory || !gitConfig?.remote || Object.keys(gitConfig.remote).length === 0) {
             throw new Error('No Git remote found');
         }
         const baseGitPath = dirname(gitDirectory);

package/dist/utils/init/agent-skills.d.ts

@@ -0,0 +1,96 @@
+export declare const DEFAULT_SKILLS_HOST = "https://netlify-agent-skills.netlify.app";
+export declare const SKILLS_HOST_ENV = "NETLIFY_SKILLS_HOST";
+export declare const DEFAULT_SKILLS_DIRECTORY: string;
+export interface SkillHistoryEntry {
+    version: string | null;
+    name?: string;
+    tree_hash: string;
+}
+export interface ManifestSkill {
+    name: string;
+    status: 'active' | 'deprecated';
+    version: string | null;
+    prior_names?: string[];
+    description?: string;
+    tree_hash: string | null;
+    files?: Record<string, string>;
+    executable?: string[];
+    history?: SkillHistoryEntry[];
+    deprecated?: {
+        since: string;
+        replaced_by?: string;
+    };
+}
+export interface SkillsManifest {
+    schema_version: number;
+    version: string;
+    skills: ManifestSkill[];
+}
+export type SkillRecord = {
+    name: string;
+    status: 'current';
+    version: string | null;
+} | {
+    name: string;
+    status: 'stale';
+    version: string | null;
+    have: string | null;
+} | {
+    name: string;
+    status: 'modified';
+    version: string | null;
+} | {
+    name: string;
+    status: 'renamed';
+    currentName: string;
+    modified: boolean;
+} | {
+    name: string;
+    status: 'deprecated';
+    replacedBy: string | null;
+    modified: boolean;
+} | {
+    name: string;
+    status: 'unknown';
+};
+export interface SkillsClassification {
+    skills: SkillRecord[];
+    missing: string[];
+}
+export type SkillAction = 'current' | 'added' | 'updated' | 'reset' | 'renamed' | 'removed' | 'kept' | 'ignored' | 'failed';
+export interface SkillActionRecord {
+    name: string;
+    action: SkillAction;
+    detail?: string;
+}
+export interface SkillsSyncResult {
+    directory: string;
+    actions: SkillActionRecord[];
+}
+export declare const resolveSkillsHost: (env?: NodeJS.ProcessEnv) => string;
+export declare const fetchSkillsManifest: (host: string) => Promise<SkillsManifest>;
+export declare const hashSkillTree: (dir: string, declaredExecutable?: Set<string>) => Promise<string>;
+export declare const classifySkillsDirectory: (root: string, manifest: SkillsManifest) => Promise<SkillsClassification>;
+export declare const installSkill: (host: string, dest: string, skill: ManifestSkill, { force }?: {
+    force?: boolean;
+}) => Promise<number>;
+export declare const syncSkills: ({ host, directory, manifest, reset, }: {
+    host: string;
+    directory: string;
+    manifest: SkillsManifest;
+    reset?: boolean;
+}) => Promise<SkillsSyncResult>;
+export declare const resolveSkillsDirectories: (workingDir: string, env?: NodeJS.ProcessEnv) => Promise<string[]>;
+export interface AgentSkillsSetupSummary {
+    installed: boolean;
+    directories: string[];
+    skillsVersion?: string;
+    summary: Record<SkillAction, number>;
+    error?: string;
+}
+export declare const setupAgentSkills: ({ workingDir, env, reset, }: {
+    workingDir: string;
+    env?: NodeJS.ProcessEnv;
+    reset?: boolean;
+}) => Promise<AgentSkillsSetupSummary>;
+//# sourceMappingURL=agent-skills.d.ts.map