@quonfig/cli 0.0.2 → 0.0.5

package/dist/util/token-storage.js

@@ -20,7 +20,10 @@ const ensureQuonfigDir = async (options) => {
 };
 export const saveTokens = async (tokens, options) => {
     await ensureQuonfigDir(options);
-    await fs.promises.writeFile(getTokenFile(options), JSON.stringify(tokens, null, 2), 'utf8');
+    const targetFile = getTokenFile(options);
+    const tmpFile = `${targetFile}.tmp`;
+    await fs.promises.writeFile(tmpFile, JSON.stringify(tokens, null, 2), { encoding: 'utf8', mode: 0o600 });
+    await fs.promises.rename(tmpFile, targetFile);
 };
 export const loadTokens = async (options) => {
     try {
@@ -45,9 +48,16 @@ export const saveAuthConfig = async (config, options) => {
         if (profileData.workspaceName) {
             configContent += ` # ${profileData.workspaceName}`;
         }
-        configContent += '\n\n';
+        configContent += '\n';
+        if (profileData.workspaceSlug) {
+            configContent += `workspace_slug = ${profileData.workspaceSlug}\n`;
+        }
+        configContent += '\n';
     }
-    await fs.promises.writeFile(getConfigFile(options), configContent, 'utf8');
+    const configTarget = getConfigFile(options);
+    const configTmp = `${configTarget}.tmp`;
+    await fs.promises.writeFile(configTmp, configContent, { encoding: 'utf8', mode: 0o600 });
+    await fs.promises.rename(configTmp, configTarget);
 };
 export const loadAuthConfig = async (options) => {
     try {
@@ -60,16 +70,20 @@ export const loadAuthConfig = async (options) => {
         if (defaultMatch && defaultMatch[1]) {
             config.defaultProfile = defaultMatch[1].trim();
         }
-        // Parse profiles
-        const profileRegex = /\[profile\s+(\w+)]\s*\n\s*workspace\s*=\s*([^\s#]+)(?:\s*#\s*(.+))?/g;
+        // Parse profiles — each block starts with [profile name] and contains key=value lines
+        const profileBlockRegex = /\[profile\s+(\w+)]\s*\n((?:[^\[]*\n?)*)/g;
         let match;
-        while ((match = profileRegex.exec(data)) !== null) {
+        while ((match = profileBlockRegex.exec(data)) !== null) {
             const profileName = match[1];
-            const workspace = match[2];
-            const workspaceName = match[3]?.trim();
+            const block = match[2];
+            const workspaceMatch = block.match(/workspace\s*=\s*([^\s#]+)(?:\s*#\s*(.+))?/);
+            const slugMatch = block.match(/workspace_slug\s*=\s*(\S+)/);
+            if (!workspaceMatch)
+                continue;
             config.profiles[profileName] = {
-                workspace,
-                workspaceName,
+                workspace: workspaceMatch[1],
+                workspaceName: workspaceMatch[2]?.trim(),
+                workspaceSlug: slugMatch?.[1]?.trim(),
             };
         }
         return Object.keys(config.profiles).length > 0 ? config : null;

package/dist/verify/validate.d.ts

@@ -36,6 +36,7 @@ export interface ValidationStats {
     rules: number;
     segmentRefsChecked: number;
     schemaRefsChecked: number;
+    envRefsChecked: number;
     uniqueKeysVerified: number;
 }
 export interface ValidationResult {

package/dist/verify/validate.js

@@ -202,6 +202,7 @@ export function validateWorkspace(workspaceDir) {
         rules: 0,
         segmentRefsChecked: 0,
         schemaRefsChecked: 0,
+        envRefsChecked: 0,
         uniqueKeysVerified: 0,
     };
     // Collect all configs for cross-reference checks
@@ -209,6 +210,7 @@ export function validateWorkspace(workspaceDir) {
     const allSchemaFiles = [];
     const segmentKeys = new Set();
     const schemaKeys = new Set();
+    const declaredEnvIds = new Set();
     // Check for unexpected top-level entries
     let entries;
     try {
@@ -238,6 +240,50 @@ export function validateWorkspace(workspaceDir) {
             });
         }
     }
+    // Validate quonfig.json at workspace root
+    const quonfigPath = path.join(workspaceDir, "quonfig.json");
+    if (!fs.existsSync(quonfigPath)) {
+        issues.push({
+            file: "quonfig.json",
+            message: `quonfig.json is missing from workspace root`,
+            severity: "error",
+            suggestion: `Create quonfig.json with format: {"environments": ["production", "staging"]}`,
+        });
+    }
+    else {
+        let quonfigRaw;
+        try {
+            quonfigRaw = fs.readFileSync(quonfigPath, "utf-8");
+        }
+        catch (err) {
+            quonfigRaw = "";
+            issues.push({ file: "quonfig.json", message: `Cannot read quonfig.json: ${err.message}`, severity: "error" });
+        }
+        if (quonfigRaw) {
+            let quonfigParsed;
+            try {
+                quonfigParsed = JSON.parse(quonfigRaw);
+            }
+            catch (err) {
+                quonfigParsed = null;
+                issues.push({ file: "quonfig.json", message: `Invalid JSON: ${err.message}`, severity: "error" });
+            }
+            const quonfigResult = z.object({ environments: z.array(z.string()) }).safeParse(quonfigParsed);
+            if (!quonfigResult.success) {
+                issues.push({
+                    file: "quonfig.json",
+                    message: `quonfig.json must have an "environments" array of strings`,
+                    severity: "error",
+                    suggestion: `Format: {"environments": ["production", "staging"]}`,
+                });
+            }
+            else {
+                for (const envId of quonfigResult.data.environments) {
+                    declaredEnvIds.add(envId);
+                }
+            }
+        }
+    }
     // First pass: parse all files and collect keys
     for (const dir of KNOWN_DIRS) {
         const dirPath = path.join(workspaceDir, dir);
@@ -351,9 +397,9 @@ export function validateWorkspace(workspaceDir) {
             // Validate environment IDs are slugs, not UUIDs
             validateEnvironmentIds(config.environments, relPath, issues);
             // Validate rules
-            validateRules(config.default.rules, relPath, "default", config.valueType, issues);
+            validateRules(config.default.rules, relPath, "default", config.valueType, issues, config.variants);
             for (const env of config.environments) {
-                validateRules(env.rules, relPath, `environments[${env.id}]`, config.valueType, issues);
+                validateRules(env.rules, relPath, `environments[${env.id}]`, config.valueType, issues, config.variants);
             }
             // Count by type
             switch (config.type) {
@@ -435,6 +481,20 @@ export function validateWorkspace(workspaceDir) {
                     });
                 }
             }
+            // Check environment IDs referenced in config exist in quonfig.json
+            if (declaredEnvIds.size > 0) {
+                for (const env of config.environments) {
+                    stats.envRefsChecked++;
+                    if (!declaredEnvIds.has(env.id)) {
+                        issues.push({
+                            file: relPath,
+                            message: `References environment "${env.id}" which is not declared in quonfig.json`,
+                            severity: "error",
+                            suggestion: `Add "${env.id}" to the environments array in quonfig.json, or remove this environment override`,
+                        });
+                    }
+                }
+            }
         }
     }
     // Check for duplicate keys across directories
@@ -479,7 +539,7 @@ function emptyStats() {
     return {
         configs: 0, featureFlags: 0, segments: 0, logLevels: 0, schemas: 0,
         environmentOverrides: 0, rules: 0, segmentRefsChecked: 0,
-        schemaRefsChecked: 0, uniqueKeysVerified: 0,
+        schemaRefsChecked: 0, envRefsChecked: 0, uniqueKeysVerified: 0,
     };
 }
 // ── Validate from in-memory file map (for git hook) ─────────────────────
@@ -495,6 +555,35 @@ export function validateFileMap(files) {
     const allSchemaFiles = [];
     const allConfigs = [];
     const parsedConfigs = [];
+    const declaredEnvIds = new Set();
+    // Validate quonfig.json if it's included in the file map (it may not be in every commit)
+    const quonfigContent = files.get("quonfig.json");
+    if (quonfigContent !== undefined) {
+        let quonfigParsed;
+        try {
+            quonfigParsed = JSON.parse(quonfigContent);
+        }
+        catch (err) {
+            quonfigParsed = null;
+            issues.push({ file: "quonfig.json", message: `Invalid JSON: ${err.message}`, severity: "error" });
+        }
+        if (quonfigParsed !== null) {
+            const quonfigResult = z.object({ environments: z.array(z.string()) }).safeParse(quonfigParsed);
+            if (!quonfigResult.success) {
+                issues.push({
+                    file: "quonfig.json",
+                    message: `quonfig.json must have an "environments" array of strings`,
+                    severity: "error",
+                    suggestion: `Format: {"environments": ["production", "staging"]}`,
+                });
+            }
+            else {
+                for (const envId of quonfigResult.data.environments) {
+                    declaredEnvIds.add(envId);
+                }
+            }
+        }
+    }
     for (const [relPath, content] of files) {
         const parts = relPath.split("/");
         if (parts.length < 2)
@@ -576,9 +665,9 @@ export function validateFileMap(files) {
             issues.push({ file: relPath, message: `Log level must have valueType "log_level", got "${config.valueType}"`, severity: "error" });
         }
         validateEnvironmentIds(config.environments, relPath, issues);
-        validateRules(config.default.rules, relPath, "default", config.valueType, issues);
+        validateRules(config.default.rules, relPath, "default", config.valueType, issues, config.variants);
         for (const env of config.environments) {
-            validateRules(env.rules, relPath, `environments[${env.id}]`, config.valueType, issues);
+            validateRules(env.rules, relPath, `environments[${env.id}]`, config.valueType, issues, config.variants);
         }
         allConfigs.push({ key: config.key, file: relPath });
         parsedConfigs.push({ relPath, config, dir });
@@ -604,6 +693,19 @@ export function validateFileMap(files) {
                 suggestion: `Create schemas/${config.schemaKey}.json or schemas-protected/${config.schemaKey}.json, or remove schemaKey`,
             });
         }
+        // Check environment IDs referenced in config exist in quonfig.json
+        if (declaredEnvIds.size > 0) {
+            for (const env of config.environments) {
+                if (!declaredEnvIds.has(env.id)) {
+                    issues.push({
+                        file: relPath,
+                        message: `References environment "${env.id}" which is not declared in quonfig.json`,
+                        severity: "error",
+                        suggestion: `Add "${env.id}" to the environments array in quonfig.json, or remove this environment override`,
+                    });
+                }
+            }
+        }
     }
     // Duplicate keys
     const keyToFiles = new Map();
@@ -674,10 +776,12 @@ function validateKey(key, file, issues) {
         issues.push({ file, message: `Key contains slash or backslash`, severity: "error" });
     }
 }
-function validateRules(rules, file, context, expectedValueType, issues) {
+function validateRules(rules, file, context, expectedValueType, issues, variants = []) {
     if (rules.length === 0) {
         issues.push({ file, message: `${context}: no rules defined`, severity: "warning" });
     }
+    // Pre-compute serialized variant values for matching
+    const variantValues = variants.map(v => JSON.stringify(v.value));
     for (let i = 0; i < rules.length; i++) {
         const rule = rules[i];
         const ruleCtx = `${context}.rules[${i}]`;
@@ -692,6 +796,18 @@ function validateRules(rules, file, context, expectedValueType, issues) {
                     severity: "error",
                 });
             }
+            // Check that value matches one of the defined variants
+            if (variants.length > 0) {
+                const serialized = JSON.stringify(rule.value);
+                if (!variantValues.includes(serialized)) {
+                    issues.push({
+                        file,
+                        message: `${ruleCtx}: value does not match any defined variant`,
+                        severity: "error",
+                        suggestion: `Rule value must be one of the defined variants`,
+                    });
+                }
+            }
         }
         else if (rule.value.type === "weighted_values") {
             // Validate weighted values
@@ -707,6 +823,18 @@ function validateRules(rules, file, context, expectedValueType, issues) {
                         severity: "error",
                     });
                 }
+                // Check that each weighted value matches one of the defined variants
+                if (variants.length > 0) {
+                    const serialized = JSON.stringify(wv.weightedValues[j].value);
+                    if (!variantValues.includes(serialized)) {
+                        issues.push({
+                            file,
+                            message: `${ruleCtx}.weightedValues[${j}]: value does not match any defined variant`,
+                            severity: "error",
+                            suggestion: `Weighted value must be one of the defined variants`,
+                        });
+                    }
+                }
             }
         }
         // Check criteria
@@ -799,6 +927,8 @@ export function formatResult(result) {
         checks.push(`${s.segmentRefsChecked} segment refs`);
     if (s.schemaRefsChecked > 0)
         checks.push(`${s.schemaRefsChecked} schema refs`);
+    if (s.envRefsChecked > 0)
+        checks.push(`${s.envRefsChecked} env refs`);
     lines.push(`  Checks:      ${checks.join(", ")}`);
     // Group issues by file
     const byFile = new Map();