git-vibe-setup 4.0.0 → 5.0.0

package/README.md

@@ -20,10 +20,11 @@ npx git-vibe-setup update
 ```
 
 The `update` command fetches `examples/consumer` from the latest stable
-`markhuangai/git-vibe` release, rewrites only `.github/workflows/*.yml` GitVibe
-wrapper files, and pins them to that release. It does not update
-`.github/git-vibe.yml`, `.git-vibe`, secrets, or variables, and it refuses to
-overwrite workflow files that do not look like GitVibe wrappers.
+`markhuangai/git-vibe` release, migrates supported `.github/git-vibe.yml`
+settings in place, rewrites `.github/workflows/*.yml` GitVibe wrapper files,
+and pins workflow refs to that release. It does not update `.git-vibe`,
+secrets, or variables, and it refuses to overwrite workflow files that do not
+look like GitVibe wrappers.
 
 To test a specific release or prerelease from a consumer repository, pass the
 release tag explicitly:

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, buildUpdateFiles, 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:
@@ -42,10 +42,11 @@ export async function runUpdate(runtime = {}) {
     const sourceFiles = await fetchConsumerStarterFiles({ fetchImpl, githubToken, releaseTag });
     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 config and 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

@@ -16,6 +16,7 @@ export declare function buildUpdateFiles(options: {
 }): 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;

package/dist/install.js

@@ -1,9 +1,8 @@
-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";
+import { isMap, isScalar, parseDocument, YAMLMap } from "yaml";
 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",
@@ -14,6 +13,7 @@ const requiredInstallSourcePaths = [
 ];
 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
@@ -39,6 +39,12 @@ export function unmanagedWorkflowUpdatePaths(files) {
         .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 = [];
@@ -63,6 +69,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);
@@ -82,12 +92,41 @@ export function pinWorkflowReleaseRefs(content, releaseTag) {
 }
 export function migrateGitVibeConfigContent(content) {
     const migratedComments = migrateLegacyEventDeliveryComments(content);
-    return ensureTrailingNewline(migrateGithubAuthConfig(migratedComments));
+    const migratedAuth = migrateGithubAuthConfig(migratedComments);
+    return ensureTrailingNewline(migrateLegacyAiProfiles(migratedAuth));
 }
 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;
@@ -223,6 +262,144 @@ function migrateGithubAuthConfig(content) {
     }
     return `${content.trimEnd()}\n\n${githubAppAuth}`;
 }
+function migrateLegacyAiProfiles(content) {
+    const document = parseDocument(content);
+    if (document.errors.length > 0) {
+        throw new Error(`git-vibe-setup could not migrate .github/git-vibe.yml because it is not valid YAML: ${document.errors[0]?.message}`);
+    }
+    const root = document.contents;
+    if (!isMap(root))
+        return content;
+    const ai = root.get("ai", true);
+    if (!isMap(ai))
+        return content;
+    const profiles = ai.get("profiles", true);
+    if (!isMap(profiles))
+        return content;
+    let changed = false;
+    for (const pair of profiles.items) {
+        if (isMap(pair.value))
+            changed = migrateLegacyAiProfile(pair.value) || changed;
+    }
+    return changed ? document.toString() : content;
+}
+function migrateLegacyAiProfile(profile) {
+    const adapter = stringNodeValue(profile.get("adapter"));
+    if (adapter === "ai-sdk-agentool") {
+        migrateAgentoolProfile(profile);
+        return true;
+    }
+    if (adapter === "cli-claude-code") {
+        profile.set("adapter", "claude-code-sdk");
+        ensureClaudeModel(profile);
+        orderProfileKeys(profile);
+        return true;
+    }
+    if (adapter === "cli-codex") {
+        profile.set("adapter", "codex-sdk");
+        return true;
+    }
+    return false;
+}
+function migrateAgentoolProfile(profile) {
+    const provider = profile.get("provider", true);
+    profile.set("adapter", "claude-code-sdk");
+    syncClaudeEnvFromProvider(profile, provider);
+    syncReasoningEffort(profile);
+    trimProviderOptions(profile);
+    ensureClaudeModel(profile);
+    profile.delete("context_window_tokens");
+    profile.delete("provider");
+    orderProfileKeys(profile);
+}
+function syncClaudeEnvFromProvider(profile, provider) {
+    const env = ensureMap(profile, "env");
+    if (isMap(provider)) {
+        copyMapValue(provider, "api_key", env, "ANTHROPIC_API_KEY");
+        copyMapValue(provider, "base_url", env, "ANTHROPIC_BASE_URL");
+        const providerModel = stringNodeValue(provider.get("model"));
+        if (providerModel) {
+            setIfMissing(env, "ANTHROPIC_DEFAULT_OPUS_MODEL", providerModel);
+            setIfMissing(env, "ANTHROPIC_DEFAULT_SONNET_MODEL", providerModel);
+            setIfMissing(env, "ANTHROPIC_DEFAULT_HAIKU_MODEL", providerModel);
+        }
+    }
+    setIfMissing(env, "ANTHROPIC_MODEL", "opus");
+    setIfMissing(env, "CLAUDE_CODE_SUBAGENT_MODEL", "opus");
+}
+function syncReasoningEffort(profile) {
+    const effort = nodeAt(profile, ["reasoning", "effort"]) ||
+        nodeAt(profile, ["provider_options", "anthropic", "effort"]);
+    if (!effort)
+        return;
+    const reasoning = ensureMap(profile, "reasoning");
+    if (!reasoning.has("effort"))
+        reasoning.set("effort", effort);
+}
+function trimProviderOptions(profile) {
+    const providerOptions = profile.get("provider_options", true);
+    if (!isMap(providerOptions))
+        return;
+    providerOptions.delete("openai");
+    if (providerOptions.items.length === 0)
+        profile.delete("provider_options");
+}
+function ensureClaudeModel(profile) {
+    setIfMissing(profile, "model", "opus");
+}
+function ensureMap(parent, key) {
+    const value = parent.get(key, true);
+    if (isMap(value))
+        return value;
+    const map = new YAMLMap();
+    parent.set(key, map);
+    return map;
+}
+function copyMapValue(source, sourceKey, target, targetKey) {
+    if (target.has(targetKey))
+        return;
+    const value = source.get(sourceKey, true);
+    if (value !== undefined)
+        target.set(targetKey, value);
+}
+function setIfMissing(map, key, value) {
+    if (!map.has(key))
+        map.set(key, value);
+}
+function nodeAt(map, path) {
+    let current = map;
+    for (const segment of path) {
+        if (!isMap(current))
+            return undefined;
+        current = current.get(segment, true);
+    }
+    return current;
+}
+function stringNodeValue(value) {
+    if (typeof value === "string")
+        return value;
+    if (isScalar(value) && typeof value.value === "string")
+        return value.value;
+    return undefined;
+}
+function orderProfileKeys(profile) {
+    const priorities = new Map([
+        ["adapter", 0],
+        ["env", 1],
+        ["model", 2],
+        ["reasoning", 3],
+        ["provider_options", 4],
+    ]);
+    profile.items.sort((left, right) => {
+        return profileKeyPriority(left, priorities) - profileKeyPriority(right, priorities);
+    });
+}
+function profileKeyPriority(pair, priorities) {
+    return priorities.get(pairKey(pair)) ?? 100;
+}
+function pairKey(pair) {
+    return stringNodeValue(pair.key) || "";
+}
 function ensureTrailingNewline(content) {
     return content.endsWith("\n") ? content : `${content}\n`;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "git-vibe-setup",
-  "version": "4.0.0",
+  "version": "5.0.0",
   "private": false,
   "type": "module",
   "bin": {
@@ -16,6 +16,9 @@
     "test": "vitest run",
     "typecheck": "tsc --project tsconfig.json --noEmit"
   },
+  "dependencies": {
+    "yaml": "^2.8.4"
+  },
   "devDependencies": {
     "@types/node": "^25.6.0",
     "typescript": "^6.0.3",