vike 0.4.264 → 0.4.266

package/dist/node/vite/plugins/pluginDev/logSkillHint.d.ts

@@ -0,0 +1,4 @@
+export { logSkillHint };
+import type { ViteDevServer } from 'vite';
+import '../../assertEnvVite.js';
+declare function logSkillHint(server: ViteDevServer, userRootDir: string): void;

package/dist/node/vite/plugins/pluginDev/logSkillHint.js

@@ -0,0 +1,276 @@
+export { logSkillHint };
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { fileURLToPath } from 'node:url';
+import pc from '@brillout/picocolors';
+import { assert, assertInfo, assertUsage } from '../../../../utils/assert.js';
+import { assertKeys } from '../../../../utils/assertKeys.js';
+import { checkType } from '../../../../utils/checkType.js';
+import { crawlFiles } from '../../../../utils/crawlFiles.js';
+import { getGlobalObject } from '../../../../utils/getGlobalObject.js';
+import { getVikeConfigError } from '../../../../shared-server-node/getVikeConfigError.js';
+import { requireResolveOptional } from '../../../../utils/requireResolve.js';
+import { setTimeoutUnref } from '../../../../utils/setTimeoutUnref.js';
+import { isObject } from '../../../../utils/isObject.js';
+import { toPosixPath } from '../../../../utils/path.js';
+import { unique } from '../../../../utils/unique.js';
+import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
+import { getCacheValue, setCacheValue } from '../../shared/cache.js';
+import '../../assertEnvVite.js';
+const execFileA = promisify(execFile);
+const importMetaUrl = import.meta.url;
+const globalObject = getGlobalObject('logSkillHint.ts', {
+    alreadyChecked: false,
+});
+const docsUrl = 'https://vike.dev/ai#skill';
+const seeDocs = `— see ${pc.underline(docsUrl)}`;
+const suppressHint = `set ${pc.cyan('+ai.skill')} to ${pc.cyan('false')} to suppress this log.`;
+const logMissing = `Add Vike's skill for AI agents (Claude Code, Codex, Cursor, ...) ${seeDocs}, or ${suppressHint}`;
+const logOutdated = (skillFilePaths) => {
+    const isPlural = skillFilePaths.length > 1;
+    const files = skillFilePaths.map((f) => pc.cyan(f)).join(', ');
+    return `Your Vike skill${isPlural ? 's' : ''} ${files} ${isPlural ? "don't" : "doesn't"} match the official ${pc.cyan('vike/SKILL.md')}, update ${isPlural ? 'them' : 'it'} ${seeDocs}, or, if you maintain your own version, ${suppressHint}`;
+};
+const skillName = 'vike';
+// The skill file shipped by the vike npm package: node_modules/vike/skills/vike/SKILL.md (see packages/vike/scripts/copySkill.mjs)
+const skillFilePathInsidePackage = 'skills/vike/SKILL.md';
+// Cache entry at node_modules/.vike/cache.json, see cache.ts
+// - `false` => the check didn't log anything last time => skip the check (forever, until node_modules/ is removed)
+// - Nothing is written as long as the hint is logged => the check is re-run upon every dev start
+const cacheKey = 'logSkillHint';
+// Log a hint if the user didn't install Vike's skill for AI agents (vike/SKILL.md), or if it differs from the official one — https://vike.dev/ai#skill
+function logSkillHint(server, userRootDir) {
+    applyLate(server, () => checkSkill(userRootDir));
+}
+// Apply late — 5 seconds after the first request, or at most 10 seconds after the dev server started — so that it doesn't slow down dev start nor the first page requests.
+function applyLate(server, callback) {
+    let isDone = false;
+    const runAfter = (milliseconds) => {
+        setTimeoutUnref(() => {
+            if (isDone)
+                return;
+            isDone = true;
+            callback();
+        }, milliseconds);
+    };
+    if (server.httpServer) {
+        server.httpServer.once('listening', () => runAfter(10 * 1000));
+    }
+    else {
+        // Middleware mode: the HTTP server is owned by the user
+        runAfter(10 * 1000);
+    }
+    let isFirstRequest = true;
+    server.middlewares.use((_req, _res, next) => {
+        if (isFirstRequest) {
+            isFirstRequest = false;
+            runAfter(5 * 1000);
+        }
+        next();
+    });
+}
+async function checkSkill(userRootDir) {
+    try {
+        await checkSkillUnsafe(userRootDir);
+    }
+    catch (err) {
+        // The check runs in a timer (see applyLate()): a thrown error would be an unhandled rejection that kills the dev server => log it instead.
+        // - Environmental failures (Git missing, unreadable files, ...) are handled gracefully and don't throw.
+        // - What can throw: usage errors (e.g. an invalid +ai.skill value) and bugs.
+        console.error(err);
+    }
+}
+async function checkSkillUnsafe(userRootDir) {
+    if (globalObject.alreadyChecked)
+        return;
+    // Skip CI environments: the hint is meant for the machine of an app developer.
+    if (process.env.CI)
+        return;
+    const vikeConfig = await getVikeConfigInternal();
+    // Maybe the user disabled the check in a config file that currently has an error => retry later (Vite restarts upon config changes).
+    if (getVikeConfigError())
+        return;
+    if (!getConfigValueAiSkill(vikeConfig))
+        return;
+    globalObject.alreadyChecked = true;
+    // The check is skipped forever once it didn't log anything (until node_modules/ is removed) — see cacheKey
+    if ((await getCacheValue(userRootDir, cacheKey)) === false)
+        return;
+    const skillState = await getSkillState(userRootDir);
+    if (skillState.state === 'missing') {
+        assertInfo(false, logMissing, { onlyOnce: true });
+        return;
+    }
+    if (skillState.state === 'outdated') {
+        assertInfo(false, logOutdated(skillState.skillFilePaths), { onlyOnce: true });
+        return;
+    }
+    if (skillState.state === 'installed' ||
+        skillState.state === 'not-using-ai-agents' ||
+        skillState.state === 'vike-not-from-npm') {
+        await setCacheValue(userRootDir, cacheKey, false);
+        return;
+    }
+    checkType(skillState);
+    assert(false);
+}
+// Determine the state of the user's skill — without side effects: the caller checkSkillUnsafe() performs exactly one action per state.
+async function getSkillState(userRootDir) {
+    const repoRootDir = await getRepoRootDir(userRootDir);
+    const skillsDirs = await findSkillsDirs(repoRootDir, userRootDir);
+    const isUsingAiAgents = skillsDirs.length > 0 || (await hasAgentMarker(userRootDir, repoRootDir));
+    if (!isUsingAiAgents)
+        return { state: 'not-using-ai-agents' };
+    const skillContentExpected = await getSkillContentExpected();
+    if (skillContentExpected === null)
+        return { state: 'vike-not-from-npm' };
+    const skillFiles = await findSkillFiles(repoRootDir, skillsDirs, skillContentExpected);
+    if (skillFiles.length === 0)
+        return { state: 'missing' };
+    const skillFilesOutdated = skillFiles.filter((f) => f.isOutdated);
+    if (skillFilesOutdated.length > 0) {
+        const skillFilePaths = skillFilesOutdated.map((f) => toPosixPath(path.relative(userRootDir, f.filePathAbsolute)));
+        return { state: 'outdated', skillFilePaths };
+    }
+    else {
+        return { state: 'installed' };
+    }
+}
+// https://vike.dev/ai#settings
+function getConfigValueAiSkill(vikeConfig) {
+    const configAi = vikeConfig.config.ai;
+    if (configAi === undefined)
+        return true;
+    assertUsage(isObject(configAi), `Setting ${pc.cyan('ai')} should be an object`);
+    assertKeys(configAi, ['skill'], `Setting ${pc.cyan('ai')}:`);
+    const skill = configAi.skill;
+    if (skill === undefined)
+        return true;
+    assertUsage(typeof skill === 'boolean', `${pc.cyan('+ai.skill')} should be a boolean, see ${pc.underline(docsUrl)}`);
+    return skill;
+}
+// The root directory of the user's Git repository — skills directories usually live at the repository root (e.g. monorepos).
+async function getRepoRootDir(userRootDir) {
+    try {
+        const { stdout } = await execFileA('git', ['rev-parse', '--show-toplevel'], { cwd: userRootDir });
+        const gitRootDir = stdout.toString().trim();
+        if (gitRootDir)
+            return gitRootDir;
+    }
+    catch {
+        // Git isn't installed, or the app isn't inside a Git repository
+    }
+    return userRootDir;
+}
+// Discover the skills directories of the user's repository, following the Agent Skills convention `**/skills/*/SKILL.md` (https://agentskills.io) — e.g. .claude/skills/ (Claude Code) and .agents/skills/ (Codex, Gemini CLI, Cursor, ...).
+async function findSkillsDirs(repoRootDir, userRootDir) {
+    // - skills-npm installs skills as gitignored symlinks (`**/skills/npm-*`) that `$ git ls-files` cannot see => tinyglobby (which finds gitignored files and follows symlinks)
+    // - Otherwise `$ git ls-files` only: we don't want to crawl the entire directory tree of the user's repository upon every dev start
+    const useGlob = isUsingSkillsNpm(userRootDir);
+    const files = await crawlFiles({
+        filePattern: '**/skills/*/SKILL',
+        fileExtension: ['md'],
+        cwd: repoRootDir,
+        // Skills directories usually live inside dot directories (e.g. .claude/ and .agents/)
+        dot: true,
+        crawler: { git: !useGlob, glob: useGlob },
+    });
+    const skillsDirs = unique(files.map((filePath) => path.posix.dirname(path.posix.dirname(filePath)))).sort();
+    return skillsDirs;
+}
+// Whether the user installed skills-npm (https://github.com/antfu/skills-npm)
+function isUsingSkillsNpm(userRootDir) {
+    return requireResolveOptional({ importPath: 'skills-npm', importerFilePath: null, userRootDir }) !== null;
+}
+// Whether the app seems to use AI agents, even without any skills directory: instruction files and config directories of AI agents, at the app's root directory and at the repository's root directory.
+const agentMarkers = [
+    // Instruction files
+    'AGENTS.md', // Codex, Cursor, Gemini CLI, GitHub Copilot, Amp, Zed, OpenCode, Jules, Devin, ...
+    'CLAUDE.md', // Claude Code
+    'GEMINI.md', // Gemini CLI
+    '.cursorrules', // Cursor (legacy)
+    '.clinerules', // Cline (file or directory)
+    '.windsurfrules', // Windsurf (legacy)
+    '.github/copilot-instructions.md', // GitHub Copilot
+    '.mcp.json', // Claude Code (project MCP servers)
+    // Config directories
+    '.claude', // Claude Code
+    '.agents', // Codex, Cursor, Gemini CLI, GitHub Copilot, OpenCode, Cline, Amp, Zed, ...
+    '.cursor', // Cursor
+    '.gemini', // Gemini CLI
+    '.windsurf', // Windsurf
+    '.junie', // JetBrains Junie
+    '.kiro', // Kiro
+    '.roo', // Roo Code
+    '.continue', // Continue
+    '.github/instructions', // GitHub Copilot
+];
+async function hasAgentMarker(userRootDir, repoRootDir) {
+    const dirs = unique([userRootDir, repoRootDir]);
+    const results = await Promise.all(dirs.flatMap((dir) => agentMarkers.map((marker) => isReadable(path.join(dir, ...marker.split('/'))))));
+    return results.some(Boolean);
+}
+// Find the installed copies of Vike's skill: `vike/SKILL.md` (manual and skills.sh installs) as well as `npm-vike-vike/SKILL.md` (skills-npm installs).
+async function findSkillFiles(repoRootDir, skillsDirs, skillContentExpected) {
+    const skillFiles = [];
+    for (const skillsDir of skillsDirs) {
+        const skillsDirAbsolute = path.join(repoRootDir, ...skillsDir.split('/'));
+        const entries = await fs.readdir(skillsDirAbsolute).catch(() => []);
+        for (const entry of entries) {
+            if (!entry.toLowerCase().includes(skillName))
+                continue;
+            const filePathAbsolute = path.join(skillsDirAbsolute, entry, 'SKILL.md');
+            // fs.readFile() follows symlinks — a dangling symlink (e.g. after removing node_modules/) is treated as missing
+            const content = await fs.readFile(filePathAbsolute, 'utf8').catch(() => null);
+            if (content === null)
+                continue;
+            // Skip other skills, e.g. `vike-react/SKILL.md`
+            if (getSkillName(content) !== skillName)
+                continue;
+            const isOutdated = normalizeContent(content) !== normalizeContent(skillContentExpected);
+            skillFiles.push({ filePathAbsolute, isOutdated });
+        }
+    }
+    return skillFiles;
+}
+// The `name` field of the YAML frontmatter
+function getSkillName(skillFileContent) {
+    const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(skillFileContent)?.[1];
+    if (!frontmatter)
+        return null;
+    const name = /^name:[ \t]*["']?([^"'\s]+)["']?[ \t]*$/m.exec(frontmatter)?.[1];
+    return name ?? null;
+}
+// Ignore line endings (e.g. Git's autocrlf on Windows) and trailing whitespace
+function normalizeContent(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trimEnd())
+        .join('\n')
+        .trim();
+}
+async function getSkillContentExpected() {
+    // [RELATIVE_PATH_FROM_DIST] Current file: node_modules/vike/dist/node/vite/plugins/pluginDev/logSkillHint.js
+    assert(importMetaUrl.includes('/dist/node/vite/plugins/pluginDev/'));
+    const filePath = fileURLToPath(new URL(`../../../../../${skillFilePathInsidePackage}`, importMetaUrl));
+    let fileContent;
+    try {
+        fileContent = await fs.readFile(filePath, 'utf8');
+    }
+    catch {
+        // The file is added upon publishing (`$ pnpm publish` => `prepack` script) => it's missing when Vike is linked (e.g. when running an example of the Vike monorepo)
+        return null;
+    }
+    return fileContent;
+}
+async function isReadable(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/node/vite/plugins/pluginDev.js

@@ -2,10 +2,9 @@ export { pluginDev };
 export { logDockerHint };
 import { optimizeDeps, resolveOptimizeDeps } from './pluginDev/optimizeDeps.js';
 import { determineFsAllowList } from './pluginDev/determineFsAllowList.js';
-// import { autoAddVikeSkill } from './pluginDev/autoAddVikeSkill.js'
+import { logSkillHint } from './pluginDev/logSkillHint.js';
 import { addSsrMiddleware } from '../shared/addSsrMiddleware.js';
 import { isDebugError } from '../../../utils/debug.js';
-// import { setTimeoutUnref } from '../../../utils/setTimeoutUnref.js'
 import { applyDev } from '../../../utils/isDev.js';
 import { isDocker } from '../../../utils/isDocker.js';
 import { assertWarning } from '../../../utils/assert.js';
@@ -36,16 +35,11 @@ function pluginDev() {
                     logDockerHint(config.server.host);
                 },
             },
