@quonfig/cli 0.0.48 → 0.0.50

package/dist/migrate/sources/launchdarkly/translate.js

@@ -26,6 +26,26 @@ function slugifyEnvKey(key) {
         .replaceAll(/[^\da-z]+/g, '-')
         .replaceAll(/^-+|-+$/g, '');
 }
+/**
+ * Gather every prerequisite edge declared across all of a flag's environments
+ * and dedupe by parent key — the orphan-parent view is per-flag, not
+ * per-environment. First occurrence wins for the variation index when an
+ * unusual config gates on the same parent at different variations in different
+ * envs (rare; the typical case is identical edges in every env).
+ */
+function collectPrerequisiteEdges(flag) {
+    const seen = new Set();
+    const edges = [];
+    for (const envState of Object.values(flag.environments)) {
+        for (const prereq of envState.prerequisites ?? []) {
+            if (seen.has(prereq.key))
+                continue;
+            seen.add(prereq.key);
+            edges.push({ parentKey: prereq.key, variation: prereq.variation });
+        }
+    }
+    return edges;
+}
 export function flagOutputPath(key) {
     return `feature-flags/${normalizeKey(key)}.json`;
 }
@@ -54,9 +74,16 @@ export function translateFlag(flag, report) {
     };
     // clientSideAvailability: feature flags are always client-visible in Quonfig,
     // so `sendToClientSdk` is invalid on them — we cannot carry the dimension.
