@vibecodetown/mcp-server 1.3.1 → 1.4.0

package/build/ci/clinic_result.js

@@ -0,0 +1,197 @@
+/**
+ * Clinic result builder.
+ * Extracted from pipeline.ts for modularity.
+ */
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { getPmRunDir } from '../kernel/paths.js';
+export function detectNodeScripts(workspaceRoot) {
+    try {
+        const pkgPath = path.join(workspaceRoot, 'package.json');
+        if (!fs.existsSync(pkgPath))
+            return { hasPackageJson: false, build: false, test: false };
+        const raw = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (!raw || typeof raw !== 'object')
+            return { hasPackageJson: true, build: false, test: false };
+        const scripts = raw.scripts;
+        const build = !!(scripts &&
+            typeof scripts === 'object' &&
+            typeof scripts.build === 'string' &&
+            scripts.build.trim());
+        const test = !!(scripts &&
+            typeof scripts === 'object' &&
+            typeof scripts.test === 'string' &&
+            scripts.test.trim());
+        return { hasPackageJson: true, build, test };
+    }
+    catch {
+        return { hasPackageJson: true, build: false, test: false };
+    }
+}
+function getNpmCommand() {
+    return process.platform === 'win32' ? 'npm.cmd' : 'npm';
+}
+export function runVerificationCommand(workspaceRoot, cmd, args, timeoutSeconds) {
+    const r = spawnSync(cmd, args, {
+        cwd: workspaceRoot,
+        encoding: 'utf8',
+        timeout: Math.max(1, timeoutSeconds) * 1000,
+    });
+    return {
+        ok: r.status === 0,
+        stdout: String(r.stdout || ''),
+        stderr: String(r.stderr || ''),
+        code: typeof r.status === 'number' ? r.status : 1,
+    };
+}
+export function buildClinicResult(params) {
+    const created_at = new Date().toISOString();
+    const lines_changed = params.diff.insertions + params.diff.deletions;
+    const evidenceRel = path.join('artifacts', 'clinic_verification.log').replaceAll('\\', '/');
+    const evidenceAbs = path.join(getPmRunDir(params.workspaceRoot, params.runId), evidenceRel);
+    const scripts = detectNodeScripts(params.workspaceRoot);
+    const npmCmd = getNpmCommand();
+    const logs = [];
+    const reasons = [];
+    let buildStatus = 'skipped';
+    let testsPassed = 0;
+    let testsFailed = 0;
+    if (!scripts.hasPackageJson) {
+        reasons.push({
+            id: 'NO_COMMANDS',
+            msg: 'No package.json found; cannot auto-detect build/test commands',
+            evidence_ref: evidenceRel,
+        });
+        fs.mkdirSync(path.dirname(evidenceAbs), { recursive: true });
+        fs.writeFileSync(evidenceAbs, 'No package.json found.\n', 'utf-8');
+        return {
+            schema_version: 'clinic_result.v1.2',
+            tool: 'clinic',
+            run_id: params.runId,
+            verdict: 'FIX',
+            status: 'FAILED',
+            iterations: 0,
+            lines_changed,
+            reason: 'NO_COMMANDS',
+            evidence_path: evidenceRel,
+            summary: 'No verification commands detected (package.json missing)',
+            reasons,
+            metrics: {
+                tests: { passed: testsPassed, failed: testsFailed },
+                build: { status: buildStatus },
+            },
+            policy: { max_iterations: 0, dry_run: true },
+            created_at,
+        };
+    }
+    if (!scripts.build && !scripts.test) {
+        reasons.push({
+            id: 'NO_COMMANDS',
+            msg: 'No build/test scripts found in package.json',
+            evidence_ref: evidenceRel,
+        });
+        fs.mkdirSync(path.dirname(evidenceAbs), { recursive: true });
+        fs.writeFileSync(evidenceAbs, 'No build/test scripts found in package.json.\n', 'utf-8');
+        return {
+            schema_version: 'clinic_result.v1.2',
+            tool: 'clinic',
+            run_id: params.runId,
+            verdict: 'FIX',
+            status: 'FAILED',
+            iterations: 0,
+            lines_changed,
+            reason: 'NO_COMMANDS',
+            evidence_path: evidenceRel,
+            summary: 'No verification commands detected (build/test scripts missing)',
+            reasons,
+            metrics: {
+                tests: { passed: testsPassed, failed: testsFailed },
+                build: { status: buildStatus },
+            },
+            policy: { max_iterations: 0, dry_run: true },
+            created_at,
+        };
+    }
+    if (scripts.build) {
+        const r = runVerificationCommand(params.workspaceRoot, npmCmd, ['run', 'build', '--silent'], params.timeoutSeconds);
+        logs.push(`=== build ===\nexit=${r.code}\n${r.stdout}\n${r.stderr}\n`);
+        if (!r.ok) {
+            buildStatus = 'fail';
+            reasons.push({ id: 'BUILD_FAIL', msg: 'Build command failed', evidence_ref: evidenceRel });
+            fs.mkdirSync(path.dirname(evidenceAbs), { recursive: true });
+            fs.writeFileSync(evidenceAbs, logs.join('\n'), 'utf-8');
+            return {
+                schema_version: 'clinic_result.v1.2',
+                tool: 'clinic',
+                run_id: params.runId,
+                verdict: 'BLOCK',
+                status: 'FAILED',
+                iterations: 0,
+                lines_changed,
+                reason: 'BUILD_FAIL',
+                evidence_path: evidenceRel,
+                summary: 'Build failed',
+                reasons,
+                metrics: {
+                    tests: { passed: testsPassed, failed: testsFailed },
+                    build: { status: buildStatus },
+                },
+                policy: { max_iterations: 0, dry_run: true },
+                created_at,
+            };
+        }
+        buildStatus = 'pass';
+    }
+    if (scripts.test) {
+        const r = runVerificationCommand(params.workspaceRoot, npmCmd, ['test', '--silent'], params.timeoutSeconds);
+        logs.push(`=== test ===\nexit=${r.code}\n${r.stdout}\n${r.stderr}\n`);
+        if (!r.ok) {
+            testsFailed = 1;
+            reasons.push({ id: 'TEST_FAIL', msg: 'Test command failed', evidence_ref: evidenceRel });
+            fs.mkdirSync(path.dirname(evidenceAbs), { recursive: true });
+            fs.writeFileSync(evidenceAbs, logs.join('\n'), 'utf-8');
+            return {
+                schema_version: 'clinic_result.v1.2',
+                tool: 'clinic',
+                run_id: params.runId,
+                verdict: 'FIX',
+                status: 'FAILED',
+                iterations: 0,
+                lines_changed,
+                reason: 'TEST_FAIL',
+                evidence_path: evidenceRel,
+                summary: 'Tests failed',
+                reasons,
+                metrics: {
+                    tests: { passed: testsPassed, failed: testsFailed },
+                    build: { status: buildStatus },
+                },
+                policy: { max_iterations: 0, dry_run: true },
+                created_at,
+            };
+        }
+        testsPassed = 1;
+    }
+    fs.mkdirSync(path.dirname(evidenceAbs), { recursive: true });
+    fs.writeFileSync(evidenceAbs, logs.join('\n'), 'utf-8');
+    return {
+        schema_version: 'clinic_result.v1.2',
+        tool: 'clinic',
+        run_id: params.runId,
+        verdict: 'GO',
+        status: 'SUCCESS',
+        iterations: 0,
+        lines_changed,
+        reason: null,
+        evidence_path: evidenceRel,
+        summary: 'Build/tests passed',
+        reasons,
+        metrics: {
+            tests: { passed: testsPassed, failed: testsFailed },
+            build: { status: buildStatus },
+        },
+        policy: { max_iterations: 0, dry_run: true },
+        created_at,
+    };
+}

