@minniexcode/codex-switch 0.0.4 → 0.0.6

package/dist/domain/config.js

@@ -33,74 +33,583 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_LINE_ENDING = void 0;
 exports.parseTopLevelProfile = parseTopLevelProfile;
 exports.parseProfileNames = parseProfileNames;
 exports.replaceTopLevelProfile = replaceTopLevelProfile;
+exports.parseStructuredConfig = parseStructuredConfig;
+exports.buildManagedProfileViews = buildManagedProfileViews;
+exports.collectConfigConsistencyIssues = collectConfigConsistencyIssues;
+exports.validateManagedProfileCreation = validateManagedProfileCreation;
+exports.planProfileLifecycleOutcome = planProfileLifecycleOutcome;
+exports.planConfigMutation = planConfigMutation;
+exports.applyPatchOperations = applyPatchOperations;
 const os = __importStar(require("node:os"));
+const errors_1 = require("./errors");
 /**
  * Reads the active top-level profile from config.toml content.
  */
 function parseTopLevelProfile(configContent) {
+    return parseStructuredConfig(configContent).activeProfile;
+}
+/**
+ * Collects all named profile sections declared in config.toml content.
+ */
+function parseProfileNames(configContent) {
+    return new Set(parseStructuredConfig(configContent).profiles.map((profile) => profile.name));
+}
+/**
+ * Replaces or inserts the top-level profile assignment while preserving the rest of the file.
+ */
+function replaceTopLevelProfile(configContent, profile) {
+    const plan = planConfigMutation(parseStructuredConfig(configContent), { setActiveProfile: profile });
+    return applyPatchOperations(configContent, plan.operations);
+}
+/**
+ * Parses the supported config.toml subset into a structured document with stable text ranges.
+ */
+function parseStructuredConfig(configContent) {
+    const lineEnding = configContent.includes("\r\n") ? "\r\n" : "\n";
+    const lines = splitWithOffsets(configContent);
+    let activeProfile = null;
+    let activeProfileRange = null;
+    const profiles = [];
+    const modelProviders = [];
+    let currentProfile = null;
+    let currentModelProvider = null;
     let inRoot = true;
-    for (const line of configContent.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    for (const line of lines) {
+        const trimmed = line.content.trim();
+        const headerMatch = trimmed.match(/^\[profiles\.([^\]]+)\]$/);
+        if (headerMatch) {
+            if (currentProfile) {
+                currentProfile.sectionEnd = line.start;
+            }
+            if (currentModelProvider) {
+                currentModelProvider.sectionEnd = line.start;
+                currentModelProvider = null;
+            }
+            currentProfile = {
+                name: headerMatch[1],
+                headerStart: line.start,
+                sectionStart: line.start,
+                sectionEnd: configContent.length,
+                managedFieldInsertIndex: configContent.length,
+                modelValueRange: null,
+                modelProviderValueRange: null,
+                model: null,
+                modelProvider: null,
+            };
+            profiles.push(currentProfile);
             inRoot = false;
             continue;
         }
-        if (!inRoot || trimmed === "" || trimmed.startsWith("#")) {
+        const modelProviderHeaderMatch = trimmed.match(/^\[model_providers\.([^\]]+)\]$/);
+        if (modelProviderHeaderMatch) {
+            if (currentProfile) {
+                currentProfile.sectionEnd = line.start;
+                currentProfile = null;
+            }
+            if (currentModelProvider) {
+                currentModelProvider.sectionEnd = line.start;
+            }
+            currentModelProvider = {
+                name: modelProviderHeaderMatch[1],
+                sectionStart: line.start,
+                sectionEnd: configContent.length,
+                baseUrlValueRange: null,
+                baseUrl: null,
+            };
+            modelProviders.push(currentModelProvider);
+            inRoot = false;
             continue;
         }
-        const match = trimmed.match(/^profile\s*=\s*["']([^"']+)["']/);
-        if (match) {
-            return match[1];
+        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+            if (currentProfile) {
+                currentProfile.sectionEnd = line.start;
+                currentProfile = null;
+            }
+            if (currentModelProvider) {
+                currentModelProvider.sectionEnd = line.start;
+                currentModelProvider = null;
+            }
+            inRoot = false;
+            continue;
+        }
+        if (inRoot) {
+            const profileMatch = matchKeyValueLine(line.content, "profile");
+            if (profileMatch && !activeProfile) {
+                activeProfile = profileMatch.value;
+                activeProfileRange = {
+                    start: line.start + profileMatch.valueStart,
+                    end: line.start + profileMatch.valueEnd,
+                };
+            }
+        }
+        if (currentProfile) {
+            const modelMatch = matchKeyValueLine(line.content, "model");
+            if (modelMatch) {
+                currentProfile.model = modelMatch.value;
+                currentProfile.modelValueRange = {
+                    start: line.start + modelMatch.valueStart,
+                    end: line.start + modelMatch.valueEnd,
+                };
+            }
+            const modelProviderMatch = matchKeyValueLine(line.content, "model_provider");
+            if (modelProviderMatch) {
+                currentProfile.modelProvider = modelProviderMatch.value;
+                currentProfile.modelProviderValueRange = {
+                    start: line.start + modelProviderMatch.valueStart,
+                    end: line.start + modelProviderMatch.valueEnd,
+                };
+            }
+        }
+        if (currentModelProvider) {
+            const baseUrlMatch = matchKeyValueLine(line.content, "base_url");
+            if (baseUrlMatch) {
+                currentModelProvider.baseUrl = baseUrlMatch.value;
+                currentModelProvider.baseUrlValueRange = {
+                    start: line.start + baseUrlMatch.valueStart,
+                    end: line.start + baseUrlMatch.valueEnd,
+                };
+            }
         }
     }
-    return null;
+    return {
+        rawText: configContent,
+        lineEnding,
+        activeProfile,
+        activeProfileRange,
+        profiles: profiles.map((profile) => ({
+            ...profile,
+            managedFieldInsertIndex: findManagedFieldInsertIndex(configContent, profile.sectionStart, profile.sectionEnd),
+        })),
+        modelProviders,
+    };
 }
 /**
- * Collects all named profile sections declared in config.toml content.
+ * Builds the managed/unmanaged/orphaned profile views used by config commands and diagnostics.
  */