-    // Report the mobile-key drop rather than silently losing it.
+    // Split the drop by usingEnvironmentId co-state (qfg-iv69):
+    //  - usingEnvironmentId:true  → flag is still client-visible, pure rollup noise.
+    //  - usingEnvironmentId:false → flag was mobile-only, now server-only post-migration (must-fix).
     if (flag.clientSideAvailability?.usingMobileKey) {
-        report.add('dropped-mobile-key-availability', flag.key, `clientSideAvailability.usingMobileKey was true — Quonfig has one client-visibility bool, the mobile-key dimension is dropped`);
+        if (flag.clientSideAvailability.usingEnvironmentId) {
+            report.add('dropped-mobile-key-still-visible', flag.key, `clientSideAvailability.usingMobileKey was true; usingEnvironmentId was also true — flag remains client-visible via Quonfig's sendToClientSdk, the mobile-key dimension itself is dropped`);
+        }
+        else {
+            report.add('dropped-mobile-key-now-server-only', flag.key, `clientSideAvailability.usingMobileKey was true but usingEnvironmentId was false — flag was mobile-only in LaunchDarkly and will not reach mobile clients post-migration; rebuild client-side access by hand before cutover`);
+        }
     }
     if (flag.maintainerId || flag.maintainerTeamKey) {
         report.add('dropped-maintainer', flag.key, `maintainer ${flag.maintainerId ?? flag.maintainerTeamKey} dropped — Quonfig authorship lives in git history`);
@@ -64,6 +91,19 @@ export function translateFlag(flag, report) {
     if (flag.customProperties && Object.keys(flag.customProperties).length > 0) {
         report.add('dropped-custom-properties', flag.key, `customProperties (${Object.keys(flag.customProperties).join(', ')}) dropped — report-only in v1 (D6)`);
     }
+    // Prerequisites — dedupe across environments by parent key so a flag gated on
+    // the same parent in N environments emits one note, not N (qfg-nb4n). The
+    // detail spells out every parent's variation index plus a one-line remediation
+    // so a human knows exactly how to restore the gate; the structured
+    // `prerequisites` payload feeds the inverted orphan-parent view in the report.
+    const prereqEdges = collectPrerequisiteEdges(flag);
+    if (prereqEdges.length > 0) {
+        const parentList = prereqEdges.map((e) => `\`${e.parentKey}\` = variation ${e.variation}`).join(', ');
+        const detail = `evaluated independently of ${prereqEdges.length} parent${prereqEdges.length === 1 ? '' : 's'} ` +
+            `(${parentList}). To preserve the gate, add a leading rule matching the same parent state, ` +
+            `or wrap reads in app code — Quonfig v1 has no cross-flag dependency operator.`;
+        report.add('dropped-prerequisite', flag.key, detail, { prerequisites: prereqEdges });
+    }
     const variants = flag.variations.map((v) => {
         const variant = {
             value: toQuonfigValue(v.value, valueType),

package/dist/migrate/sources/launchdarkly/types.d.ts

@@ -173,6 +173,25 @@ export interface LDContextKindsResponse {
         name?: string;
     }>;
 }
+/**
+ * One row from `GET /members` — only the fields the migrator surfaces are
+ * typed. `_id` is what flag JSON references as `maintainerId`; `email` is the
+ * human-readable label we resolve into MIGRATION_REPORT.md.
+ */
+export interface LDMember {
+    _id: string;
+    email?: string;
+}
+/** `GET /members` — offset-paginated. */
+export interface LDMembersResponse {
+    _links?: {
+        next?: {
+            href: string;
+        };
+    };
+    items: LDMember[];
+    totalCount?: number;
+}
 /**
  * The full Phase-1 config snapshot — what the fetcher stitches together and
  * what `translate()` consumes. One of these is produced per migration run.

package/dist/migrate/sources/launchdarkly.js

@@ -12,7 +12,7 @@ import * as fs from 'node:fs';
 import * as os from 'node:os';
 import * as path from 'node:path';
 import { ConversionReport } from '../quonfig-target/report.js';
-import { fetchProjectEnvironments, fetchSegmentsForEnv, fetchSnapshot } from './launchdarkly/api.js';
+import { fetchMembers, fetchProjectEnvironments, fetchProjectEnvironmentsDetailed, fetchSegmentsForEnv, fetchSnapshot, } from './launchdarkly/api.js';
 import { auditEntryToLegacyChange, buildFlagAuditSpec, getCommitMetaForAuditEntry, probeRetentionHorizon, walkAuditLog, } from './launchdarkly/audit.js';
 import { flagOutputPath, segmentOutputPath, translateFlag, translateSegment } from './launchdarkly/translate.js';
 const SOURCE_NAME = 'launchdarkly';
@@ -39,7 +39,9 @@ function resolveProjectKey() {
 const state = {
     apiKey: null,
     environments: [],
+    environmentSourceNames: [],
     fullSummary: false,
+    maintainerMap: null,
     projectKey: resolveProjectKey(),
     report: new ConversionReport(),
     retentionHorizon: null,
@@ -89,11 +91,15 @@ function slugifyEnvKey(key) {
 }
 async function validateAuthImpl(apiKey) {
     // A cheap authenticated call — 401s on a bad token, 404s on a bad project.
-    await fetchProjectEnvironments(apiKey, state.projectKey);
+    // Use the detailed call so we can stash {key, name} for the report's env
+    // mapping table (qfg-1t7m) without a second round-trip.
+    const detailed = await fetchProjectEnvironmentsDetailed(apiKey, state.projectKey);
     state.apiKey = apiKey;
     state.report = new ConversionReport();
     state.environments = [];
+    state.environmentSourceNames = detailed;
     state.retentionHorizon = null;
+    state.maintainerMap = null;
     // Plan §4.1.1: under --full-summary, probe the audit-log retention window
     // here — the earliest authenticated hook — so the command can tell the user
     // the real history horizon BEFORE the slow Phase-2 walk starts. The walk can
@@ -103,10 +109,33 @@ async function validateAuthImpl(apiKey) {
         state.retentionHorizon = await probeRetentionHorizon(apiKey, { spec: buildFlagAuditSpec(state.projectKey) });
     }
 }
+/**
+ * qfg-l8uz: best-effort `/members` lookup so MIGRATION_REPORT.md can render
+ * `maintainerId → email`. Project-scoped tokens or accounts that hide member
+ * data will 403 here — that's fine, the migration must not fail just because
+ * the rollup loses a label. Returns null on any error, the empty map when the
+ * endpoint returns no members, and a stripped map otherwise (members without
+ * an email are skipped — we have nothing useful to render for them).
+ */
+async function loadMaintainerMap(apiKey) {
+    try {
+        const members = await fetchMembers(apiKey);
+        const map = {};
+        for (const member of members) {
+            if (member.email)
+                map[member._id] = member.email;
+        }
+        return map;
+    }
+    catch {
+        return null;
+    }
+}
 async function listEnvironmentsImpl() {
     const apiKey = requireApiKey('listEnvironments');
-    const envKeys = await fetchProjectEnvironments(apiKey, state.projectKey);
-    state.environments = envKeys.map((k) => slugifyEnvKey(k));
+    const detailed = await fetchProjectEnvironmentsDetailed(apiKey, state.projectKey);
+    state.environmentSourceNames = detailed;
+    state.environments = detailed.map((e) => slugifyEnvKey(e.key));
     return [...new Set(state.environments)];
 }
 /**
@@ -120,6 +149,11 @@ async function listEnvironmentsImpl() {
  */
 async function* fetchChangesImpl() {
     const apiKey = requireApiKey('fetchChanges');
+    // qfg-l8uz: load the account-wide member directory once so the report can
+    // render maintainerId → email pairs. Deliberately best-effort — a failed
+    // call (project-scoped token, hidden member data) just leaves the rollup
+    // showing opaque hex IDs.
+    state.maintainerMap = await loadMaintainerMap(apiKey);
     if (state.fullSummary) {
         yield* fetchAuditHistory(apiKey);
         return;
@@ -243,6 +277,39 @@ function getSkippedConfigsImpl() {
 export function getConversionReport() {
     return state.report;
 }
+/**
+ * qfg-l8uz: maintainerId → email map produced by `/members` during
+ * validateAuth, or null when the call failed (project-scoped token, account
+ * hides members, etc.). The report renderer surfaces this as a sub-table on
+ * `## Identifier map` and decorates `dropped-maintainer` rollups so a reader
+ * sees real emails alongside the opaque hex IDs.
+ */
+function getMaintainerMapImpl() {
+    if (state.maintainerMap === null)
+        return null;
+    return Object.keys(state.maintainerMap).length === 0 ? null : { ...state.maintainerMap };
+}
+/**
+ * qfg-1t7m: source-name → Quonfig-name pairs for the report's "Environment
+ * mapping table". The source name is LD's user-facing env display name; the
+ * Quonfig name is the slugified env key. De-duped on the slugified key — two
+ * source envs that collapse to the same slug get one row (the first wins),
+ * since that is the row that will exist in quonfig.json.
+ */
+function getEnvironmentMapImpl() {
+    if (state.environmentSourceNames.length === 0)
+        return null;
+    const seen = new Set();
+    const entries = [];
+    for (const env of state.environmentSourceNames) {
+        const quonfigName = slugifyEnvKey(env.key);
+        if (seen.has(quonfigName))
+            continue;
+        seen.add(quonfigName);
+        entries.push({ quonfigName, sourceName: env.name });
+    }
+    return entries.length === 0 ? null : entries;
+}
 /**
  * Every structured conversion note from this run — re-bucketed rollouts,
  * dropped prerequisites, lossy individual-target conversions, etc. The write
@@ -275,6 +342,8 @@ export const launchdarklySource = {
     },
     getCommitMeta: getCommitMetaImpl,
     getConversionNotes: getConversionNotesImpl,
+    getEnvironmentMap: getEnvironmentMapImpl,
+    getMaintainerMap: getMaintainerMapImpl,
     getSkippedConfigs: getSkippedConfigsImpl,
     listEnvironments: listEnvironmentsImpl,
     name: SOURCE_NAME,
@@ -284,7 +353,9 @@ export const launchdarklySource = {
 export function __resetLaunchDarklySourceForTests() {
     state.apiKey = null;
     state.environments = [];
+    state.environmentSourceNames = [];
     state.fullSummary = false;
+    state.maintainerMap = null;
     state.projectKey = resolveProjectKey();
     state.report = new ConversionReport();
     state.retentionHorizon = null;

package/dist/util/clone-and-stack-push.js

@@ -33,10 +33,16 @@ const runGit = async (cwd, args) => {
         throw wrapped;
     }
 };
+/**
+ * True only when `dir` is itself the root of a git repo. Uses `--show-prefix`
+ * (relative path from enclosing toplevel down to `dir`, empty when `dir` IS
+ * the toplevel) to avoid cross-platform path-string pitfalls — see the
+ * matching comment in cli/src/migrate/local-write.ts (qfg-wu85).
+ */
 const isGitRepo = async (dir) => {
     try {
-        await runGitSafe(['-C', dir, 'rev-parse', '--git-dir']);
-        return true;
+        const { stdout } = await runGitSafe(['-C', dir, 'rev-parse', '--show-prefix']);
+        return stdout.trim() === '';
     }
     catch {
         return false;

package/dist/util/friction-log.d.ts

@@ -4,6 +4,7 @@ export interface FrictionEntry {
     exitCode: number;
     ts: string;
 }
+export declare function getDefaultFrictionLogPath(home?: string): string;
 export declare function getFrictionLogPath(envValue?: string | undefined, cwd?: string): null | string;
 export declare function buildFrictionEntry(opts: {
     argv?: string[];

package/dist/util/friction-log.js

@@ -1,5 +1,9 @@
 import fs from 'node:fs';
+import os from 'node:os';
 import path from 'node:path';
+export function getDefaultFrictionLogPath(home = os.homedir()) {
+    return path.join(home, '.qfg', 'friction.log');
+}
 export function getFrictionLogPath(envValue, cwd = process.cwd()) {
     if (envValue === undefined)
         return null;
@@ -7,7 +11,7 @@ export function getFrictionLogPath(envValue, cwd = process.cwd()) {
     if (trimmed === '' || trimmed === 'false' || trimmed === '0')
         return null;
     if (trimmed === 'true' || trimmed === '1') {
-        return path.join(cwd, '.qfg-friction.log');
+        return getDefaultFrictionLogPath();
     }
     return path.isAbsolute(trimmed) ? trimmed : path.resolve(cwd, trimmed);
 }
@@ -23,6 +27,7 @@ export function buildFrictionEntry(opts) {
     };
 }
 export function appendFrictionEntry(logPath, entry) {
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
     fs.appendFileSync(logPath, JSON.stringify(entry) + '\n', 'utf8');
 }
 const MAX_STDERR_CAPTURE = 4000;

package/dist/util/git-ops.d.ts

@@ -40,6 +40,12 @@ export interface SpawnGitOptions {
  */
 export declare const spawnGit: (args: string[], options?: SpawnGitOptions) => Promise<void>;
 export declare const gitClone: (repoUrl: string, dir: string) => Promise<void>;
+/**
+ * True only when `dir` is itself the root of a git repo. Uses `--show-prefix`
+ * (relative path from enclosing toplevel down to `dir`, empty when `dir` IS
+ * the toplevel) to avoid cross-platform path-string pitfalls — see the
+ * matching comment in cli/src/migrate/local-write.ts (qfg-wu85).
+ */
 export declare const isGitRepo: (dir: string) => Promise<boolean>;
 export declare const getRemoteUrl: (dir: string) => Promise<string | null>;
 /**

package/dist/util/git-ops.js

@@ -63,10 +63,16 @@ export const spawnGit = (args, options) => new Promise((resolve, reject) => {
 export const gitClone = async (repoUrl, dir) => {
     await runGit(['clone', repoUrl, dir]);
 };
+/**
+ * True only when `dir` is itself the root of a git repo. Uses `--show-prefix`
+ * (relative path from enclosing toplevel down to `dir`, empty when `dir` IS
+ * the toplevel) to avoid cross-platform path-string pitfalls — see the
+ * matching comment in cli/src/migrate/local-write.ts (qfg-wu85).
+ */
 export const isGitRepo = async (dir) => {
     try {
-        await runGit(['-C', dir, 'rev-parse', '--git-dir']);
-        return true;
+        const { stdout } = await runGit(['-C', dir, 'rev-parse', '--show-prefix']);
+        return stdout.trim() === '';
     }
     catch {
         return false;

package/dist/version.d.ts

@@ -1,2 +1,2 @@
-declare const _default: "0.0.48";
+declare const _default: "0.0.50";
 export default _default;

package/dist/version.js

@@ -1,2 +1,2 @@
 // AUTO-GENERATED from package.json by scripts/generate-version.mjs — do not edit.
-export default '0.0.48';
+export default '0.0.50';

package/oclif.manifest.json

@@ -3625,5 +3625,5 @@
       ]
     }
   },
-  "version": "0.0.48"
+  "version": "0.0.50"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "packageManager": "yarn@4.11.0+sha512.4e54aeace9141df2f0177c266b05ec50dc044638157dae128c471ba65994ac802122d7ab35bcd9e81641228b7dcf24867d28e750e0bcae8a05277d600008ad54",
   "name": "@quonfig/cli",
-  "version": "0.0.48",
+  "version": "0.0.50",
   "bugs": {
     "url": "https://github.com/quonfig/cli/issues"
   },