package/build/ci/cloud_sync.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveCloudSyncToken(): Promise<string | null>;
+export declare function flushCloudSyncQueueInBackground(): Promise<void>;

package/build/ci/cloud_sync.js

@@ -0,0 +1,29 @@
+import { TokenCache } from '../mcp/auth/token_cache.js';
+import { SyncManager } from '../sync-manager.js';
+export async function resolveCloudSyncToken() {
+    const env = (process.env.VIBE_CLOUD_SYNC_TOKEN || '').trim();
+    if (env)
+        return env;
+    try {
+        const cached = await new TokenCache().get();
+        return cached?.token ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function flushCloudSyncQueueInBackground() {
+    try {
+        const token = await resolveCloudSyncToken();
+        if (!token)
+            return;
+        const syncManager = new SyncManager({
+            authToken: token,
+            endpoint: process.env.VIBE_CLOUD_SYNC_ENDPOINT || undefined,
+        });
+        await syncManager.flush();
+    }
+    catch {
+        // ignore
+    }
+}

package/build/ci/engine.d.ts

@@ -0,0 +1,10 @@
+export declare function findEngine(name: string): string | null;
+export declare function runEngine(enginePath: string, args: string[], options: {
+    timeout: number;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+}): Promise<{
+    code: number;
+    stdout: string;
+    stderr: string;
+}>;

package/build/ci/engine.js

@@ -0,0 +1,63 @@
+import { spawn } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+// ESM polyfill — used for best-effort engine discovery.
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export function findEngine(name) {
+    const platform = process.platform === 'win32' ? 'win_x64' : 'linux_x64';
+    const ext = process.platform === 'win32' ? '.exe' : '';
+    const binaryName = name + ext;
+    // 1. Environment variable override
+    const envPath = process.env[`VIBE_${name.toUpperCase().replace('-', '_')}_PATH`];
+    if (envPath && fs.existsSync(envPath))
+        return envPath;
+    // 2. Same directory as the entry script (best-effort)
+    const scriptDir = path.dirname(process.argv[1] || __dirname);
+    const sameDirPath = path.join(scriptDir, binaryName);
+    if (fs.existsSync(sameDirPath))
+        return sameDirPath;
+    // 3. Package root bin folder
+    const packageRoot = path.join(scriptDir, '..', '..');
+    const binPath = path.join(packageRoot, 'bin', `${name}_${platform}`, binaryName);
+    if (fs.existsSync(binPath))
+        return binPath;
+    // 4. CWD bin folder
+    const cwdBinPath = path.join(process.cwd(), 'bin', `${name}_${platform}`, binaryName);
+    if (fs.existsSync(cwdBinPath))
+        return cwdBinPath;
+    // 5. PATH lookup
+    const pathDirs = (process.env.PATH || '').split(path.delimiter);
+    for (const dir of pathDirs) {
+        const fullPath = path.join(dir, binaryName);
+        if (fs.existsSync(fullPath))
+            return fullPath;
+    }
+    return null;
+}
+export async function runEngine(enginePath, args, options) {
+    return new Promise(resolve => {
+        const proc = spawn(enginePath, args, {
+            cwd: options.cwd,
+            env: options.env ?? process.env,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            timeout: options.timeout * 1000,
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', data => {
+            stdout += data.toString();
+        });
+        proc.stderr.on('data', data => {
+            stderr += data.toString();
+        });
+        proc.on('close', code => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        proc.on('error', err => {
+            stderr += err.message;
+            resolve({ code: 1, stdout, stderr });
+        });
+    });
+}

package/build/ci/file_changes.d.ts

@@ -0,0 +1,10 @@
+/**
+ * File change detection utilities.
+ * Extracted from pipeline.ts for modularity.
+ */
+import type { DiffStats } from './pipeline_types.js';
+export declare function toPosixPath(p: string): string;
+export declare function uniqStrings(xs: string[]): string[];
+export declare function getModifiedFiles(workspaceRoot: string): string[];
+export declare function parseNumstat(out: string): DiffStats;
+export declare function getDiffStats(workspaceRoot: string): DiffStats;

package/build/ci/file_changes.js

@@ -0,0 +1,127 @@
+/**
+ * File change detection utilities.
+ * Extracted from pipeline.ts for modularity.
+ */
+import { spawnSync } from 'node:child_process';
+export function toPosixPath(p) {
+    return p.replaceAll('\\', '/');
+}
+export function uniqStrings(xs) {
+    const seen = new Set();
+    const out = [];
+    for (const x of xs) {
+        const k = x.trim();
+        if (!k)
+            continue;
+        if (seen.has(k))
+            continue;
+        seen.add(k);
+        out.push(k);
+    }
+    return out;
+}
+export function getModifiedFiles(workspaceRoot) {
+    const env = (process.env.VIBE_MODIFIED_FILES || '').trim();
+    if (env) {
+        return uniqStrings(env.split(/[,\\n\\r]+/g).map(s => toPosixPath(s.trim())));
+    }
+    const isGit = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
+        cwd: workspaceRoot,
+        encoding: 'utf8',
+    });
+    if (isGit.status !== 0)
+        return [];
+    const out = [];
+    const add = (args) => {
+        const r = spawnSync('git', args, { cwd: workspaceRoot, encoding: 'utf8' });
+        if (r.status !== 0)
+            return;
+        const lines = String(r.stdout || '')
+            .split(/\r?\n/g)
+            .map(s => s.trim())
+            .filter(Boolean);
+        out.push(...lines.map(toPosixPath));
+    };
+    const base = (process.env.VIBE_DIFF_BASE || '').trim();
+    if (base) {
+        add(['diff', '--name-only', '--diff-filter=ACMRT', `${base}...HEAD`]);
+    }
+    else {
+        const baseRef = (process.env.GITHUB_BASE_REF ||
+            process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME ||
+            '').trim();
+        if (baseRef) {
+            // best-effort fetch (FAIL-SAFE)
+            spawnSync('git', ['fetch', '--no-tags', '--depth', '200', 'origin', baseRef], {
+                cwd: workspaceRoot,
+                encoding: 'utf8',
+            });
+            add(['diff', '--name-only', '--diff-filter=ACMRT', `origin/${baseRef}...HEAD`]);
+        }
+    }
+    // local unstaged/staged changes (local mode)
+    add(['diff', '--name-only', '--diff-filter=ACMRT', '--cached']);
+    add(['diff', '--name-only', '--diff-filter=ACMRT']);
+    // fallback: last commit
+    if (out.length === 0) {
+        add(['diff', '--name-only', '--diff-filter=ACMRT', 'HEAD~1...HEAD']);
+    }
+    return uniqStrings(out);
+}
+export function parseNumstat(out) {
+    let files = 0;
+    let insertions = 0;
+    let deletions = 0;
+    for (const line of out.split(/\r?\n/g)) {
+        const t = line.trim();
+        if (!t)
+            continue;
+        const [a, d] = t.split(/\s+/g);
+        const ins = Number.parseInt(a ?? '', 10);
+        const del = Number.parseInt(d ?? '', 10);
+        if (!Number.isFinite(ins) || !Number.isFinite(del))
+            continue;
+        files += 1;
+        insertions += ins;
+        deletions += del;
+    }
+    return { files, insertions, deletions };
+}
+export function getDiffStats(workspaceRoot) {
+    const isGit = spawnSync('git', ['rev-parse', '--is-inside-work-tree'], {
+        cwd: workspaceRoot,
+        encoding: 'utf8',
+    });
+    if (isGit.status !== 0)
+        return { files: 0, insertions: 0, deletions: 0 };
+    const run = (args) => {
+        const r = spawnSync('git', args, { cwd: workspaceRoot, encoding: 'utf8' });
+        if (r.status !== 0)
+            return '';
+        return String(r.stdout || '');
+    };
+    const base = (process.env.VIBE_DIFF_BASE || '').trim();
+    if (base) {
+        return parseNumstat(run(['diff', '--numstat', `${base}...HEAD`]));
+    }
+    const baseRef = (process.env.GITHUB_BASE_REF ||
+        process.env.CI_MERGE_REQUEST_TARGET_BRANCH_NAME ||
+        '').trim();
+    if (baseRef) {
+        spawnSync('git', ['fetch', '--no-tags', '--depth', '200', 'origin', baseRef], {
+            cwd: workspaceRoot,
+            encoding: 'utf8',
+        });
+        return parseNumstat(run(['diff', '--numstat', `origin/${baseRef}...HEAD`]));
+    }
+    const staged = parseNumstat(run(['diff', '--numstat', '--cached']));
+    const unstaged = parseNumstat(run(['diff', '--numstat']));
+    const combined = {
+        files: Math.max(staged.files, unstaged.files),
+        insertions: staged.insertions + unstaged.insertions,
+        deletions: staged.deletions + unstaged.deletions,
+    };
+    if (combined.files > 0)
+        return combined;
+    return parseNumstat(run(['diff', '--numstat', 'HEAD~1...HEAD']));
+}

package/build/ci/pipeline.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Vibe CI CLI Wrapper v1.0
+ *
+ * 단일 검증 엔트리포인트 - vpm-back run을 호출하여 GO/FIX/BLOCK 판정
+ *
+ * Usage: vibe ci [options]
+ *
+ * Exit Codes:
+ *   0 = GO (머지 가능)
+ *   2 = FIX (수정 필요)
+ *   3 = BLOCK (차단)
+ *   1 = ERROR (인프라/엔진 오류)
+ */
+export { detectLanguage, checkLanguageRules } from './pipeline_violations.js';
+export type { LanguageRuleViolation } from './pipeline_violations.js';
+export declare const EXIT_CODES: {
+    readonly GO: 0;
+    readonly FIX: 2;
+    readonly BLOCK: 3;
+    readonly ERROR: 1;
+};
+export declare function main(): Promise<void>;