-function parseProfileNames(configContent) {
-    const result = new Set();
-    for (const line of configContent.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        const match = trimmed.match(/^\[profiles\.([^\]]+)\]$/);
-        if (match) {
-            result.add(match[1]);
+function buildManagedProfileViews(document, providers) {
+    const linkMap = buildProfileLinkMap(providers);
+    const modelProviderMap = new Map(document.modelProviders.map((provider) => [provider.name, provider]));
+    const views = [];
+    const seen = new Set();
+    for (const section of document.profiles) {
+        const linkInfo = linkMap.get(section.name) ?? { linkedProviders: [], managed: false };
+        const modelProviderSection = section.modelProvider ? modelProviderMap.get(section.modelProvider) ?? null : null;
+        seen.add(section.name);
+        views.push({
+            name: section.name,
+            managed: linkInfo.managed,
+            isActive: document.activeProfile === section.name,
+            linkedProviders: [...linkInfo.linkedProviders].sort(),
+            model: section.model,
+            modelProvider: section.modelProvider,
+            baseUrl: modelProviderSection?.baseUrl ?? null,
+            managedFields: collectManagedFields(section.model, section.modelProvider),
+            source: linkInfo.managed ? "managed" : "unmanaged",
+        });
+    }
+    for (const [profile, linkInfo] of [...linkMap.entries()].sort(([left], [right]) => left.localeCompare(right))) {
+        if (seen.has(profile)) {
+            continue;
         }
+        views.push({
+            name: profile,
+            managed: true,
+            isActive: document.activeProfile === profile,
+            linkedProviders: [...linkInfo.linkedProviders].sort(),
+            model: null,
+            modelProvider: null,
+            baseUrl: null,
+            managedFields: [],
+            source: "orphaned-reference",
+        });
     }
-    return result;
+    return views.sort((left, right) => left.name.localeCompare(right.name));
 }
 /**
- * Replaces or inserts the top-level profile assignment while preserving the rest of the file.
+ * Collects structured config consistency issues for doctor and status.
  */
-function replaceTopLevelProfile(configContent, profile) {
-    const lines = configContent.split(/\r?\n/);
-    let inRoot = true;
-    let replaced = false;
-    const nextLines = lines.map((line) => {
-        const trimmed = line.trim();
-        if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-            // Only the root section may contain the active `profile = ...` switch.
-            inRoot = false;
-            return line;
+function collectConfigConsistencyIssues(document, providers) {
+    const issues = [];
+    for (const view of buildManagedProfileViews(document, providers)) {
+        if (view.source === "orphaned-reference") {
+            issues.push({
+                code: "ORPHANED_PROFILE_REFERENCE",
+                profile: view.name,
+                providers: [...view.linkedProviders],
+            });
+        }
+        if (view.source === "unmanaged" && view.linkedProviders.length === 0) {
+            issues.push({
+                code: "ORPHANED_PROFILE_SECTION",
+                profile: view.name,
+            });
+        }
+        if (view.linkedProviders.length > 1) {
+            issues.push({
+                code: "SHARED_PROFILE_REFERENCE",
+                profile: view.name,
+                providers: [...view.linkedProviders],
+            });
+        }
+        if (view.source !== "orphaned-reference") {
+            if (!view.modelProvider) {
+                issues.push({
+                    code: "MODEL_PROVIDER_MISSING",
+                    profile: view.name,
+                });
+            }
+            else {
+                if (view.modelProvider !== view.name) {
+                    issues.push({
+                        code: "MODEL_PROVIDER_NAME_MISMATCH",
+                        profile: view.name,
+                        modelProvider: view.modelProvider,
+                    });
+                }
+                const modelProviderSection = document.modelProviders.find((entry) => entry.name === view.modelProvider);
+                if (!modelProviderSection) {
+                    issues.push({
+                        code: "MODEL_PROVIDER_SECTION_MISSING",
+                        profile: view.name,
+                        modelProvider: view.modelProvider,
+                    });
+                }
+                else if (!modelProviderSection.baseUrl) {
+                    issues.push({
+                        code: "MODEL_PROVIDER_BASE_URL_MISSING",
+                        profile: view.name,
+                        modelProvider: view.modelProvider,
+                    });
+                }
+            }
         }
-        if (!replaced && inRoot && /^profile\s*=/.test(trimmed)) {
-            replaced = true;
-            return `profile = "${profile}"`;
+    }
+    if (document.activeProfile) {
+        const activeLinkInfo = buildProfileLinkMap(providers).get(document.activeProfile);
+        if (!activeLinkInfo) {
+            issues.push({
+                code: "UNMANAGED_ACTIVE_PROFILE",
+                profile: document.activeProfile,
+            });
+        }
+    }
+    return issues.sort((left, right) => {
+        if (left.profile === right.profile) {
+            return left.code.localeCompare(right.code);
         }
-        return line;
+        return left.profile.localeCompare(right.profile);
     });
-    if (!replaced) {
-        // When no root-level profile exists yet, insert it before the first section header.
-        const insertAt = nextLines.findIndex((line) => line.trim().startsWith("["));
-        if (insertAt === -1) {
-            nextLines.push(`profile = "${profile}"`);
+}
+/**
+ * Ensures the minimal managed profile fields are available before a new section is created.
+ */
+function validateManagedProfileCreation(profile, fields) {
+    const model = fields.model?.trim() ?? "";
+    const modelProvider = fields.modelProvider?.trim() ?? "";
+    if (!model || !modelProvider) {
+        throw (0, errors_1.cliError)("MANAGED_PROFILE_FIELDS_MISSING", `Managed profile "${profile}" requires both model and model_provider.`, {
+            profile,
+            missingFields: [
+                !model ? "model" : null,
+                !modelProvider ? "model_provider" : null,
+            ].filter((value) => Boolean(value)),
+        });
+    }
+    return {
+        model,
+        modelProvider,
+    };
+}
+/**
+ * Computes keep/delete/switch outcomes when a provider leaves or changes profiles.
+ */
+function planProfileLifecycleOutcome(args) {
+    if (!args.oldProfile || args.oldProfile === args.newProfile) {
+        return {
+            deletedProfileSections: [],
+            keptSharedProfiles: [],
+            switchedActiveProfile: false,
+            nextActiveProfile: args.activeProfile,
+        };
+    }
+    const remainingLinks = args.remainingLinksByProfile.get(args.oldProfile) ?? [];
+    if (remainingLinks.length > 0) {
+        return {
+            deletedProfileSections: [],
+            keptSharedProfiles: [args.oldProfile],
+            switchedActiveProfile: false,
+            nextActiveProfile: args.activeProfile,
+        };
+    }
+    if (args.activeProfile === args.oldProfile) {
+        if (!args.switchToProfile) {
+            throw (0, errors_1.cliError)("PROFILE_IN_USE", `Profile "${args.oldProfile}" is still the active profile. Switch first before removing the last linked provider.`, {
+                profile: args.oldProfile,
+                provider: args.providerName,
+                activeProfile: args.activeProfile,
+                linkedProviders: [],
+            });
+        }
+        return {
+            deletedProfileSections: [args.oldProfile],
+            keptSharedProfiles: [],
+            switchedActiveProfile: true,
+            nextActiveProfile: args.switchToProfile,
+        };
+    }
+    return {
+        deletedProfileSections: [args.oldProfile],
+        keptSharedProfiles: [],
+        switchedActiveProfile: false,
+        nextActiveProfile: args.activeProfile,
+    };
+}
+/**
+ * Builds a text patch plan for top-level profile changes and profile section lifecycle changes.
+ */
+function planConfigMutation(document, args) {
+    const operations = [];
+    const createdProfileSections = [];
+    const deletedProfileSections = [];
+    const updatedProfiles = [];
+    const sectionMap = new Map(document.profiles.map((profile) => [profile.name, profile]));
+    if (args.setActiveProfile && args.setActiveProfile !== document.activeProfile) {
+        const quoted = `"${args.setActiveProfile}"`;
+        if (document.activeProfileRange) {
+            operations.push({
+                kind: "replace-range",
+                start: document.activeProfileRange.start,
+                end: document.activeProfileRange.end,
+                text: quoted,
+            });
+        }
+        else {
+            const insertAt = findTopLevelInsertIndex(document.rawText);
+            const text = `profile = ${quoted}${document.lineEnding}`;
+            operations.push({
+                kind: "insert-at",
+                index: insertAt,
+                text,
+            });
+        }
+    }
+    for (const profileName of args.deleteProfiles ?? []) {
+        const section = sectionMap.get(profileName);
+        if (!section) {
+            continue;
+        }
+        operations.push({
+            kind: "delete-range",
+            start: section.sectionStart,
+            end: expandDeletionEnd(document.rawText, section.sectionStart, section.sectionEnd),
+        });
+        deletedProfileSections.push(profileName);
+    }
+    for (const [profileName, fields] of Object.entries(args.upsertProfiles ?? {}).sort(([left], [right]) => left.localeCompare(right))) {
+        const section = sectionMap.get(profileName);
+        if (!section) {
+            const requiredFields = validateManagedProfileCreation(profileName, fields);
+            const prefix = document.rawText.length > 0 && !document.rawText.endsWith(document.lineEnding)
+                ? document.lineEnding
+                : "";
+            operations.push({
+                kind: "insert-at",
+                index: document.rawText.length,
+                text: `${prefix}[profiles.${profileName}]${document.lineEnding}` +
+                    `model = ${JSON.stringify(requiredFields.model)}${document.lineEnding}` +
+                    `model_provider = ${JSON.stringify(requiredFields.modelProvider)}${document.lineEnding}`,
+            });
+            createdProfileSections.push(profileName);
+            continue;
+        }
+        const sectionUpdated = planSectionFieldMutation(document, section, fields, operations);
+        if (sectionUpdated) {
+            updatedProfiles.push(profileName);
+        }
+    }
+    return {
+        operations,
+        createdProfileSections,
+        deletedProfileSections,
+        updatedProfiles,
+        switchedActiveProfile: Boolean(args.setActiveProfile && args.setActiveProfile !== document.activeProfile),
+    };
+}
+/**
+ * Applies a patch plan to raw config text. Callers should sort by reverse offsets only once here.
+ */
+function applyPatchOperations(rawText, operations) {
+    const sorted = [...operations].sort((left, right) => getOperationStart(right) - getOperationStart(left));
+    let nextText = rawText;
+    for (const operation of sorted) {
+        if (operation.kind === "replace-range") {
+            nextText = `${nextText.slice(0, operation.start)}${operation.text}${nextText.slice(operation.end)}`;
+            continue;
+        }
+        if (operation.kind === "delete-range") {
+            nextText = `${nextText.slice(0, operation.start)}${nextText.slice(operation.end)}`;
+            continue;
+        }
+        nextText = `${nextText.slice(0, operation.index)}${operation.text}${nextText.slice(operation.index)}`;
+    }
+    return nextText;
+}
+function planSectionFieldMutation(document, section, fields, operations) {
+    let updated = false;
+    const modelText = fields.model !== undefined ? JSON.stringify(fields.model) : null;
+    const modelProviderText = fields.modelProvider !== undefined ? JSON.stringify(fields.modelProvider) : null;
+    const inserts = [];
+    if (modelText !== null && section.modelValueRange) {
+        if (section.model !== fields.model) {
+            operations.push({
+                kind: "replace-range",
+                start: section.modelValueRange.start,
+                end: section.modelValueRange.end,
+                text: modelText,
+            });
+            updated = true;
+        }
+    }
+    else if (modelText !== null && !section.modelValueRange) {
+        inserts.push(`model = ${modelText}${document.lineEnding}`);
+        updated = true;
+    }
+    if (modelProviderText !== null && section.modelProviderValueRange) {
+        if (section.modelProvider !== fields.modelProvider) {
+            operations.push({
+                kind: "replace-range",
+                start: section.modelProviderValueRange.start,
+                end: section.modelProviderValueRange.end,
+                text: modelProviderText,
+            });
+            updated = true;
+        }
+    }
+    else if (modelProviderText !== null && !section.modelProviderValueRange) {
+        inserts.push(`model_provider = ${modelProviderText}${document.lineEnding}`);
+        updated = true;
+    }
+    if (inserts.length > 0) {
+        operations.push({
+            kind: "insert-at",
+            index: section.managedFieldInsertIndex,
+            text: inserts.join(""),
+        });
+    }
+    return updated;
+}
+function splitWithOffsets(value) {
+    if (value.length === 0) {
+        return [];
+    }
+    const result = [];
+    let index = 0;
+    while (index < value.length) {
+        let nextBreak = value.indexOf("\n", index);
+        if (nextBreak === -1) {
+            nextBreak = value.length;
         }
         else {
-            nextLines.splice(insertAt, 0, `profile = "${profile}"`);
+            nextBreak += 1;
+        }
+        result.push({
+            content: value.slice(index, nextBreak).replace(/\r?\n$/, ""),
+            start: index,
+            end: nextBreak,
+        });
+        index = nextBreak;
+    }
+    return result;
+}
+function matchKeyValueLine(line, key) {
+    const match = line.match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*(["'])(.*?)\\1\\s*(#.*)?$`));
+    if (!match || match.index === undefined) {
+        return null;
+    }
+    const value = match[2];
+    const openingQuoteIndex = line.indexOf(match[1], match.index);
+    if (openingQuoteIndex === -1) {
+        return null;
+    }
+    const valueStart = openingQuoteIndex;
+    const valueEnd = openingQuoteIndex + match[1].length + value.length + match[1].length;
+    return {
+        value,
+        valueStart,
+        valueEnd,
+    };
+}
+function findManagedFieldInsertIndex(rawText, sectionStart, sectionEnd) {
+    const sectionText = rawText.slice(sectionStart, sectionEnd);
+    const lines = splitWithOffsets(sectionText);
+    let lastMeaningfulIndex = lines.length - 1;
+    while (lastMeaningfulIndex >= 0) {
+        const trimmed = lines[lastMeaningfulIndex].content.trim();
+        if (trimmed === "" || trimmed.startsWith("#")) {
+            lastMeaningfulIndex -= 1;
+            continue;
+        }
+        break;
+    }
+    if (lastMeaningfulIndex < 0) {
+        return sectionEnd;
+    }
+    return sectionStart + lines[lastMeaningfulIndex].end;
+}
+function collectManagedFields(model, modelProvider) {
+    const fields = [];
+    if (model !== null) {
+        fields.push("model");
+    }
+    if (modelProvider !== null) {
+        fields.push("model_provider");
+    }
+    return fields;
+}
+function buildProfileLinkMap(providers) {
+    const map = new Map();
+    for (const [providerName, provider] of Object.entries(providers?.providers ?? {})) {
+        const current = map.get(provider.profile) ?? { linkedProviders: [], managed: true };
+        current.linkedProviders.push(providerName);
+        current.managed = true;
+        map.set(provider.profile, current);
+    }
+    for (const value of map.values()) {
+        value.linkedProviders.sort();
+    }
+    return map;
+}
+function getOperationStart(operation) {
+    if (operation.kind === "insert-at") {
+        return operation.index;
+    }
+    return operation.start;
+}
+function findTopLevelInsertIndex(rawText) {
+    const sectionMatch = rawText.match(/^\s*\[/m);
+    return sectionMatch && sectionMatch.index !== undefined ? sectionMatch.index : rawText.length;
+}
+function expandDeletionEnd(rawText, sectionStart, sectionEnd) {
+    let end = sectionEnd;
+    while (end < rawText.length && (rawText[end] === "\r" || rawText[end] === "\n")) {
+        end += 1;
+    }
+    if (sectionStart > 0) {
+        let cursor = sectionStart - 1;
+        while (cursor >= 0 && (rawText[cursor] === "\r" || rawText[cursor] === "\n")) {
+            cursor -= 1;
+        }
+        if (cursor < sectionStart - 1) {
+            return end;
         }
     }
-    return nextLines.join(os.EOL);
+    return end;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+exports.DEFAULT_LINE_ENDING = os.EOL === "\r\n" ? "\r\n" : "\n";