-            // TODO/soon: re-enable automatically adding vike/SKILL.md (https://vike.dev/ai#skill).
-            // Temporarily disabled — https://github.com/vikejs/vike/pull/3465 got some backlash, let's find a better solution first.
-            /*
             configureServer: {
-              handler() {
-                // Apply late — after the dev server is up and running — so that it doesn't slow down dev start
-                setTimeoutUnref(() => autoAddVikeSkill(config.root), 15 * 1000)
-              },
+                handler(server) {
+                    logSkillHint(server, config.root);
+                },
             },
-            */
         },
         {
             name: 'vike:pluginDev:post',

package/dist/node/vite/shared/cache.d.ts

@@ -0,0 +1,5 @@
+export { getCacheValue };
+export { setCacheValue };
+import '../assertEnvVite.js';
+declare function getCacheValue(userRootDir: string, key: string): Promise<unknown>;
+declare function setCacheValue(userRootDir: string, key: string, value: unknown): Promise<void>;

package/dist/node/vite/shared/cache.js

@@ -0,0 +1,50 @@
+export { getCacheValue };
+export { setCacheValue };
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isObject } from '../../../utils/isObject.js';
+import { findFile } from '../../../utils/findFile.js';
+import { toPosixPath } from '../../../utils/path.js';
+import '../assertEnvVite.js';
+// Persistent key-value cache at node_modules/.vike/cache.json — e.g. to remember that a check was already done.
+// - Best-effort: a missing or invalid file reads as empty, and write errors (e.g. read-only file system) are swallowed.
+// - One top-level key per feature: entries are merged into the existing file.
+// - Values must be JSON-serializable.
+const cacheFileName = 'cache.json';
+async function getCacheValue(userRootDir, key) {
+    const cache = await readCache(userRootDir);
+    return cache[key];
+}
+async function setCacheValue(userRootDir, key, value) {
+    const filePath = getCacheFilePath(userRootDir);
+    try {
+        const cache = await readCache(userRootDir);
+        cache[key] = value;
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        await fs.writeFile(filePath, `${JSON.stringify(cache, null, 2)}\n`, 'utf8');
+    }
+    catch {
+        // E.g. read-only file system
+    }
+}
+async function readCache(userRootDir) {
+    const filePath = getCacheFilePath(userRootDir);
+    try {
+        const cache = JSON.parse(await fs.readFile(filePath, 'utf8'));
+        if (isObject(cache))
+            return cache;
+    }
+    catch {
+        // Missing or invalid cache file
+    }
+    return {};
+}
+// Same location logic as Vite's default `cacheDir` (node_modules/.vite/): the node_modules/ directory of the nearest package.json (searching upwards from the user's root directory), falling back to the user's root directory if there isn't any package.json.
+function getCacheFilePath(userRootDir) {
+    userRootDir = toPosixPath(userRootDir);
+    const packageJsonPath = findFile('package.json', userRootDir);
+    const cacheDir = packageJsonPath
+        ? path.posix.join(path.posix.dirname(packageJsonPath), 'node_modules', '.vike')
+        : path.posix.join(userRootDir, '.vike');
+    return path.posix.join(cacheDir, cacheFileName);
+}

