vite-plus 0.1.0-alpha.0 → 0.1.0

package/dist/bin.d.ts

@@ -1,7 +1,7 @@
 /**
  * Unified entry point for both the local CLI (via bin/vp) and the global CLI (via Rust vp binary).
  *
- * Global commands (create, migrate, init, mcp, --version) are handled by rolldown-bundled modules.
+ * Global commands (create, migrate, config, mcp, staged, --version) are handled by rolldown-bundled modules.
  * All other commands are delegated to the Rust core through NAPI bindings, which
  * uses JavaScript tool resolver functions to locate tool binaries.
  *

package/dist/bin.js

@@ -1,7 +1,7 @@
 /**
  * Unified entry point for both the local CLI (via bin/vp) and the global CLI (via Rust vp binary).
  *
- * Global commands (create, migrate, init, mcp, --version) are handled by rolldown-bundled modules.
+ * Global commands (create, migrate, config, mcp, staged, --version) are handled by rolldown-bundled modules.
  * All other commands are delegated to the Rust core through NAPI bindings, which
  * uses JavaScript tool resolver functions to locate tool binaries.
  *
@@ -35,9 +35,9 @@ else if (command === 'migrate') {
     // @ts-ignore — rolldown output
     await import('./global/migrate.js');
 }
-else if (command === 'init') {
+else if (command === 'config') {
     // @ts-ignore — rolldown output
-    await import('./global/init.js');
+    await import('./global/config.js');
 }
 else if (command === 'mcp') {
     // @ts-ignore — rolldown output
@@ -47,6 +47,10 @@ else if (command === '--version' || command === '-V') {
     // @ts-ignore — rolldown output
     await import('./global/version.js');
 }
+else if (command === 'staged') {
+    // @ts-ignore — rolldown output
+    await import('./global/staged.js');
+}
 else {
     // All other commands — delegate to Rust core via NAPI binding
     run({

package/dist/config/agent.d.ts

@@ -0,0 +1,9 @@
+import { type AgentConfig } from '../utils/agent.js';
+export interface AgentSetupSelection {
+    instructionFilePath: 'CLAUDE.md' | 'AGENTS.md';
+    agents: AgentConfig[];
+}
+export declare function resolveAgentSetup(root: string, interactive: boolean): Promise<AgentSetupSelection>;
+export declare function hasExistingAgentInstructions(root: string): boolean;
+export declare function injectAgentBlock(root: string, filePath: string): void;
+export declare function setupMcpConfig(root: string, selectedAgents: AgentConfig[]): void;

package/dist/config/agent.js

@@ -0,0 +1,190 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import * as prompts from '@voidzero-dev/vite-plus-prompts';
+import { detectAgents, getAgentById, } from '../utils/agent.js';
+import { writeJsonFile, readJsonFile } from '../utils/json.js';
+import { pkgRoot } from '../utils/path.js';
+function detectInstructionFilePath(root, agentConfigs) {
+    if (agentConfigs.some((a) => a.skillsDir === '.claude/skills')) {
+        return 'CLAUDE.md';
+    }
+    if (existsSync(join(root, 'CLAUDE.md'))) {
+        return 'CLAUDE.md';
+    }
+    return 'AGENTS.md';
+}
+async function pickAgentWhenUndetected() {
+    const choice = await prompts.select({
+        message: 'Could not detect your coding agent. Which one are you using?',
+        options: [
+            { value: 'claude-code', label: 'Claude Code' },
+            { value: 'cursor', label: 'Cursor' },
+            { value: 'codex', label: 'Codex' },
+            { value: 'gemini-cli', label: 'Gemini CLI' },
+            { value: 'generic', label: 'Generic' },
+        ],
+    });
+    if (prompts.isCancel(choice)) {
+        prompts.cancel('Setup cancelled.');
+        process.exit(0);
+    }
+    if (choice === 'generic') {
+        return {
+            instructionFilePath: 'AGENTS.md',
+            agents: [],
+        };
+    }
+    const selected = getAgentById(choice);
+    if (!selected) {
+        return {
+            instructionFilePath: 'AGENTS.md',
+            agents: [],
+        };
+    }
+    return {
+        instructionFilePath: choice === 'claude-code' ? 'CLAUDE.md' : 'AGENTS.md',
+        agents: [selected],
+    };
+}
+export async function resolveAgentSetup(root, interactive) {
+    const detected = detectAgents(root);
+    if (detected.length > 0 || !interactive) {
+        return {
+            instructionFilePath: detectInstructionFilePath(root, detected),
+            agents: detected,
+        };
+    }
+    return pickAgentWhenUndetected();
+}
+// --- Version and template reading ---
+function getOwnVersion() {
+    const pkg = JSON.parse(readFileSync(join(pkgRoot, 'package.json'), 'utf-8'));
+    if (typeof pkg.version !== 'string') {
+        throw new Error('vite-plus package.json is missing a "version" field');
+    }
+    return pkg.version;
+}
+function readAgentPrompt() {
+    return readFileSync(join(pkgRoot, 'AGENTS.md'), 'utf-8');
+}
+// --- Versioned injection ---
+const MARKER_OPEN_RE = /<!--injected-by-vite-plus-v([\w.+-]+)-->/;
+const MARKER_CLOSE = '<!--/injected-by-vite-plus-->';
+const MARKER_BLOCK_RE = /<!--injected-by-vite-plus-v[\w.+-]+-->\n[\s\S]*?<!--\/injected-by-vite-plus-->/;
+export function hasExistingAgentInstructions(root) {
+    for (const file of ['AGENTS.md', 'CLAUDE.md']) {
+        const fullPath = join(root, file);
+        if (existsSync(fullPath)) {
+            const content = readFileSync(fullPath, 'utf-8');
+            if (MARKER_OPEN_RE.test(content)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function injectAgentBlock(root, filePath) {
+    const fullPath = join(root, filePath);
+    const version = getOwnVersion();
+    const promptContent = readAgentPrompt();
+    const openMarker = `<!--injected-by-vite-plus-v${version}-->`;
+    const block = `${openMarker}\n${promptContent}\n${MARKER_CLOSE}`;
+    if (existsSync(fullPath)) {
+        const existing = readFileSync(fullPath, 'utf-8');
+        const match = existing.match(MARKER_OPEN_RE);
+        if (match) {
+            if (match[1] === version) {
+                prompts.log.info(`${filePath} already has Vite+ instructions (v${version})`);
+                return;
+            }
+            // Replace existing block with updated version
+            const updated = existing.replace(MARKER_BLOCK_RE, block);
+            if (updated === existing) {
+                // Closing marker is missing or malformed — append fresh block
+                const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+                writeFileSync(fullPath, existing + separator + block + '\n');
+                prompts.log.warn(`Existing Vite+ block in ${filePath} was malformed; appended fresh block`);
+            }
+            else {
+                writeFileSync(fullPath, updated);
+                prompts.log.success(`Updated Vite+ instructions in ${filePath} (v${match[1]} → v${version})`);
+            }
+        }
+        else {
+            // Append block to end of file
+            const separator = existing.endsWith('\n') ? '\n' : '\n\n';
+            writeFileSync(fullPath, existing + separator + block + '\n');
+            prompts.log.success(`Added Vite+ instructions to ${filePath}`);
+        }
+    }
+    else {
+        writeFileSync(fullPath, block + '\n');
+        prompts.log.success(`Created ${filePath} with Vite+ instructions`);
+    }
+}
+// --- MCP config ---
+function writeMcpConfigForTarget(root, target) {
+    const fullPath = join(root, target.filePath);
+    let existing = {};
+    if (existsSync(fullPath)) {
+        try {
+            existing = readJsonFile(fullPath);
+        }
+        catch {
+            prompts.log.warn(`Could not parse ${target.filePath} — skipping MCP config. Please add the config manually.`);
+            return;
+        }
+    }
+    if (!existing[target.rootKey]) {
+        existing[target.rootKey] = {};
+    }
+    if (existing[target.rootKey]['vite-plus']) {
+        prompts.log.info(`${target.filePath} already has vite-plus MCP config`);
+        return;
+    }
+    existing[target.rootKey]['vite-plus'] = {
+        command: 'npx',
+        args: ['vp', 'mcp'],
+        ...target.extraFields,
+    };
+    mkdirSync(dirname(fullPath), { recursive: true });
+    writeJsonFile(fullPath, existing);
+    prompts.log.success(`Added vite-plus MCP server to ${target.filePath}`);
+}
+function pickMcpTarget(root, targets) {
+    if (targets.length === 1) {
+        return targets[0];
+    }
+    return targets.find((t) => existsSync(join(root, t.filePath))) ?? targets[0];
+}
+export function setupMcpConfig(root, selectedAgents) {
+    if (selectedAgents.length === 0) {
+        prompts.note(JSON.stringify({
+            'vite-plus': {
+                command: 'npx',
+                args: ['vp', 'mcp'],
+            },
+        }, null, 2), 'Add this MCP server config to your agent');
+        return;
+    }
+    const mcpAgents = [];
+    const hintAgents = [];
+    for (const agent of selectedAgents) {
+        if (agent.mcpConfig) {
+            mcpAgents.push({ agent, targets: agent.mcpConfig });
+        }
+        else if (agent.mcpHint) {
+            hintAgents.push({ agent, hint: agent.mcpHint });
+        }
+    }
+    // Print hints for agents without project-level config
+    for (const { agent, hint } of hintAgents) {
+        prompts.log.info(`${agent.displayName}: ${hint}`);
+    }
+    // Write config for agents with project-level support
+    for (const { agent, targets } of mcpAgents) {
+        const target = pickMcpTarget(root, targets);
+        prompts.log.info(`${agent.displayName} MCP target: ${target.filePath}`);
+        writeMcpConfigForTarget(root, target);
+    }
+}

package/dist/config/bin.d.ts

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

package/dist/config/bin.js

@@ -0,0 +1,79 @@
+// Unified `vp config` command — merges the old `vp prepare` (hooks setup) and
+// `vp init` (agent integration) into a single entry point.
+//
+// Interactive mode (TTY, no CI): prompts on first run, updates silently after.
+// Non-interactive mode (scripts.prepare, CI, piped): runs everything by default.
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import mri from 'mri';
+import { vitePlusHeader } from '../../binding/index.js';
+import { renderCliDoc } from '../utils/help.js';
+import { defaultInteractive, promptGitHooks } from '../utils/prompts.js';
+import { linkSkillsForSpecificAgents } from '../utils/skills.js';
+import { log } from '../utils/terminal.js';
+import { resolveAgentSetup, hasExistingAgentInstructions, injectAgentBlock, setupMcpConfig, } from './agent.js';
+import { install } from './hooks.js';
+async function main() {
+    const args = mri(process.argv.slice(3), {
+        boolean: ['help', 'hooks-only'],
+        string: ['hooks-dir'],
+        alias: { h: 'help' },
+    });
+    if (args.help) {
+        const helpMessage = renderCliDoc({
+            usage: 'vp config [OPTIONS]',
+            summary: 'Configure Vite+ for the current project (hooks + agent integration).',
+            sections: [
+                {
+                    title: 'Options',
+                    rows: [
+                        {
+                            label: '--hooks-dir <path>',
+                            description: 'Custom hooks directory (default: .vite-hooks)',
+                        },
+                        { label: '-h, --help', description: 'Show this help message' },
+                    ],
+                },
+                {
+                    title: 'Environment',
+                    rows: [{ label: 'VITE_GIT_HOOKS=0', description: 'Skip hook installation' }],
+                },
+            ],
+        });
+        log(vitePlusHeader() + '\n');
+        log(helpMessage);
+        return;
+    }
+    const dir = args['hooks-dir'];
+    const hooksOnly = args['hooks-only'];
+    const interactive = defaultInteractive();
+    const root = process.cwd();
+    // --- Step 1: Hooks setup ---
+    const hooksDir = dir ?? '.vite-hooks';
+    const isFirstHooksRun = !existsSync(join(root, hooksDir, 'pre-commit'));
+    let shouldSetupHooks = true;
+    if (interactive && isFirstHooksRun && !dir) {
+        // --hooks-dir implies agreement; only prompt when using default dir on first run
+        shouldSetupHooks = await promptGitHooks({ interactive });
+    }
+    if (shouldSetupHooks) {
+        const { message, isError } = install(dir);
+        if (message) {
+            log(message);
+            if (isError) {
+                process.exit(1);
+            }
+        }
+    }
+    // --- Step 2: Agent setup (skipped with --hooks-only or during prepare lifecycle) ---
+    if (!hooksOnly && process.env.npm_lifecycle_event !== 'prepare') {
+        const isFirstAgentRun = !hasExistingAgentInstructions(root);
+        const agentSetup = await resolveAgentSetup(root, interactive && isFirstAgentRun);
+        injectAgentBlock(root, agentSetup.instructionFilePath);
+        setupMcpConfig(root, agentSetup.agents);
+        if (agentSetup.agents.length > 0) {
+            linkSkillsForSpecificAgents(root, agentSetup.agents);
+        }
+    }
+}
+void main();

package/dist/config/hooks.d.ts

@@ -0,0 +1,6 @@
+export declare function hookScript(dir: string): string;
+export interface InstallResult {
+    message: string;
+    isError: boolean;
+}
+export declare function install(dir?: string): InstallResult;

package/dist/config/hooks.js

@@ -0,0 +1,101 @@
+import { spawnSync } from 'node:child_process';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+const HOOKS = [
+    'pre-commit',
+    'pre-merge-commit',
+    'prepare-commit-msg',
+    'commit-msg',
+    'post-commit',
+    'applypatch-msg',
+    'pre-applypatch',
+    'post-applypatch',
+    'pre-rebase',
+    'post-rewrite',
+    'post-checkout',
+    'post-merge',
+    'pre-push',
+    'pre-auto-gc',
+];
+// Build nested dirname expression: depth 3 → dirname "$(dirname "$(dirname "$0"))"
+function nestedDirname(depth) {
+    let expr = '"$0"';
+    for (let i = 0; i < depth; i++) {
+        expr = `"$(dirname ${expr})"`;
+    }
+    return expr;
+}
+// The shell script that dispatches to user-defined hooks in <dir>/
+// `depth` = number of path segments in `dir` + 2 (for `_` subdir + hook filename)
+export function hookScript(dir) {
+    // Count segments: ".vite-hooks" → 1, ".config/husky" → 2
+    // Filter out empty strings and '.' to handle paths like "./.config/husky"
+    const segments = dir.split('/').filter((s) => s !== '' && s !== '.').length;
+    const depth = segments + 2; // +2 for _ subdir and hook filename
+    const rootExpr = nestedDirname(depth);
+    return `#!/usr/bin/env sh
+{ [ "$HUSKY" = "2" ] || [ "$VITE_GIT_HOOKS" = "2" ]; } && set -x
+n=$(basename "$0")
+s=$(dirname "$(dirname "$0")")/$n
+
+[ ! -f "$s" ] && exit 0
+
+i="\${XDG_CONFIG_HOME:-$HOME/.config}/vite-plus/hooks-init.sh"
+[ ! -f "$i" ] && i="\${XDG_CONFIG_HOME:-$HOME/.config}/husky/init.sh"
+[ -f "$i" ] && . "$i"
+
+{ [ "\${HUSKY-}" = "0" ] || [ "\${VITE_GIT_HOOKS-}" = "0" ]; } && exit 0
+
+d=${rootExpr}
+export PATH="$d/node_modules/.bin:$PATH"
+sh -e "$s" "$@"
+c=$?
+
+[ $c != 0 ] && echo "VITE+ - $n script failed (code $c)"
+[ $c = 127 ] && echo "VITE+ - command not found in PATH=$PATH"
+exit $c`;
+}
+export function install(dir = '.vite-hooks') {
+    if (process.env.HUSKY === '0' || process.env.VITE_GIT_HOOKS === '0') {
+        return { message: 'skip install (git hooks disabled)', isError: false };
+    }
+    if (dir.includes('..')) {
+        return { message: '.. not allowed', isError: false };
+    }
+    // Use --show-prefix to get the relative path from git root to cwd.
+    // This avoids Windows path normalization issues (MSYS paths, 8.3 short names)
+    // that make path.relative() unreliable across git and Node.js representations.
+    const prefixResult = spawnSync('git', ['rev-parse', '--show-prefix']);
+    if (prefixResult.status == null) {
+        return { message: 'git command not found', isError: true };
+    }
+    if (prefixResult.status !== 0) {
+        return { message: ".git can't be found", isError: false };
+    }
+    const internal = (x = '') => join(dir, '_', x);
+    const rel = prefixResult.stdout.toString().trim().replace(/\/$/, '');
+    const target = rel ? `${rel}/${dir}/_` : `${dir}/_`;
+    const checkResult = spawnSync('git', ['config', '--local', 'core.hooksPath']);
+    const existingHooksPath = checkResult.status === 0 ? checkResult.stdout?.toString().trim() : '';
+    if (existingHooksPath && existingHooksPath !== target) {
+        return {
+            message: `core.hooksPath is already set to "${existingHooksPath}", skipping`,
+            isError: false,
+        };
+    }
+    const { status, stderr } = spawnSync('git', ['config', 'core.hooksPath', target]);
+    if (status == null) {
+        return { message: 'git command not found', isError: true };
+    }
+    if (status) {
+        return { message: '' + stderr, isError: true };
+    }
+    rmSync(internal('husky.sh'), { force: true });
+    mkdirSync(internal(), { recursive: true });
+    writeFileSync(internal('.gitignore'), '*');
+    writeFileSync(internal('h'), hookScript(dir), { mode: 0o755 });
+    for (const hook of HOOKS) {
+        writeFileSync(internal(hook), `#!/usr/bin/env sh\n. "$(dirname "$0")/h"`, { mode: 0o755 });
+    }
+    return { message: '', isError: false };
+}