git-vibe-setup 4.1.0 → 5.1.1

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/install.js

@@ -1,5 +1,6 @@
 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/investigate.yml",
@@ -91,7 +92,9 @@ export function pinWorkflowReleaseRefs(content, releaseTag) {
 }
 export function migrateGitVibeConfigContent(content) {
     const migratedComments = migrateLegacyEventDeliveryComments(content);
-    return ensureTrailingNewline(migrateGithubAuthConfig(migratedComments));
+    const migratedAuth = migrateGithubAuthConfig(migratedComments);
+    const migratedSafety = migratePromptInjectionSafetyConfig(migratedAuth);
+    return ensureTrailingNewline(migrateLegacyAiProfiles(migratedSafety));
 }
 function isManagedWorkflowTarget(file) {
     return isManagedWorkflowFile(file.targetPath, basename(file.targetPath));
@@ -260,6 +263,154 @@ function migrateGithubAuthConfig(content) {
     }
     return `${content.trimEnd()}\n\n${githubAppAuth}`;
 }
+function migratePromptInjectionSafetyConfig(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) || root.has("safety"))
+        return content;
+    return `${content.trimEnd()}\n\nsafety:\n  prompt_injection_gate: true\n`;
+}
+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.1.0",
+  "version": "5.1.1",
   "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",