package/dist/node/vite/shared/resolveVikeConfigInternal/crawlPlusFiles.js

@@ -20,7 +20,7 @@ async function crawlPlusFiles(userRootDir) {
         cwd: userRootDir,
         dot: false,
         // Fallback to tinyglobby for users that dynamically generate plus files (and `.gitignore`s them)
-        globFallback: true,
+        crawler: { git: true, glob: true },
     });
     // Filter build files
     files = files.filter((filePath) => !isTemporaryBuildFile(filePath));

package/dist/types/Config.d.ts

@@ -592,17 +592,13 @@ type ConfigBuiltIn = {
 };
 type ConfigAi = {
     /**
-     * Whether Vike automatically adds and updates `vike/SKILL.md` inside skills directories (e.g. `.agents/skills/` and `.claude/skills/`).
-     *
-     * - `true`: add `vike/SKILL.md` to every existing `skills/` directory
-     * - `false`: never add `vike/SKILL.md`
-     * - `string[]`: add `vike/SKILL.md` to exactly these directories
+     * Whether Vike checks that your app has Vike's skill for AI agents (`vike/SKILL.md`), logging a hint upon `$ vike dev` if it's missing or outdated.
      *
      * @default true
      *
      * https://vike.dev/ai#skill
      */
-    skill?: boolean | string[];
+    skill?: boolean;
 };
 type Vercel = {
     /**

package/dist/utils/PROJECT_VERSION.d.ts

@@ -1 +1 @@
-export declare const PROJECT_VERSION: '0.4.264';
+export declare const PROJECT_VERSION: '0.4.266';

package/dist/utils/PROJECT_VERSION.js

@@ -1,2 +1,2 @@
 // Automatically updated by @brillout/release-me
-export const PROJECT_VERSION = '0.4.264';
+export const PROJECT_VERSION = '0.4.266';

package/dist/utils/crawlFiles.d.ts

@@ -15,7 +15,15 @@ declare function crawlFiles(options: {
      */
     dot: boolean;
     /**
-     * Whether to fallback to tinyglobby if `$ git ls-files` doesn't find any file.
+     * Which crawlers to use.
+     * - `git` => `$ git ls-files` (fast, but skips gitignored files)
+     * - `glob` => tinyglobby (finds gitignored files)
+     *
+     * If both are enabled, tinyglobby is only used as a fallback when `$ git ls-files` doesn't find any file.
+     * If Git isn't usable (Git isn't installed, or `cwd` isn't inside a Git repository), tinyglobby is always used.
      */
-    globFallback: boolean;
+    crawler: {
+        git: boolean;
+        glob: boolean;
+    };
 }): Promise<string[]>;

package/dist/utils/crawlFiles.js

@@ -26,19 +26,20 @@ const globstar = '**/';
  * Crawl the files matching `filePattern`, using `$ git ls-files` and, as a fallback, [tinyglobby](https://github.com/SuperchupuDev/tinyglobby).
  */
 async function crawlFiles(options) {
-    const { filePattern, fileExtension, cwd, dot, globFallback } = options;
+    const { filePattern, fileExtension, cwd, dot, crawler } = options;
+    assert(crawler.git || crawler.glob);
     const userSettings = getUserSettings();
     const globOptions = { cwd, dot, nocase: false, ignore: getIgnorePatterns(userSettings) };
     // One pattern per file extension (the `filePattern` skips the file extension)
     assert(!path.posix.basename(filePattern).includes('.'));
     const patterns = fileExtension.map((ext) => `${filePattern}.${ext}`);
     // Crawl
-    const filesGit = userSettings.git !== false && (await crawlGit(patterns, cwd, globOptions));
+    const filesGit = crawler.git && userSettings.git !== false && (await crawlGit(patterns, cwd, globOptions));
     const useGlob = 
-    // `!filesGit` => Git isn't usable => we *have* to use tinyglobby
+    // `!filesGit` => Git isn't used or isn't usable => we *have* to use tinyglobby
     !filesGit ||
-        // `filesGit.length === 0` => fallback to tinyglobby if globFallback is true
-        (filesGit.length === 0 && globFallback);
+        // `filesGit.length === 0` => fallback to tinyglobby if enabled
+        (filesGit.length === 0 && crawler.glob);
     const filesGlob = (useGlob || debug.isActivated) && (await crawlGlob(patterns, globOptions));
     const files = useGlob ? filesGlob : filesGit;
     assert(files);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vike",
-  "version": "0.4.264",
+  "version": "0.4.266",
   "repository": "https://github.com/vikejs/vike",
   "exports": {
     "./server": {
@@ -137,8 +137,8 @@
     "es-module-lexer": "^1.0.0",
     "esbuild": ">=0.19.0",
     "json5": "^2.0.0",
-    "magic-string": "^1.2.2",
-    "picomatch": "^4.0.5",
+    "magic-string": "^1.2.3",
+    "picomatch": "^4.0.7",
     "semver": "^7.8.5",
     "sirv": "^3.0.2",
     "source-map-support": "^0.5.0",
@@ -240,6 +240,7 @@
     "./bin.js",
     "./AGENTS.md",
     "./dist/",
+    "./skills/",
     "./abort.js",
     "./api.js",
     "./client.js",

package/skills/vike/SKILL.md

@@ -0,0 +1,6 @@
+---
+name: "vike"
+description: "Vike documentation index — a compact overview of Vike's docs. Consider consulting it, e.g. when using uncommon Vike APIs or when stuck on a Vike problem."
+---
+
+See https://vike.dev/llms.txt

package/dist/node/vite/plugins/pluginDev/autoAddVikeSkill.d.ts

@@ -1,3 +0,0 @@
-export { autoAddVikeSkill };
-import '../../assertEnvVite.js';
-declare function autoAddVikeSkill(userRootDir: string): Promise<void>;

package/dist/node/vite/plugins/pluginDev/autoAddVikeSkill.js

@@ -1,178 +0,0 @@
-export { autoAddVikeSkill };
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import pc from '@brillout/picocolors';
-import { assertInfo, assertUsage } from '../../../../utils/assert.js';
-import { assertKeys } from '../../../../utils/assertKeys.js';
-import { crawlFiles } from '../../../../utils/crawlFiles.js';
-import { getGlobalObject } from '../../../../utils/getGlobalObject.js';
-import { getVikeConfigError } from '../../../../shared-server-node/getVikeConfigError.js';
-import { isArrayOfStrings } from '../../../../utils/isArrayOfStrings.js';
-import { isFilePathAbsoluteFilesystem } from '../../../../utils/isFilePathAbsoluteFilesystem.js';
-import { isObject } from '../../../../utils/isObject.js';
-import { unique } from '../../../../utils/unique.js';
-import { getVikeConfigInternal } from '../../shared/resolveVikeConfigInternal.js';
-import '../../assertEnvVite.js';
-const execFileA = promisify(execFile);
-const importMetaUrl = import.meta.url;
-const globalObject = getGlobalObject('autoAddVikeSkill.ts', {
-    alreadyDone: false,
-});
-const skillPathInsideSkillsDir = 'vike/SKILL.md';
-const skillFileContent = `---
-name: "vike"
-description: "Vike documentation index — a compact overview of Vike's docs. Consider consulting it, e.g. when using uncommon Vike APIs or when stuck on a Vike problem."
----
-
-See https://vike.dev/llms.txt
-`;
-const commitMessage = (isUpdate) => `${isUpdate ? 'Update' : 'Add'} Vike skill — ${pc.underline('https://vike.dev/ai#skill')}`;
-// Automatically add vike/SKILL.md to skills/ directories (e.g. .claude/skills/ and .agents/skills/) of the user's Git repository (and Git-commit it) — so that AI agents (Claude Code, Codex, Cursor, Gemini CLI, ...) automatically pick it up.
-// https://vike.dev/ai#skill
-async function autoAddVikeSkill(userRootDir) {
-    try {
-        await autoAddVikeSkillUnsafe(userRootDir);
-    }
-    catch (err) {
-        // Show the error without breaking the dev server. (Expected situations don't throw — e.g. Git missing is handled gracefully.)
-        console.error(err);
-    }
-}
-async function autoAddVikeSkillUnsafe(userRootDir) {
-    if (globalObject.alreadyDone)
-        return;
-    // Skip CI environments: the skill file is meant to be added from the machine of an app developer.
-    if (process.env.CI)
-        return;
-    // Skip if Vike isn't inside node_modules/ (e.g. when Vike is linked, such as when running an example of the Vike monorepo).
-    if (!importMetaUrl.includes('node_modules/'))
-        return;
-    const vikeConfig = await getVikeConfigInternal();
-    // Maybe the user disabled the feature in a config file that currently has an error => retry later (Vite restarts upon config changes).
-    if (getVikeConfigError())
-        return;
-    const configValue = getConfigValueAiSkill(vikeConfig);
-    if (configValue === false)
-        return;
-    globalObject.alreadyDone = true;
-    const res = await addAiSkill(userRootDir, {
-        // true (default) => add the skill file to every existing skills directory (`**/skills/*/SKILL.md`)
-        skillsDirs: configValue === true ? undefined : configValue,
-    });
-    if (!res)
-        return;
-    assertInfo(false, `${res.isUpdate ? 'Updated' : 'Created'}${res.isCommitted ? ' and Git-committed' : ''} ${res.files
-        .map((f) => pc.cyan(f.filePathRelative))
-        .join(', ')} — ${pc.underline('https://vike.dev/ai#skill')}`, { onlyOnce: false });
-}
-// https://vike.dev/ai#skill
-function getConfigValueAiSkill(vikeConfig) {
-    const configAi = vikeConfig.config.ai;
-    if (configAi === undefined)
-        return true;
-    assertUsage(isObject(configAi), `Setting ${pc.cyan('ai')} should be an object`);
-    assertKeys(configAi, ['skill'], `Setting ${pc.cyan('ai')}:`);
-    const skill = configAi.skill;
-    if (skill === undefined || skill === true)
-        return true;
-    if (skill === false)
-        return false;
-    assertUsage(isArrayOfStrings(skill), `Setting ${pc.cyan('ai.skill')} should be a boolean or a list of skills directories (e.g. ${pc.cyan("['.claude/skills', '.agents/skills']")})`);
-    return skill.map((skillsDir) => {
-        assertUsage(skillsDir !== '' && !isFilePathAbsoluteFilesystem(skillsDir), `Setting ${pc.cyan('ai.skill')} entries should be paths relative to the root directory of your app's Git repository (e.g. ${pc.cyan("'.claude/skills'")})`);
-        // Normalize: remove trailing slashes
-        return skillsDir.replace(/\/+$/, '');
-    });
-}
-async function addAiSkill(userRootDir, { skillsDirs }) {
-    // Skip if Git isn't installed
-    if ('err' in (await runGitCommand(['--version'], userRootDir)))
-        return null;
-    // Skip if the app isn't inside a Git repository
-    const resGitRootDir = await runGitCommand(['rev-parse', '--show-toplevel'], userRootDir);
-    if ('err' in resGitRootDir)
-        return null;
-    const gitRootDir = resGitRootDir.stdout.trim();
-    if (!gitRootDir)
-        return null;
-    // By default, the skill file is only added to the skills directories that already exist — we don't want to add files to the repositories of users who don't use skills.
-    skillsDirs ?? (skillsDirs = await discoverSkillsDirs(gitRootDir));
-    if (skillsDirs.length === 0)
-        return null;
-    const files = [];
-    for (const skillsDir of skillsDirs) {
-        const filePathRelative = `${skillsDir}/${skillPathInsideSkillsDir}`;
-        const filePathAbsolute = path.join(gitRootDir, ...filePathRelative.split('/'));
-        // Skip if the skill file is already up-to-date
-        const contentCurrent = await fs.readFile(filePathAbsolute, 'utf8').catch(() => null);
-        if (contentCurrent === skillFileContent)
-            continue;
-        const isUpdate = contentCurrent !== null;
-        await fs.mkdir(path.dirname(filePathAbsolute), { recursive: true });
-        await fs.writeFile(filePathAbsolute, skillFileContent, 'utf8');
-        files.push({ filePathAbsolute, filePathRelative, isUpdate });
-    }
-    if (files.length === 0)
-        return null;
-    const isCommitted = await gitCommit(gitRootDir, files);
-    return { files, isUpdate: files.some((f) => f.isUpdate), isCommitted };
-}
-// Discover the skills directories of the user's Git repository, following the Agent Skills convention `**/skills/*/SKILL.md` (https://agentskills.io) — e.g. .claude/skills/ (Claude Code) and .agents/skills/ (Codex, Gemini CLI, Cursor, ...).
-async function discoverSkillsDirs(gitRootDir) {
-    const files = await crawlFiles({
-        filePattern: '**/skills/*/SKILL',
-        fileExtension: ['md'],
-        cwd: gitRootDir,
-        // Skills directories usually live inside dot directories (e.g. .claude/ and .agents/)
-        dot: true,
-        // Most apps don't contain any skills directory — when Git doesn't know about any skill file, we don't want to crawl the app's entire directory tree upon every dev start.
-        globFallback: false,
-    });
-    const skillsDirs = unique(files.map((filePath) => path.posix.dirname(path.posix.dirname(filePath)))).sort();
-    return skillsDirs;
-}
-async function gitCommit(gitRootDir, files) {
-    // Don't Git-commit the skill files that the user chose to .gitignore — `$ git check-ignore` succeeds if the file is ignored
-    const filesToCommit = [];
-    for (const file of files) {
-        const resCheckIgnore = await runGitCommand(['check-ignore', '--quiet', '--', file.filePathRelative], gitRootDir);
-        if ('err' in resCheckIgnore)
-            filesToCommit.push(file);
-    }
-    if (filesToCommit.length === 0)
-        return false;
-    const filePaths = filesToCommit.map((f) => f.filePathRelative);
-    const resAdd = await runGitCommand(['add', '--', ...filePaths], gitRootDir);
-    if ('err' in resAdd)
-        return false;
-    const isUpdate = filesToCommit.some((f) => f.isUpdate);
-    const resCommit = await runGitCommand([
-        '-c',
-        'user.name=Vike',
-        '-c',
-        'user.email=no-reply@vike.dev',
-        'commit',
-        // Skip Git hooks (e.g. slow or failing pre-commit hooks)
-        '--no-verify',
-        '--message',
-        commitMessage(isUpdate),
-        // Only commit the skill files — never commit files staged by the user
-        '--',
-        ...filePaths,
-    ], gitRootDir);
-    return !('err' in resCommit);
-}
-// Run a Git command — doesn't throw: it returns `{ err }` upon failure.
-async function runGitCommand(args, cwd) {
-    let stdout;
-    try {
-        const res = await execFileA('git', args, { cwd });
-        stdout = res.stdout.toString();
-    }
-    catch (err) {
-        return { err };
-    }
-    return { stdout };
-}