vibe-coding-master 0.4.20 → 0.4.22

package/dist/backend/app-version.js

@@ -0,0 +1,12 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+export function readVcmPackageVersion(appRoot) {
+    const packageJsonPath = path.join(appRoot, "package.json");
+    try {
+        const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+        return typeof raw.version === "string" && raw.version.trim() ? raw.version : "unknown";
+    }
+    catch {
+        return process.env.npm_package_version || "unknown";
+    }
+}

package/dist/backend/cli/install-vcm-harness.js

@@ -18,9 +18,10 @@ import { renderVcmHarnessBootstrapSkillRules } from "../templates/harness/vcm-ha
 import { renderVcmLongRunningValidationSkillRules } from "../templates/harness/vcm-long-running-validation-skill.js";
 import { renderVcmReportHarnessIssueSkillRules } from "../templates/harness/vcm-report-harness-issue-skill.js";
 import { renderVcmRouteMessageSkillRules } from "../templates/harness/vcm-route-message-skill.js";
-const HARNESS_VERSION = "0.3.0-fixed";
+import { readVcmPackageVersion } from "../app-version.js";
 const CLI_DIR = path.dirname(fileURLToPath(import.meta.url));
 const APP_ROOT = path.resolve(CLI_DIR, "../../..");
+const VCM_PACKAGE_VERSION = readVcmPackageVersion(APP_ROOT);
 const MANIFEST_PATH = ".ai/vcm-harness-manifest.json";
 const HTML_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=\d+)? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=\d+)?\n[\s\S]*?# VCM:END/m;
