@quonfig/cli 0.0.1 → 0.0.4

package/dist/util/token-storage.js

@@ -1,8 +1,13 @@
 import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
+import { getDomain } from './domain-urls.js';
 const getQuonfigDir = (options) => options?.quonfigDir || path.join(os.homedir(), '.quonfig');
-const getTokenFile = (options) => path.join(getQuonfigDir(options), 'tokens.json');
+const getTokenFile = (options) => {
+    const domain = getDomain();
+    const filename = domain !== 'quonfig.com' ? `tokens-${domain.replaceAll('.', '-')}.json` : 'tokens.json';
+    return path.join(getQuonfigDir(options), filename);
+};
 const getConfigFile = (options) => path.join(getQuonfigDir(options), 'config');
 const ensureQuonfigDir = async (options) => {
     const quonfigDir = getQuonfigDir(options);
@@ -15,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 {
@@ -40,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 {
@@ -55,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

@@ -26,10 +26,24 @@ export interface ValidationIssue {
     severity: Severity;
     suggestion?: string;
 }
+export interface ValidationStats {
+    configs: number;
+    featureFlags: number;
+    segments: number;
+    logLevels: number;
+    schemas: number;
+    environmentOverrides: number;
+    rules: number;
+    segmentRefsChecked: number;
+    schemaRefsChecked: number;
+    envRefsChecked: number;
+    uniqueKeysVerified: number;
+}
 export interface ValidationResult {
     issues: ValidationIssue[];
     filesChecked: number;
     valid: boolean;
+    stats: ValidationStats;
 }
 /**
  * Validate an entire workspace directory on disk.

package/dist/verify/validate.js

@@ -192,11 +192,25 @@ import * as path from "node:path";
 export function validateWorkspace(workspaceDir) {
     const issues = [];
     let filesChecked = 0;
+    const stats = {
+        configs: 0,
+        featureFlags: 0,
+        segments: 0,
+        logLevels: 0,
+        schemas: 0,
+        environmentOverrides: 0,
+        rules: 0,
+        segmentRefsChecked: 0,
+        schemaRefsChecked: 0,
+        envRefsChecked: 0,
+        uniqueKeysVerified: 0,
+    };
     // Collect all configs for cross-reference checks
     const allConfigs = [];
     const allSchemaFiles = [];
     const segmentKeys = new Set();
     const schemaKeys = new Set();
+    const declaredEnvIds = new Set();
     // Check for unexpected top-level entries
     let entries;
     try {
@@ -211,6 +225,7 @@ export function validateWorkspace(workspaceDir) {
                 }],
             filesChecked: 0,
             valid: false,
+            stats,
         };
     }
     for (const entry of entries) {
@@ -225,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);
@@ -272,6 +331,7 @@ export function validateWorkspace(workspaceDir) {
                 schemaKeys.add(schemaKey);
                 validateKey(schemaKey, relPath, issues);
                 allSchemaFiles.push({ key: schemaKey, file: relPath });
+                stats.schemas++;
                 continue;
             }
             // Validate against StoredConfigSchema
@@ -337,16 +397,33 @@ 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, config.variants);
+            }
+            // Count by type
+            switch (config.type) {
+                case "config":
+                    stats.configs++;
+                    break;
+                case "feature_flag":
+                    stats.featureFlags++;
+                    break;
+                case "segment":
+                    stats.segments++;
+                    break;
+                case "log_level":
+                    stats.logLevels++;
+                    break;
+            }
+            // Count rules and environment overrides
+            stats.rules += config.default.rules.length;
+            stats.environmentOverrides += config.environments.length;
             for (const env of config.environments) {
-                validateRules(env.rules, relPath, `environments[${env.id}]`, config.valueType, issues);
+                stats.rules += env.rules.length;
             }
             // Collect for cross-reference
             allConfigs.push({ key: config.key, type: config.type, dir, file: relPath });
-            // Check schemaKey reference (collected, validated in second pass)
-            if (config.schemaKey) {
-                // Will be checked after all files are parsed
-            }
         }
     }
     // Second pass: referential integrity
@@ -382,6 +459,7 @@ export function validateWorkspace(workspaceDir) {
             // Check segment references in criteria
             const segRefs = collectSegmentReferences(config);
             for (const ref of segRefs) {
+                stats.segmentRefsChecked++;
                 if (!segmentKeys.has(ref)) {
                     issues.push({
                         file: relPath,
@@ -392,13 +470,30 @@ export function validateWorkspace(workspaceDir) {
                 }
             }
             // Check schemaKey references
-            if (config.schemaKey && !schemaKeys.has(config.schemaKey)) {
-                issues.push({
-                    file: relPath,
-                    message: `References schema "${config.schemaKey}" which does not exist`,
-                    severity: "error",
-                    suggestion: `Create schemas/${config.schemaKey}.json or schemas-protected/${config.schemaKey}.json, or remove schemaKey`,
-                });
+            if (config.schemaKey) {
+                stats.schemaRefsChecked++;
+                if (!schemaKeys.has(config.schemaKey)) {
+                    issues.push({
+                        file: relPath,
+                        message: `References schema "${config.schemaKey}" which does not exist`,
+                        severity: "error",
+                        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) {
+                    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`,
+                        });
+                    }
+                }
             }
         }
     }
@@ -435,8 +530,17 @@ export function validateWorkspace(workspaceDir) {
             });
         }
     }
+    stats.uniqueKeysVerified = keyToFiles.size + schemaKeyToFiles.size;
     const hasErrors = issues.some(i => i.severity === "error");
-    return { issues, filesChecked, valid: !hasErrors };
+    return { issues, filesChecked, valid: !hasErrors, stats };
+}
+// Default empty stats for validateFileMap (which doesn't track detailed stats)
+function emptyStats() {
+    return {
+        configs: 0, featureFlags: 0, segments: 0, logLevels: 0, schemas: 0,
+        environmentOverrides: 0, rules: 0, segmentRefsChecked: 0,
+        schemaRefsChecked: 0, envRefsChecked: 0, uniqueKeysVerified: 0,
+    };
 }
 // ── Validate from in-memory file map (for git hook) ─────────────────────
 /**
@@ -451,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)
@@ -532,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 });
@@ -560,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();
@@ -593,7 +739,7 @@ export function validateFileMap(files) {
         }
     }
     const hasErrors = issues.some(i => i.severity === "error");
-    return { issues, filesChecked, valid: !hasErrors };
+    return { issues, filesChecked, valid: !hasErrors, stats: emptyStats() };
 }
 // ── Helpers ─────────────────────────────────────────────────────────────
 function validateEnvironmentIds(environments, file, issues) {
@@ -630,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}]`;
@@ -648,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
@@ -663,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
@@ -720,14 +892,44 @@ function typeToDir(type) {
 // ── Output formatting ───────────────────────────────────────────────────
 export function formatResult(result) {
     const lines = [];
+    const s = result.stats;
     if (result.valid) {
-        lines.push(`OK: ${result.filesChecked} files checked, no errors found.`);
+        lines.push(`OK: ${result.filesChecked} files checked, no errors found.\n`);
     }
     else {
         const errors = result.issues.filter(i => i.severity === "error");
         const warnings = result.issues.filter(i => i.severity === "warning");
         lines.push(`FAILED: ${errors.length} error(s), ${warnings.length} warning(s) in ${result.filesChecked} files.\n`);
     }
+    // Show what was checked
+    const fileCounts = [];
+    if (s.configs > 0)
+        fileCounts.push(`${s.configs} configs`);
+    if (s.featureFlags > 0)
+        fileCounts.push(`${s.featureFlags} feature flags`);
+    if (s.segments > 0)
+        fileCounts.push(`${s.segments} segments`);
+    if (s.logLevels > 0)
+        fileCounts.push(`${s.logLevels} log levels`);
+    if (s.schemas > 0)
+        fileCounts.push(`${s.schemas} schemas`);
+    if (fileCounts.length > 0) {
+        lines.push(`  Files:       ${fileCounts.join(", ")}`);
+    }
+    const checks = [];
+    checks.push(`${result.filesChecked} JSON parsed`);
+    checks.push(`${result.filesChecked} schema-validated`);
+    checks.push(`${s.uniqueKeysVerified} unique keys`);
+    checks.push(`${s.rules} rules checked`);
+    if (s.environmentOverrides > 0)
+        checks.push(`${s.environmentOverrides} env overrides`);
+    if (s.segmentRefsChecked > 0)
+        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();
     for (const issue of result.issues) {
@@ -735,6 +937,9 @@ export function formatResult(result) {
         existing.push(issue);
         byFile.set(issue.file, existing);
     }
+    if (byFile.size > 0) {
+        lines.push("");
+    }
     for (const [file, fileIssues] of byFile) {
         lines.push(`  ${file}:`);
         for (const issue of fileIssues) {