git-vibe-setup 3.1.1 → 4.1.0

package/dist/cli.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env node
 import { realpathSync } from "node:fs";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 import { fileURLToPath } from "node:url";
 import { fetchConsumerStarterFiles } from "./consumer-starter.js";
 import { githubTokenFromEnvironment } from "./github-api.js";
-import { blockingInstallPaths, buildInstallFiles, buildWorkflowUpdateFiles, existingFilesError, installFiles, unmanagedWorkflowUpdateError, unmanagedWorkflowUpdatePaths, updateFiles, } from "./install.js";
+import { blockingInstallPaths, buildInstallFiles, buildUpdateFiles, existingFilesError, installFiles, obsoleteWorkflowCleanupPaths, unmanagedWorkflowUpdateError, unmanagedWorkflowUpdatePaths, updateFiles, } from "./install.js";
 import { renderManualSetupInstructions } from "./instructions.js";
 import { latestReleaseTag } from "./releases.js";
 const usage = `Usage:
@@ -40,12 +40,13 @@ export async function runUpdate(runtime = {}) {
     const githubToken = runtime.githubToken || githubTokenFromEnvironment();
     const releaseTag = await resolveReleaseTag(runtime, fetchImpl, githubToken);
     const sourceFiles = await fetchConsumerStarterFiles({ fetchImpl, githubToken, releaseTag });
-    const files = buildWorkflowUpdateFiles({ cwd, releaseTag, sourceFiles });
+    const files = buildUpdateFiles({ cwd, releaseTag, sourceFiles });
     const unmanagedPaths = unmanagedWorkflowUpdatePaths(files);
+    const cleanupPaths = obsoleteWorkflowCleanupPaths(files);
     if (unmanagedPaths.length > 0)
         throw unmanagedWorkflowUpdateError(unmanagedPaths, cwd);
     updateFiles(files);
-    (runtime.log || console.log)(`GitVibe workflow files updated with reusable workflows pinned to ${releaseTag}.`);
+    (runtime.log || console.log)(updateSuccessMessage({ cleanupPaths, cwd, releaseTag }));
 }
 export async function setupCli(runtime = {}) {
     const argv = runtime.argv || process.argv.slice(2);
@@ -149,6 +150,15 @@ function validateReleaseTag(releaseTag) {
     }
     throw new Error(`Invalid release tag: ${releaseTag}. Release tags must look like v3.0.4 or v3.0.4-rc.1.`);
 }
+function updateSuccessMessage(options) {
+    const message = `GitVibe config and workflow files updated with reusable workflows pinned to ${options.releaseTag}.`;
+    if (options.cleanupPaths.length === 0)
+        return message;
+    const listed = options.cleanupPaths
+        .map((path) => `- ${relative(options.cwd, path) || path}`)
+        .join("\n");
+    return `${message}\nObsolete workflow files were left in place for manual review:\n${listed}`;
+}
 /* c8 ignore start */
 if (isDirectRun(import.meta.url)) {
     const exitCode = await setupCli();

package/dist/install.d.ts

@@ -9,15 +9,17 @@ export declare function buildInstallFiles(options: {
     releaseTag: string;
     sourceFiles: ConsumerStarterFile[];
 }): InstallFile[];
-export declare function buildWorkflowUpdateFiles(options: {
+export declare function buildUpdateFiles(options: {
     cwd: string;
     releaseTag: string;
     sourceFiles: ConsumerStarterFile[];
 }): InstallFile[];
 export declare function blockingInstallPaths(files: InstallFile[]): string[];
 export declare function unmanagedWorkflowUpdatePaths(files: InstallFile[]): string[];
+export declare function obsoleteWorkflowCleanupPaths(files: InstallFile[]): string[];
 export declare function installFiles(files: InstallFile[]): void;
 export declare function updateFiles(files: InstallFile[]): void;
 export declare function existingFilesError(paths: string[], cwd: string): Error;
 export declare function unmanagedWorkflowUpdateError(paths: string[], cwd: string): Error;
 export declare function pinWorkflowReleaseRefs(content: string, releaseTag: string): string;
+export declare function migrateGitVibeConfigContent(content: string): string;

package/dist/install.js

@@ -1,9 +1,7 @@
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative } from "node:path";
 const requiredInstallSourcePaths = [
     ".github/git-vibe.yml",
-    ".github/workflows/address-feedback.yml",
-    ".github/workflows/develop.yml",
     ".github/workflows/investigate.yml",
     ".github/workflows/materialize.yml",
     ".github/workflows/review.yml",
@@ -13,17 +11,19 @@ const requiredInstallSourcePaths = [
     ".git-vibe/role-group/security.md",
 ];
 const requiredWorkflowSourcePaths = requiredInstallSourcePaths.filter(isWorkflowSourcePath);
+const requiredUpdateSourcePaths = [".github/git-vibe.yml", ...requiredWorkflowSourcePaths];
+const managedWorkflowMarker = "# GitVibe managed workflow wrapper";
 export function buildInstallFiles(options) {
     requireSourcePaths(options.sourceFiles, requiredInstallSourcePaths, options.releaseTag);
     return options.sourceFiles
         .filter((file) => isInstallSourcePath(file.relativePath))
         .map((file) => buildInstallFile(file, options.cwd, options.releaseTag));
 }
-export function buildWorkflowUpdateFiles(options) {
-    requireSourcePaths(options.sourceFiles, requiredWorkflowSourcePaths, options.releaseTag);
+export function buildUpdateFiles(options) {
+    requireSourcePaths(options.sourceFiles, requiredUpdateSourcePaths, options.releaseTag);
     return options.sourceFiles
-        .filter((file) => isWorkflowSourcePath(file.relativePath))
-        .map((file) => buildInstallFile(file, options.cwd, options.releaseTag));
+        .filter((file) => isUpdateSourcePath(file.relativePath))
+        .map((file) => buildUpdateFile(file, options.cwd, options.releaseTag));
 }
 export function blockingInstallPaths(files) {
     return files
@@ -33,10 +33,17 @@ export function blockingInstallPaths(files) {
 }
 export function unmanagedWorkflowUpdatePaths(files) {
     return files
+        .filter(isWorkflowInstallFile)
         .filter((file) => existsSync(file.targetPath) && !isManagedWorkflowTarget(file))
         .map((file) => file.targetPath)
         .sort();
 }
+export function obsoleteWorkflowCleanupPaths(files) {
+    return obsoleteWorkflowPaths(files)
+        .filter((targetPath) => !isMarkedManagedWorkflowFile(targetPath, basename(targetPath)))
+        .filter((targetPath) => isManagedWorkflowFile(targetPath, basename(targetPath)))
+        .sort();
+}
 export function installFiles(files) {
     const createdDirectories = [];
     const createdFiles = [];
@@ -61,6 +68,10 @@ export function updateFiles(files) {
             snapshots.push(snapshotFile(file.targetPath));
             writeFileSync(file.targetPath, file.content);
         }
+        for (const targetPath of obsoleteManagedWorkflowPaths(files)) {
+            snapshots.push(snapshotFile(targetPath));
+            rmSync(targetPath, { force: true });
+        }
     }
     catch (error) {
         rollbackUpdate(snapshots, createdDirectories);
@@ -78,10 +89,42 @@ export function unmanagedWorkflowUpdateError(paths, cwd) {
 export function pinWorkflowReleaseRefs(content, releaseTag) {
     return content.replace(/(uses:\s*markhuangai\/git-vibe\/\.github\/workflows\/[^\s@]+)@[^\s]+/g, (_match, workflowReference) => `${workflowReference}@${releaseTag}`);
 }
+export function migrateGitVibeConfigContent(content) {
+    const migratedComments = migrateLegacyEventDeliveryComments(content);
+    return ensureTrailingNewline(migrateGithubAuthConfig(migratedComments));
+}
 function isManagedWorkflowTarget(file) {
+    return isManagedWorkflowFile(file.targetPath, basename(file.targetPath));
+}
+function isManagedWorkflowFile(targetPath, workflowName) {
+    try {
+        return managedWorkflowPattern(workflowName).test(readFileSync(targetPath, "utf8"));
+    }
+    catch {
+        return false;
+    }
+}
+function obsoleteManagedWorkflowPaths(files) {
+    return obsoleteWorkflowPaths(files)
+        .filter((targetPath) => isMarkedManagedWorkflowFile(targetPath, basename(targetPath)))
+        .sort();
+}
+function obsoleteWorkflowPaths(files) {
+    const workflowDirectory = dirname(files.find(isWorkflowInstallFile)?.targetPath || "");
+    if (!workflowDirectory || workflowDirectory === ".")
+        return [];
+    if (!existsSync(workflowDirectory))
+        return [];
+    const currentWorkflowNames = new Set(files.filter(isWorkflowInstallFile).map((file) => basename(file.targetPath)));
+    return readdirSync(workflowDirectory, { withFileTypes: true })
+        .filter((entry) => entry.isFile() && !currentWorkflowNames.has(entry.name))
+        .map((entry) => join(workflowDirectory, entry.name));
+}
+function isMarkedManagedWorkflowFile(targetPath, workflowName) {
     try {
-        const workflowName = basename(file.targetPath);
-        return managedWorkflowPattern(workflowName).test(readFileSync(file.targetPath, "utf8"));
+        const content = readFileSync(targetPath, "utf8");
+        return (content.startsWith(`${managedWorkflowMarker}\n`) &&
+            managedWorkflowPattern(workflowName).test(content));
     }
     catch {
         return false;
@@ -150,6 +193,22 @@ function buildInstallFile(sourceFile, cwd, releaseTag) {
         targetPath: join(cwd, safeRelativePath(sourceFile.relativePath)),
     };
 }
+function buildUpdateFile(sourceFile, cwd, releaseTag) {
+    const targetPath = join(cwd, safeRelativePath(sourceFile.relativePath));
+    const existingContent = fileContentIfExists(targetPath);
+    let content = pinWorkflowReleaseRefs(sourceFile.content, releaseTag);
+    if (sourceFile.relativePath === ".github/git-vibe.yml" && existingContent !== undefined) {
+        content = migrateGitVibeConfigContent(existingContent);
+    }
+    else if (isWorkflowSourcePath(sourceFile.relativePath) && existingContent !== undefined) {
+        content = preserveWorkflowRunner(content, existingContent);
+    }
+    return {
+        content,
+        sourcePath: sourceFile.sourcePath,
+        targetPath,
+    };
+}
 function requireSourcePaths(sourceFiles, requiredPaths, releaseTag) {
     const sourcePaths = new Set(sourceFiles.map((file) => file.relativePath));
     const missingPaths = requiredPaths.filter((path) => !sourcePaths.has(path));
@@ -161,9 +220,15 @@ function requireSourcePaths(sourceFiles, requiredPaths, releaseTag) {
 function isInstallSourcePath(relativePath) {
     return relativePath.startsWith(".github/") || relativePath.startsWith(".git-vibe/");
 }
+function isUpdateSourcePath(relativePath) {
+    return relativePath === ".github/git-vibe.yml" || isWorkflowSourcePath(relativePath);
+}
 function isWorkflowSourcePath(relativePath) {
     return relativePath.startsWith(".github/workflows/") && relativePath.endsWith(".yml");
 }
+function isWorkflowInstallFile(file) {
+    return file.sourcePath.includes(".github/workflows/") && file.sourcePath.endsWith(".yml");
+}
 function safeRelativePath(relativePath) {
     const segments = relativePath.split("/");
     const isSafe = relativePath.length > 0 &&
@@ -174,3 +239,27 @@ function safeRelativePath(relativePath) {
         return relativePath;
     throw new Error(`git-vibe-setup found an unsafe starter file path: ${relativePath}`);
 }
+function fileContentIfExists(targetPath) {
+    if (!existsSync(targetPath))
+        return undefined;
+    return readFileSync(targetPath, "utf8");
+}
+function preserveWorkflowRunner(generatedContent, existingContent) {
+    const runner = /^\s+runner:\s*(.+)$/m.exec(existingContent)?.[1];
+    if (!runner)
+        return generatedContent;
+    return generatedContent.replace(/^(\s+runner:\s*).+$/m, `$1${runner}`);
+}
+function migrateLegacyEventDeliveryComments(content) {
+    return content.replace(/^event_delivery:\n  # webhook: repository webhook points at the self-hosted GitVibe server\.\n  # relay: webhook proxy\/tunnel such as Smee, Hookdeck, Cloudflare Tunnel, or ngrok\.\n  # actions: no-server receiver workflows in the consumer repository\.\n  # polling: local\/scheduled worker polls GitHub APIs with cursors\/ETags\.\n/m, "event_delivery:\n  # Hosted GitHub App installs configure webhooks centrally; repositories do not create hooks.\n");
+}
+function migrateGithubAuthConfig(content) {
+    const githubAppAuth = "github_auth:\n  mode: github-app\n";
+    if (/^github_auth:\n/m.test(content)) {
+        return content.replace(/^github_auth:\n(?:[ \t]+.*(?:\n|$))*/m, githubAppAuth);
+    }
+    return `${content.trimEnd()}\n\n${githubAppAuth}`;
+}
+function ensureTrailingNewline(content) {
+    return content.endsWith("\n") ? content : `${content}\n`;
+}

package/dist/instructions.js

@@ -1,7 +1,5 @@
 const requiredSecrets = [
     ["GITVIBE_AI_ENV_JSON", "JSON env bundle for AI provider config and CLI auth."],
-    ["GITVIBE_GITHUB_TOKEN", "Fine-grained PAT for GitVibe workflow and server writes."],
-    ["WEBHOOK_SECRET", "Webhook shared secret mapped to GITHUB_WEBHOOK_SECRET in deployment."],
 ];
 const usefulVariables = [
     "GITVIBE_BASE_BRANCH",
@@ -13,8 +11,9 @@ export function renderManualSetupInstructions(releaseTag) {
     const lines = [
         `GitVibe starter files installed with reusable workflows pinned to ${releaseTag}.`,
         "",
-        "Configure these GitHub secrets manually before running the workflows:",
+        "Configure this GitHub secret manually before running the workflows:",
         ...requiredSecrets.map(([name, description]) => `- ${name}: ${description}`),
+        "- GITVIBE_MCP_ENV_JSON: optional JSON env bundle for MCP credentials.",
         "",
         "Optional repository variables:",
         ...usefulVariables.map((name) => `- ${name}`),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-vibe-setup",
-  "version": "3.1.1",
+  "version": "4.1.0",
   "private": false,
   "type": "module",
   "bin": {