@@ -331,7 +332,7 @@ async function buildManifest(projectRoot) {
     return {
         schemaVersion: 1,
         manager: "vcm",
-        harnessVersion: HARNESS_VERSION,
+        harnessVersion: VCM_PACKAGE_VERSION,
         installMode: "fixed",
         installedAt: typeof current?.installedAt === "string" ? current.installedAt : now,
         updatedAt: now,

package/dist/backend/server.js

@@ -46,6 +46,7 @@ import { registerTaskRoutes } from "./api/task-routes.js";
 import { registerTranslationRoutes } from "./api/translation-routes.js";
 import { registerTerminalWs } from "./ws/terminal-ws.js";
 import { toVcmError } from "./errors.js";
+import { readVcmPackageVersion } from "./app-version.js";
 export async function createServer(deps, options = {}) {
     const app = Fastify({
         logger: false
@@ -161,6 +162,8 @@ export async function startServer(options = {}) {
 }
 export function createDefaultServerDeps(options = {}) {
     const fs = createNodeFileSystemAdapter();
+    const appRoot = getAppRoot();
+    const vcmVersion = readVcmPackageVersion(appRoot);
     const runner = createCommandRunner();
     const git = createGitAdapter(runner);
     const claude = createClaudeAdapter(runner);
@@ -185,7 +188,8 @@ export function createDefaultServerDeps(options = {}) {
         git,
         runtime,
         harnessEngineerSessions: sessionService,
-        runFixedInstaller: createScriptFixedHarnessInstaller(path.join(getAppRoot(), "scripts/install-vcm-harness.mjs"))
+        runFixedInstaller: createScriptFixedHarnessInstaller(path.join(appRoot, "scripts/install-vcm-harness.mjs")),
+        vcmVersion
     });
     const harnessFeedbackService = createHarnessFeedbackService({
         fs,
@@ -277,7 +281,7 @@ export function createDefaultServerDeps(options = {}) {
         translationWorkerService
     });
     const diagnosticsService = createDiagnosticsService({
-        appRoot: getAppRoot(),
+        appRoot,
         runtime,
         gatewayService,
         translationService

package/dist/backend/services/diagnostics-service.js

@@ -1,8 +1,7 @@
-import { readFileSync } from "node:fs";
 import fs from "node:fs/promises";
-import path from "node:path";
+import { readVcmPackageVersion } from "../app-version.js";
 export function createDiagnosticsService(deps) {
-    const version = readPackageVersion(deps.appRoot);
+    const version = readVcmPackageVersion(deps.appRoot);
     return {
         async getRuntimeDiagnostics() {
             const runtimeSessions = deps.runtime.listSessions();
@@ -34,16 +33,6 @@ export function createDiagnosticsService(deps) {
         }
     };
 }
-function readPackageVersion(appRoot) {
-    const packageJsonPath = path.join(appRoot, "package.json");
-    try {
-        const raw = JSON.parse(readFileSync(packageJsonPath, "utf8"));
-        return typeof raw.version === "string" && raw.version.trim() ? raw.version : "unknown";
-    }
-    catch {
-        return process.env.npm_package_version || "unknown";
-    }
-}
 async function readFdCount() {
     try {
         return (await fs.readdir("/proc/self/fd")).length;

package/dist/backend/services/harness-service.js

@@ -21,6 +21,7 @@ import { bumpHarnessRevision, readHarnessRevisionState } from "./harness-revisio
 const execFileAsync = promisify(execFile);
 const BOOTSTRAP_SESSION_PATH = ".ai/vcm/bootstrap/session.json";
 const HARNESS_ENGINEER_SESSION_PATH = ".ai/vcm/harness-engineer/session.json";
+const MANIFEST_PATH = ".ai/vcm-harness-manifest.json";
 export const VCM_HARNESS_VERSION = 1;
 const MANAGED_BLOCK_PATTERN = /<!-- VCM:BEGIN(?:\s+version=(\d+))? -->[\s\S]*?<!-- VCM:END -->/m;
 const HASH_MANAGED_BLOCK_PATTERN = /# VCM:BEGIN(?:\s+version=(\d+))?\n[\s\S]*?# VCM:END/m;
@@ -173,11 +174,15 @@ const HARNESS_FILES = [
 ];
 export function createHarnessService(deps) {
     const now = deps.now ?? (() => new Date().toISOString());
+    const vcmVersion = deps.vcmVersion ?? "unknown";
     return {
         async getHarnessStatus(repoRoot) {
             const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
-            return renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges);
+            const manifestChange = deps.runFixedInstaller
+                ? await analyzeHarnessManifest(deps.fs, repoRoot, vcmVersion)
+                : undefined;
+            return renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange);
         },
         async getHarnessFileContent(repoRoot, filePath) {
             return readHarnessFileContent(deps.fs, repoRoot, filePath);
@@ -208,9 +213,12 @@ export function createHarnessService(deps) {
             const file = await readHarnessFileContent(deps.fs, repoRoot, definition.path);
             const analyses = await analyzeHarnessFiles(deps.fs, repoRoot);
             const legacyChanges = await analyzeLegacyCodexHarnessPaths(deps.fs, repoRoot);
+            const manifestChange = deps.runFixedInstaller
+                ? await analyzeHarnessManifest(deps.fs, repoRoot, vcmVersion)
+                : undefined;
             return {
                 file,
-                status: renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges),
+                status: renderHarnessStatus(await readHarnessRevisionValue(deps.fs, repoRoot), analyses, legacyChanges, manifestChange),
                 harnessCommit
             };
         },
@@ -262,11 +270,11 @@ export function createHarnessService(deps) {
             return mergeRepositoryDiffToCurrentBranch(requireRepositoryMergeGit(deps.git), baseRepoRoot, input, now());
         },
         async getBootstrapStatus(repoRoot, targetRepoRoot = repoRoot) {
-            return getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now);
+            return getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
         },
         async startHarnessBootstrap(repoRoot, targetRepoRoot = repoRoot, input = {}) {
-            const session = await ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, input);
-            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now);
+            const session = await ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, vcmVersion, input);
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
             return {
                 status: {
                     ...nextStatus,
@@ -277,8 +285,8 @@ export function createHarnessService(deps) {
             };
         },
         async restartHarnessBootstrap(repoRoot, targetRepoRoot = repoRoot, input = {}) {
-            const session = await restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, input);
-            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now);
+            const session = await restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, vcmVersion, input);
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
             return {
                 status: {
                     ...nextStatus,
@@ -299,7 +307,7 @@ export function createHarnessService(deps) {
             }
             await deps.harnessEngineerSessions?.stopProjectHarnessEngineerSession(repoRoot);
             await clearHarnessBootstrapRunState(deps.fs, repoRoot);
-            return getHarnessBootstrapStatus(deps, repoRoot, repoRoot, now);
+            return getHarnessBootstrapStatus(deps, repoRoot, repoRoot, now, vcmVersion);
         },
         async runHarnessBootstrap(repoRoot, targetRepoRoot = repoRoot) {
             if (!deps.runtime || !deps.harnessEngineerSessions) {
@@ -310,7 +318,7 @@ export function createHarnessService(deps) {
                 });
             }
             await assertHarnessWorktreeClean(deps.git, targetRepoRoot);
-            const status = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now);
+            const status = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
             const session = status.session;
             if (!session || session.status !== "running" || !deps.runtime.getSession(session.id)) {
                 throw new VcmError({
@@ -331,7 +339,7 @@ export function createHarnessService(deps) {
                 updatedAt: timestamp
             });
             await submitTerminalInput(deps.runtime, session.id, prompt);
-            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now);
+            const nextStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
             return {
                 status: {
                     ...nextStatus,
@@ -345,7 +353,7 @@ export function createHarnessService(deps) {
         async recordHarnessBootstrapHook(repoRoot, input) {
             const state = await loadPersistedHarnessBootstrapRunState(deps.fs, repoRoot);
             if (state?.status !== "running" || !matchesBootstrapRunState(state, input)) {
-                return getHarnessBootstrapStatus(deps, repoRoot, state?.targetRepoRoot ?? repoRoot, now);
+                return getHarnessBootstrapStatus(deps, repoRoot, state?.targetRepoRoot ?? repoRoot, now, vcmVersion);
             }
             const timestamp = now();
             if (input.eventName === "Stop" && state.targetRepoRoot) {
@@ -358,11 +366,11 @@ export function createHarnessService(deps) {
                 updatedAt: timestamp,
                 lastHookEvent: input.eventName
             });
-            return getHarnessBootstrapStatus(deps, repoRoot, state.targetRepoRoot ?? repoRoot, now);
+            return getHarnessBootstrapStatus(deps, repoRoot, state.targetRepoRoot ?? repoRoot, now, vcmVersion);
         }
     };
 }
-async function ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, input) {
+async function ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, vcmVersion, input) {
     if (!deps.harnessEngineerSessions) {
         throw new VcmError({
             code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
@@ -370,7 +378,7 @@ async function ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot,
             statusCode: 501
         });
     }
-    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now);
+    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
     if (currentStatus.session?.status === "running") {
         return currentStatus.session;
     }
@@ -383,7 +391,7 @@ async function ensureHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot,
     }
     return toHarnessBootstrapSession(await deps.harnessEngineerSessions.ensureProjectHarnessEngineerSession(repoRoot, input));
 }
-async function restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, input) {
+async function restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot, now, vcmVersion, input) {
     if (!deps.harnessEngineerSessions) {
         throw new VcmError({
             code: "HARNESS_BOOTSTRAP_UNAVAILABLE",
@@ -391,7 +399,7 @@ async function restartHarnessEngineerForBootstrap(deps, repoRoot, targetRepoRoot
             statusCode: 501
         });
     }
-    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now);
+    const currentStatus = await getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion);
     if (!currentStatus.canStart) {
         throw new VcmError({
             code: "HARNESS_BOOTSTRAP_NOT_READY",
@@ -1075,12 +1083,13 @@ async function removeLegacyCodexHarnessPaths(fs, repoRoot) {
     }
     return changes;
 }
-function renderHarnessStatus(harnessRevision, analyses, legacyChanges = []) {
+function renderHarnessStatus(harnessRevision, analyses, legacyChanges = [], manifestChange) {
     const files = analyses.map((analysis) => analysis.status);
     const plannedChanges = analyses
         .map((analysis) => analysis.plannedChange)
         .filter((change) => Boolean(change))
-        .concat(legacyChanges);
+        .concat(legacyChanges)
+        .concat(manifestChange ? [manifestChange] : []);
     // Derive `initialized`: the VCM harness is considered installed when at least one
     // VCM-exclusive marker is present (per analysis):
     //   - status.hasManagedBlock === true (a managed block already lives in the file), OR
@@ -1253,10 +1262,40 @@ function resolveHarnessPath(repoRoot, relativePath) {
 function ensureTrailingNewline(content) {
     return content.endsWith("\n") ? content : `${content}\n`;
 }
-async function getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now) {
+async function analyzeHarnessManifest(fs, repoRoot, vcmVersion) {
+    if (!vcmVersion || vcmVersion === "unknown") {
+        return undefined;
+    }
+    const manifestPath = resolveHarnessPath(repoRoot, MANIFEST_PATH);
+    if (!await fs.pathExists(manifestPath)) {
+        return {
+            path: MANIFEST_PATH,
+            action: "create",
+            reason: `VCM fixed harness manifest is missing; current VCM version is ${vcmVersion}.`
+        };
+    }
+    const manifest = await readOptionalJsonObject(fs, repoRoot, MANIFEST_PATH);
+    const installedVersion = typeof manifest?.harnessVersion === "string" ? manifest.harnessVersion : undefined;
+    if (!manifest || manifest.manager !== "vcm" || manifest.schemaVersion !== 1) {
+        return {
+            path: MANIFEST_PATH,
+            action: "update",
+            reason: "VCM fixed harness manifest metadata is invalid."
+        };
+    }
+    if (installedVersion !== vcmVersion) {
+        return {
+            path: MANIFEST_PATH,
+            action: "update",
+            reason: `VCM fixed harness manifest version is ${installedVersion ?? "missing"}; current VCM version is ${vcmVersion}.`
+        };
+    }
+    return undefined;
+}
+async function getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now, vcmVersion) {
     const moduleIndex = await readOptionalJsonObject(deps.fs, targetRepoRoot, ".ai/generated/module-index.json");
     const checks = [
-        await checkFixedHarness(deps.fs, targetRepoRoot),
+        await checkFixedHarness(deps.fs, targetRepoRoot, vcmVersion),
         await checkProjectContext(deps.fs, targetRepoRoot),
         checkGeneratedJson(moduleIndex, ".ai/generated/module-index.json", "module-index", "Module index"),
         checkGeneratedJson(await readOptionalJsonObject(deps.fs, targetRepoRoot, ".ai/generated/public-surface.json"), ".ai/generated/public-surface.json", "public-surface", "Public surface"),
@@ -1288,10 +1327,10 @@ async function getHarnessBootstrapStatus(deps, repoRoot, targetRepoRoot, now) {
         warnings: bootstrapWarnings(status, checks, session, runState)
     };
 }
-async function checkFixedHarness(fs, repoRoot) {
+async function checkFixedHarness(fs, repoRoot, vcmVersion) {
     const requiredPaths = [
         "CLAUDE.md",
-        ".ai/vcm-harness-manifest.json",
+        MANIFEST_PATH,
         ".claude/skills/vcm-harness-bootstrap/SKILL.md",
         ".ai/tools/generate-module-index",
         ".ai/tools/generate-public-surface"
@@ -1320,6 +1359,16 @@ async function checkFixedHarness(fs, repoRoot) {
             detail: "CLAUDE.md is missing the VCM managed block."
         };
     }
+    const manifestChange = await analyzeHarnessManifest(fs, repoRoot, vcmVersion);
+    if (manifestChange) {
+        return {
+            key: "fixed-harness",
+            label: "Fixed harness",
+            status: "incomplete",
+            path: MANIFEST_PATH,
+            detail: manifestChange.reason
+        };
+    }
     return {
         key: "fixed-harness",
         label: "Fixed harness",

package/dist/main.js

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { DEFAULT_BACKEND_PORT, DEFAULT_FRONTEND_PORT } from "./shared/constants.js";
+import { readVcmPackageVersion } from "./backend/app-version.js";
 import { getDefaultStaticDir, startServer } from "./backend/server.js";
 export function parseMainArgs(argv) {
     const options = {};
@@ -75,17 +76,7 @@ export async function main(argv = process.argv.slice(2)) {
     });
 }
 function readPackageVersion() {
-    const packageJsonPath = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..", "package.json");
-    try {
-        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-        if (typeof packageJson.version === "string" && packageJson.version.trim()) {
-            return packageJson.version;
-        }
-    }
-    catch {
-        // Fall through to an explicit unknown version instead of starting the server.
-    }
-    return "unknown";
+    return readVcmPackageVersion(path.resolve(path.dirname(fileURLToPath(import.meta.url)), ".."));
 }
 function renderHelp() {
     return `Usage: