vitek-plugin 0.1.2-beta.6 → 0.2.1-beta

package/dist/adapters/vite/path-utils.js

@@ -0,0 +1,46 @@
+/**
+ * Path normalization utilities for Vite plugin hooks.
+ * Centralizes logic for importer/module id resolution (file:, /, absolute).
+ */
+import * as path from 'path';
+import * as fs from 'fs';
+import { fileURLToPath } from 'url';
+const EXTENSIONS = ['.ts', '.tsx', '.mts', '.js', '.jsx', '.mjs'];
+/**
+ * Converts an importer string (from resolveId) to an absolute filesystem path.
+ * Handles file: URLs, leading-slash paths (virtual), and absolute paths.
+ */
+export function normalizeImporterPath(importer, root) {
+    if (importer.startsWith('file:')) {
+        return fileURLToPath(importer);
+    }
+    if (importer.startsWith('/')) {
+        const virtualPath = path.join(root, importer.replace(/^\//, ''));
+        return fs.existsSync(virtualPath) ? virtualPath : path.resolve(importer);
+    }
+    return path.resolve(importer);
+}
+/**
+ * Converts a module id (from transform/resolveId) to an absolute filesystem path.
+ * Handles file: URLs and leading-slash paths (virtual).
+ */
+export function normalizeModuleIdPath(id, root) {
+    const idPath = id.startsWith('file:') ? fileURLToPath(id) : id;
+    if (idPath.startsWith('/')) {
+        const virtualPath = path.join(root, idPath.replace(/^\//, ''));
+        return fs.existsSync(virtualPath) ? virtualPath : path.resolve(idPath);
+    }
+    return path.resolve(idPath);
+}
+/**
+ * Resolves a path to an existing file, trying extensions if the path has none.
+ * Returns the resolved absolute path or null if not found.
+ */
+export function resolveWithExtension(filePath) {
+    if (fs.existsSync(filePath))
+        return filePath;
+    const ext = EXTENSIONS.find((e) => fs.existsSync(filePath + e));
+    if (ext)
+        return filePath + ext;
+    return null;
+}

package/dist/adapters/vite/path-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=path-utils.test.d.ts.map

package/dist/adapters/vite/path-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-utils.test.d.ts","sourceRoot":"","sources":["../../../src/adapters/vite/path-utils.test.ts"],"names":[],"mappings":""}

package/dist/adapters/vite/path-utils.test.js

@@ -0,0 +1,79 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { pathToFileURL } from 'url';
+import { normalizeImporterPath, normalizeModuleIdPath, resolveWithExtension, } from './path-utils.js';
+describe('path-utils', () => {
+    let rootDir;
+    beforeEach(() => {
+        rootDir = fs.mkdtempSync(path.join(process.cwd(), 'path-utils-test-'));
+        fs.mkdirSync(path.join(rootDir, 'src', 'api'), { recursive: true });
+        fs.mkdirSync(path.join(rootDir, 'src', 'lib'), { recursive: true });
+        fs.writeFileSync(path.join(rootDir, 'src', 'api', 'health.ts'), '', 'utf-8');
+        fs.writeFileSync(path.join(rootDir, 'src', 'lib', 'utils.ts'), '', 'utf-8');
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(rootDir, { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    describe('normalizeImporterPath', () => {
+        it('converts file: URL to absolute path', () => {
+            const filePath = path.join(rootDir, 'src', 'api', 'health.ts');
+            const fileUrl = pathToFileURL(filePath).href;
+            expect(normalizeImporterPath(fileUrl, rootDir)).toBe(filePath);
+        });
+        it('converts leading-slash path (virtual) when file exists', () => {
+            const virtualPath = '/src/api/health.ts';
+            const result = normalizeImporterPath(virtualPath, rootDir);
+            expect(result).toBe(path.join(rootDir, 'src', 'api', 'health.ts'));
+        });
+        it('converts leading-slash path when file does not exist', () => {
+            const virtualPath = '/nonexistent/file.ts';
+            const result = normalizeImporterPath(virtualPath, rootDir);
+            expect(result).toBe(path.resolve(virtualPath));
+        });
+        it('resolves absolute path', () => {
+            const absPath = path.join(rootDir, 'src', 'api', 'health.ts');
+            expect(normalizeImporterPath(absPath, rootDir)).toBe(path.resolve(absPath));
+        });
+    });
+    describe('normalizeModuleIdPath', () => {
+        it('converts file: URL to absolute path', () => {
+            const filePath = path.join(rootDir, 'src', 'lib', 'utils.ts');
+            const fileUrl = pathToFileURL(filePath).href;
+            expect(normalizeModuleIdPath(fileUrl, rootDir)).toBe(filePath);
+        });
+        it('converts leading-slash path (virtual) when file exists', () => {
+            const virtualPath = '/src/lib/utils.ts';
+            const result = normalizeModuleIdPath(virtualPath, rootDir);
+            expect(result).toBe(path.join(rootDir, 'src', 'lib', 'utils.ts'));
+        });
+        it('resolves path without leading slash', () => {
+            const relPath = path.join(rootDir, 'src', 'api', 'health.ts');
+            expect(normalizeModuleIdPath(relPath, rootDir)).toBe(path.resolve(relPath));
+        });
+    });
+    describe('resolveWithExtension', () => {
+        it('returns path when file exists without extension', () => {
+            const existingPath = path.join(rootDir, 'src', 'api', 'health.ts');
+            expect(resolveWithExtension(existingPath)).toBe(existingPath);
+        });
+        it('adds .ts when file exists with extension', () => {
+            const basePath = path.join(rootDir, 'src', 'api', 'health');
+            expect(resolveWithExtension(basePath)).toBe(basePath + '.ts');
+        });
+        it('adds .tsx when .ts does not exist but .tsx does', () => {
+            fs.writeFileSync(path.join(rootDir, 'src', 'component.tsx'), '', 'utf-8');
+            const basePath = path.join(rootDir, 'src', 'component');
+            expect(resolveWithExtension(basePath)).toBe(basePath + '.tsx');
+        });
+        it('returns null when file does not exist', () => {
+            const basePath = path.join(rootDir, 'src', 'nonexistent');
+            expect(resolveWithExtension(basePath)).toBeNull();
+        });
+    });
+});

package/dist/build/build-api-bundle.d.ts

@@ -6,6 +6,7 @@ export interface BuildApiBundleOptions {
     root: string;
     apiDir: string;
     outDir: string;
+    alias?: Record<string, string>;
 }
 /**
  * Builds the API bundle and writes it to outDir/vitek-api.mjs

package/dist/build/build-api-bundle.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build-api-bundle.d.ts","sourceRoot":"","sources":["../../src/build/build-api-bundle.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB;AAgDD;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAgD3F;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}
+{"version":3,"file":"build-api-bundle.d.ts","sourceRoot":"","sources":["../../src/build/build-api-bundle.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAWH,MAAM,WAAW,qBAAqB;IACpC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CAChC;AAgFD;;;GAGG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAmD3F;AAED,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C"}

package/dist/build/build-api-bundle.js

@@ -22,7 +22,8 @@ function generateEntryContent(scanResult, entryDir) {
     scanResult.middlewares.forEach((mw, i) => {
         const rel = path.relative(entryDir, mw.path).replace(/\\/g, '/');
         const importPath = rel.startsWith('.') ? rel : `./${rel}`;
-        lines.push(`import mw_${i} from ${JSON.stringify(importPath)};`);
+        // Use namespace import so we can read both default and named export 'config' (for global pathPatterns)
+        lines.push(`import * as mw_${i}_ns from ${JSON.stringify(importPath)};`);
     });
     const routeEntries = scanResult.routes.map((parsed, i) => {
         const regex = patternToRegex(parsed.pattern);
@@ -34,7 +35,11 @@ function generateEntryContent(scanResult, entryDir) {
     lines.push(routeEntries.join(',\n'));
     lines.push('];');
     const mwEntries = scanResult.middlewares.map((mw, i) => {
-        return `  { basePattern: ${JSON.stringify(mw.basePattern)}, middleware: (() => { const m = mw_${i}; const fn = typeof m === 'function' || Array.isArray(m) ? m : (m.default ?? m.middleware); return Array.isArray(fn) ? fn : [fn]; })() }`;
+        const base = `  { basePattern: ${JSON.stringify(mw.basePattern)}, middleware: (() => { const m = mw_${i}_ns.default ?? mw_${i}_ns; const fn = typeof m === 'function' || Array.isArray(m) ? m : (m?.default ?? m?.middleware); return Array.isArray(fn) ? fn : [fn]; })()`;
+        if (mw.basePattern === '') {
+            return `${base}, pathPatterns: (() => { const c = mw_${i}_ns?.config; if (!c?.path) return undefined; const p = Array.isArray(c.path) ? c.path : [c.path]; return p.map((x) => String(x).replace(/^\\/api\\/?/, '').replace(/^\\/+|\\/+$/g, '')); })() }`;
+        }
+        return `${base} }`;
     });
     lines.push('');
     lines.push('const middlewares = [');
@@ -44,12 +49,39 @@ function generateEntryContent(scanResult, entryDir) {
     lines.push('export { routes, middlewares };');
     return lines.join('\n');
 }
+function createAliasPlugin(root, alias) {
+    const entries = Object.entries(alias)
+        .filter(([, v]) => v != null && v !== '')
+        .sort(([a], [b]) => b.length - a.length);
+    return {
+        name: 'vitek-alias',
+        setup(build) {
+            if (entries.length === 0)
+                return;
+            const b = build;
+            const filter = new RegExp('^(' + entries.map(([k]) => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')).join('|') + ')(/|$)');
+            b.onResolve({ filter }, (args) => {
+                const imp = args.path;
+                for (const [key, value] of entries) {
+                    if (imp === key || imp.startsWith(key + '/')) {
+                        const rest = imp.slice(key.length).replace(/^\//, '') || '';
+                        const base = path.resolve(root, value, rest);
+                        const withExt = ['.js', '.ts', '.mjs', '.cjs'].find((ext) => fs.existsSync(base + ext));
+                        const resolved = withExt ? base + withExt : base;
+                        return { path: resolved };
+                    }
+                }
+                return null;
+            });
+        },
+    };
+}
 /**
  * Builds the API bundle and writes it to outDir/vitek-api.mjs
  * Returns the path to the written file, or null if skipped (no apiDir, no routes, or error)
  */
 export async function buildApiBundle(options) {
-    const { root, apiDir, outDir } = options;
+    const { root, apiDir, outDir, alias } = options;
     if (!fs.existsSync(apiDir)) {
         return null;
     }
@@ -69,6 +101,7 @@ export async function buildApiBundle(options) {
     if (!esbuild) {
         return null;
     }
+    const plugins = alias && Object.keys(alias).length > 0 ? [createAliasPlugin(root, alias)] : [];
     try {
         await esbuild.build({
             entryPoints: [tmpEntry],
@@ -77,6 +110,8 @@ export async function buildApiBundle(options) {
             platform: 'node',
             outfile: outFile,
             external: ['vitek-plugin'],
+            minify: true,
+            plugins,
         });
         return outFile;
     }

package/dist/build/build-api-bundle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-api-bundle.test.d.ts.map

package/dist/build/build-api-bundle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-api-bundle.test.d.ts","sourceRoot":"","sources":["../../src/build/build-api-bundle.test.ts"],"names":[],"mappings":""}

package/dist/build/build-api-bundle.test.js

@@ -0,0 +1,50 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { buildApiBundle, getApiBundleFilename } from './build-api-bundle.js';
+describe('build-api-bundle', () => {
+    let rootDir;
+    let apiDir;
+    let outDir;
+    beforeEach(() => {
+        rootDir = fs.mkdtempSync(path.join(process.cwd(), 'build-api-test-'));
+        apiDir = path.join(rootDir, 'src', 'api');
+        outDir = path.join(rootDir, 'dist');
+        fs.mkdirSync(apiDir, { recursive: true });
+        fs.mkdirSync(outDir, { recursive: true });
+        fs.writeFileSync(path.join(apiDir, 'health.get.ts'), 'export default function handler() { return { ok: true }; }\n', 'utf-8');
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(rootDir, { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    it('getApiBundleFilename returns vitek-api.mjs', () => {
+        expect(getApiBundleFilename()).toBe('vitek-api.mjs');
+    });
+    it('returns null when apiDir does not exist', async () => {
+        const result = await buildApiBundle({
+            root: rootDir,
+            apiDir: path.join(rootDir, 'nonexistent'),
+            outDir,
+        });
+        expect(result).toBeNull();
+    });
+    it('returns null when apiDir has no routes', async () => {
+        fs.unlinkSync(path.join(apiDir, 'health.get.ts'));
+        const result = await buildApiBundle({ root: rootDir, apiDir, outDir });
+        expect(result).toBeNull();
+    });
+    it('builds vitek-api.mjs when apiDir has routes', async () => {
+        const result = await buildApiBundle({ root: rootDir, apiDir, outDir });
+        expect(result).toBe(path.join(outDir, 'vitek-api.mjs'));
+        expect(fs.existsSync(result)).toBe(true);
+        const content = fs.readFileSync(result, 'utf-8');
+        expect(content).toContain('routes');
+        expect(content).toContain('middlewares');
+        expect(content).toContain('export');
+    });
+});

package/dist/build/build-sockets-bundle.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=build-sockets-bundle.test.d.ts.map

package/dist/build/build-sockets-bundle.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-sockets-bundle.test.d.ts","sourceRoot":"","sources":["../../src/build/build-sockets-bundle.test.ts"],"names":[],"mappings":""}

package/dist/build/build-sockets-bundle.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { buildSocketsBundle, getSocketsBundleFilename } from './build-sockets-bundle.js';
+describe('build-sockets-bundle', () => {
+    let rootDir;
+    let apiDir;
+    let outDir;
+    beforeEach(() => {
+        rootDir = fs.mkdtempSync(path.join(process.cwd(), 'build-sockets-test-'));
+        apiDir = path.join(rootDir, 'src', 'api');
+        outDir = path.join(rootDir, 'dist');
+        fs.mkdirSync(apiDir, { recursive: true });
+        fs.mkdirSync(outDir, { recursive: true });
+        fs.writeFileSync(path.join(apiDir, 'chat.socket.ts'), 'export default function handler() {}\n', 'utf-8');
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(rootDir, { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    it('getSocketsBundleFilename returns vitek-sockets.mjs', () => {
+        expect(getSocketsBundleFilename()).toBe('vitek-sockets.mjs');
+    });
+    it('returns null when apiDir does not exist', async () => {
+        const result = await buildSocketsBundle({
+            root: rootDir,
+            apiDir: path.join(rootDir, 'nonexistent'),
+            outDir,
+        });
+        expect(result).toBeNull();
+    });
+    it('returns null when apiDir has no socket files', async () => {
+        fs.unlinkSync(path.join(apiDir, 'chat.socket.ts'));
+        const result = await buildSocketsBundle({ root: rootDir, apiDir, outDir });
+        expect(result).toBeNull();
+    });
+    it('builds vitek-sockets.mjs when apiDir has socket files', async () => {
+        const result = await buildSocketsBundle({ root: rootDir, apiDir, outDir });
+        expect(result).toBe(path.join(outDir, 'vitek-sockets.mjs'));
+        expect(fs.existsSync(result)).toBe(true);
+        const content = fs.readFileSync(result, 'utf-8');
+        expect(content).toContain('sockets');
+        expect(content).toContain('export');
+    });
+});

package/dist/cli/cli.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Main CLI entry: vitek [command]
+ * Commands: init, mcp, serve (default)
+ * Usage: vitek init [--force] | vitek mcp | vitek [serve] [options]
+ */
+declare const cmd: string;
+declare function run(): Promise<void>;
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli/cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.d.ts","sourceRoot":"","sources":["../../src/cli/cli.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,QAAA,MAAU,GAAG,QAAgB,CAAC;AAE9B,iBAAe,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,CAalC"}

package/dist/cli/cli.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Main CLI entry: vitek [command]
+ * Commands: init, mcp, serve (default)
+ * Usage: vitek init [--force] | vitek mcp | vitek [serve] [options]
+ */
+const [, , cmd] = process.argv;
+async function run() {
+    if (cmd === 'init') {
+        const { runInit } = await import('./init.js');
+        await runInit();
+        return;
+    }
+    if (cmd === 'mcp') {
+        const { runMcpProject } = await import('./mcp-project.js');
+        await runMcpProject();
+        return;
+    }
+    const { main } = await import('./serve.js');
+    await main();
+}
+run().catch((err) => {
+    console.error('[vitek]', err);
+    process.exit(1);
+});

package/dist/cli/fixtures/serve-config/vitek.config.d.mts

@@ -0,0 +1,6 @@
+/** Fixture for serve.test.ts: config that exports beforeApiRequest, onError, onServerStart, onServerShutdown */
+export function beforeApiRequest(_ctx: any, next: any): void;
+export function onError(_err: any, _req: any, res: any): void;
+export function onServerStart(ctx: any): void;
+export function onServerShutdown(): void;
+//# sourceMappingURL=vitek.config.d.mts.map

package/dist/cli/fixtures/serve-config/vitek.config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitek.config.d.mts","sourceRoot":"","sources":["../../../../src/cli/fixtures/serve-config/vitek.config.mjs"],"names":[],"mappings":"AAAA,gHAAgH;AAChH,6DAEC;AAED,8DAGC;AAED,8CAKC;AAED,yCAIC"}

package/dist/cli/fixtures/serve-config/vitek.config.mjs

@@ -0,0 +1,19 @@
+/** Fixture for serve.test.ts: config that exports beforeApiRequest, onError, onServerStart, onServerShutdown */
+export function beforeApiRequest(_ctx, next) {
+    next();
+}
+export function onError(_err, _req, res) {
+    res.statusCode = 503;
+    res.end('Unavailable');
+}
+export function onServerStart(ctx) {
+    if (typeof globalThis !== 'undefined') {
+        globalThis.__vitekOnServerStartCtx = ctx;
+        globalThis.__vitekOnServerStartCalled = true;
+    }
+}
+export function onServerShutdown() {
+    if (typeof globalThis !== 'undefined') {
+        globalThis.__vitekOnServerShutdownCalled = true;
+    }
+}

package/dist/cli/init.d.ts

@@ -0,0 +1,15 @@
+/**
+ * vitek init: scaffold src/api and add vitek to vite.config
+ * Usage: vitek init [--force]
+ * Idempotent: does not overwrite existing files unless --force.
+ */
+export declare function parseInitArgs(): {
+    force: boolean;
+};
+/**
+ * Injects vitek import and plugin into config content if not already present.
+ * Returns new content or null if no change needed.
+ */
+export declare function injectVitekIntoConfig(content: string): string | null;
+export declare function runInit(): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

package/dist/cli/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/cli/init.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAkBH,wBAAgB,aAAa,IAAI;IAAE,KAAK,EAAE,OAAO,CAAA;CAAE,CAOlD;AAsBD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAmBpE;AAED,wBAAsB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC,CA+B7C"}

package/dist/cli/init.js

@@ -0,0 +1,99 @@
+/**
+ * vitek init: scaffold src/api and add vitek to vite.config
+ * Usage: vitek init [--force]
+ * Idempotent: does not overwrite existing files unless --force.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+const DEFAULT_API_DIR = 'src/api';
+const HEALTH_ROUTE_JS = `/**
+ * Health check endpoint
+ * GET /api/health
+ */
+
+export default function handler() {
+  return { ok: true, timestamp: new Date().toISOString() };
+}
+`;
+const VITE_CONFIG_NAMES = ['vite.config.js', 'vite.config.ts', 'vite.config.mjs', 'vite.config.cjs'];
+export function parseInitArgs() {
+    const argv = process.argv.slice(2);
+    let force = false;
+    for (const arg of argv) {
+        if (arg === '--force' || arg === '-f')
+            force = true;
+    }
+    return { force };
+}
+/**
+ * Ensures directory exists. Creates it and parents if needed.
+ */
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+/**
+ * Finds the first existing vite config file in cwd.
+ */
+function findViteConfig(cwd) {
+    for (const name of VITE_CONFIG_NAMES) {
+        const p = path.join(cwd, name);
+        if (fs.existsSync(p) && fs.statSync(p).isFile())
+            return p;
+    }
+    return null;
+}
+/**
+ * Injects vitek import and plugin into config content if not already present.
+ * Returns new content or null if no change needed.
+ */
+export function injectVitekIntoConfig(content) {
+    const hasVitek = /vitek-plugin|vitek\s*\(/.test(content);
+    if (hasVitek)
+        return null;
+    let out = content;
+    // Add import after first line (so it's at the top with other imports)
+    if (!out.includes('vitek-plugin')) {
+        const firstNewline = out.indexOf('\n');
+        const insertIdx = firstNewline === -1 ? out.length : firstNewline + 1;
+        out = out.slice(0, insertIdx) + "import { vitek } from 'vitek-plugin';\n" + out.slice(insertIdx);
+    }
+    // Add vitek() to plugins array: find plugins: [ and insert vitek(), as first element
+    const pluginsMatch = out.match(/plugins:\s*\[/);
+    if (!pluginsMatch)
+        return null;
+    const insertPluginsIdx = pluginsMatch.index + pluginsMatch[0].length;
+    out = out.slice(0, insertPluginsIdx) + 'vitek(), ' + out.slice(insertPluginsIdx);
+    return out;
+}
+export async function runInit() {
+    const { force } = parseInitArgs();
+    const cwd = process.cwd();
+    const apiDir = path.join(cwd, DEFAULT_API_DIR);
+    const healthPath = path.join(apiDir, 'health.get.ts');
+    ensureDir(apiDir);
+    if (!fs.existsSync(healthPath) || force) {
+        fs.writeFileSync(healthPath, HEALTH_ROUTE_JS, 'utf-8');
+        console.log(`[vitek init] Created ${DEFAULT_API_DIR}/health.get.ts`);
+    }
+    else {
+        console.log(`[vitek init] ${DEFAULT_API_DIR}/health.get.ts already exists (use --force to overwrite)`);
+    }
+    const configPath = findViteConfig(cwd);
+    if (configPath) {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const newContent = injectVitekIntoConfig(content);
+        if (newContent) {
+            fs.writeFileSync(configPath, newContent, 'utf-8');
+            console.log(`[vitek init] Added vitek to ${path.basename(configPath)}`);
+        }
+        else {
+            console.log(`[vitek init] ${path.basename(configPath)} already has vitek`);
+        }
+    }
+    else {
+        console.log('[vitek init] No vite.config.js/ts/mjs/cjs found; add vitek() to your Vite config manually. See https://martinsbicudo.github.io/vitek-plugin/guide/getting-started');
+    }
+    console.log('[vitek init] Tip: expose your API to AI assistants with `vitek mcp` — https://martinsbicudo.github.io/vitek-plugin/guide/mcp-project');
+}

package/dist/cli/init.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=init.test.d.ts.map

package/dist/cli/init.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.test.d.ts","sourceRoot":"","sources":["../../src/cli/init.test.ts"],"names":[],"mappings":""}

package/dist/cli/init.test.js

@@ -0,0 +1,117 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { runInit, parseInitArgs, injectVitekIntoConfig } from './init.js';
+describe('parseInitArgs', () => {
+    it('returns force false when no args', () => {
+        process.argv = ['node', 'vitek', 'init'];
+        expect(parseInitArgs().force).toBe(false);
+    });
+    it('returns force true when --force', () => {
+        process.argv = ['node', 'vitek', 'init', '--force'];
+        expect(parseInitArgs().force).toBe(true);
+    });
+    it('returns force true when -f', () => {
+        process.argv = ['node', 'vitek', 'init', '-f'];
+        expect(parseInitArgs().force).toBe(true);
+    });
+});
+describe('injectVitekIntoConfig', () => {
+    it('returns null when vitek is already present', () => {
+        const content = "import { vitek } from 'vitek-plugin';\nexport default defineConfig({ plugins: [vitek()] });";
+        expect(injectVitekIntoConfig(content)).toBeNull();
+    });
+    it('adds import and vitek() to plugins when missing', () => {
+        const content = `import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [],
+});
+`;
+        const result = injectVitekIntoConfig(content);
+        expect(result).not.toBeNull();
+        expect(result).toContain("import { vitek } from 'vitek-plugin'");
+        expect(result).toContain('vitek(), ');
+        expect(result).toMatch(/plugins:\s*\[\s*vitek\(\)/);
+    });
+    it('returns null when plugins array is missing', () => {
+        const content = 'export default { root: "." }';
+        expect(injectVitekIntoConfig(content)).toBeNull();
+    });
+});
+describe('runInit', () => {
+    let tmpDir;
+    const originalCwd = process.cwd();
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vitek-init-test-'));
+    });
+    afterEach(() => {
+        process.chdir(originalCwd);
+        try {
+            fs.rmSync(tmpDir, { recursive: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    it('creates src/api and health.get.ts', async () => {
+        process.chdir(tmpDir);
+        await runInit();
+        const healthPath = path.join(tmpDir, 'src', 'api', 'health.get.ts');
+        expect(fs.existsSync(healthPath)).toBe(true);
+        const content = fs.readFileSync(healthPath, 'utf-8');
+        expect(content).toContain('export default function handler()');
+        expect(content).toContain('ok: true');
+    });
+    it('does not overwrite health.get.ts on second run without --force', async () => {
+        process.chdir(tmpDir);
+        process.argv = ['node', 'vitek', 'init'];
+        await runInit();
+        const healthPath = path.join(tmpDir, 'src', 'api', 'health.get.ts');
+        fs.writeFileSync(healthPath, '// custom content', 'utf-8');
+        process.argv = ['node', 'vitek', 'init'];
+        await runInit();
+        expect(fs.readFileSync(healthPath, 'utf-8')).toBe('// custom content');
+    });
+    it('overwrites health.get.ts when --force', async () => {
+        process.chdir(tmpDir);
+        await runInit();
+        const healthPath = path.join(tmpDir, 'src', 'api', 'health.get.ts');
+        fs.writeFileSync(healthPath, '// custom', 'utf-8');
+        process.argv = ['node', 'vitek', 'init', '--force'];
+        await runInit();
+        expect(fs.readFileSync(healthPath, 'utf-8')).toContain('export default function handler()');
+    });
+    it('adds vitek to existing vite.config.js', async () => {
+        process.chdir(tmpDir);
+        fs.mkdirSync(path.join(tmpDir, 'src', 'api'), { recursive: true });
+        const configPath = path.join(tmpDir, 'vite.config.js');
+        fs.writeFileSync(configPath, `import { defineConfig } from 'vite';
+
+export default defineConfig({
+  plugins: [],
+});
+`, 'utf-8');
+        await runInit();
+        const content = fs.readFileSync(configPath, 'utf-8');
+        expect(content).toContain("import { vitek } from 'vitek-plugin'");
+        expect(content).toContain('vitek(), ');
+    });
+    it('does not duplicate vitek in config on second run', async () => {
+        process.chdir(tmpDir);
+        fs.mkdirSync(path.join(tmpDir, 'src', 'api'), { recursive: true });
+        const configPath = path.join(tmpDir, 'vite.config.js');
+        fs.writeFileSync(configPath, `import { defineConfig } from 'vite';
+import { vitek } from 'vitek-plugin';
+
+export default defineConfig({
+  plugins: [vitek()],
+});
+`, 'utf-8');
+        await runInit();
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const vitekCount = (content.match(/vitek/g) || []).length;
+        expect(vitekCount).toBeLessThanOrEqual(3); // import + two in plugins
+    });
+});