@enrichlayer/el-linear 1.9.0 → 1.15.0

package/dist/commands/attachments.js

@@ -3,6 +3,7 @@ import { createGraphQLAttachmentsService } from "../utils/graphql-attachments-se
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
 export function setupAttachmentsCommands(program) {
     const attachments = program
         .command("attachments")
@@ -40,7 +41,7 @@ export function setupAttachmentsCommands(program) {
         const resolvedIssueId = await linearService.resolveIssueId(issueId);
         const attachmentsService = await createGraphQLAttachmentsService(rootOpts);
         const allAttachments = await attachmentsService.listAttachments(resolvedIssueId);
-        const limit = Number.parseInt(options.limit, 10);
+        const limit = parsePositiveInt(options.limit, "--limit");
         const data = allAttachments.slice(0, limit);
         outputSuccess({ data, meta: { count: data.length } });
     }));

package/dist/commands/batch.js

@@ -1,14 +1,12 @@
-import { resolveAssignee, resolveLabels, resolveTeam, } from "../config/resolver.js";
-import { GraphQLIssuesService } from "../utils/graphql-issues-service.js";
-import { createGraphQLService } from "../utils/graphql-service.js";
-import { createLinearService } from "../utils/linear-service.js";
+import { resolveAssignee, resolveLabels, resolveMember, resolveTeam, } from "../config/resolver.js";
+import { createIssuesService } from "../utils/issues-service-bootstrap.js";
 import { logger } from "../utils/logger.js";
 import { handleAsyncCommand, outputSuccess, outputWarning, } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { splitList } from "../utils/validators.js";
 /**
  * Parse the --filter string into structured search arguments.
- * Format: "status:Backlog team:DEV label:Bug assignee:Alice project:Sprint12"
+ * Format: "status:Backlog team:DEV label:Bug assignee:Alice delegate:Claude project:Sprint12"
  */
 function parseFilterString(filter) {
     const result = {};
@@ -30,21 +28,28 @@ function parseFilterString(filter) {
  * Returns LinearIssue[] so we can show a preview.
  */
 async function resolveTargetIssues(options, rootOpts) {
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     if (options.issues) {
         const ids = splitList(options.issues);
         return Promise.all(ids.map((id) => issuesService.getIssueById(id)));
     }
     if (options.filter) {
         const filters = parseFilterString(options.filter);
+        // Typed as SearchIssueArgs (not Record<string, unknown>) so a future
+        // rename of any field — like the DEV-4068 T4 `projectId` → `project`
+        // migration — surfaces here at compile time instead of silently
+        // dropping the filter.
         const searchArgs = {
             teamId: filters.team ? resolveTeam(filters.team) : undefined,
             assigneeId: filters.assignee
                 ? await resolveAssignee(filters.assignee, rootOpts)
                 : undefined,
-            projectId: filters.project || undefined,
+            delegateId: filters.delegate
+                ? resolveMember(filters.delegate)
+                : undefined,
+            project: filters.project
+                ? { kind: "id", id: filters.project }
+                : undefined,
             labelNames: filters.label ? splitList(filters.label) : undefined,
             status: filters.status ? splitList(filters.status) : undefined,
             limit: 50,
@@ -117,9 +122,7 @@ async function handleBatchAssign(options, command) {
         });
         return;
     }
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     const { results } = await executeBatch(issues, (issue) => issuesService.updateIssue({ id: issue.identifier, assigneeId }, "adding"));
     outputSuccess({
         action: "assign",
@@ -164,9 +167,7 @@ async function handleBatchLabel(options, command) {
         });
         return;
     }
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     const removeLower = removeLabels.map((l) => l.toLowerCase());
     const { results } = await executeBatch(issues, (issue) => {
         // Filter out labels to remove (by name, case-insensitive)
@@ -218,9 +219,7 @@ async function handleBatchMove(options, command) {
         });
         return;
     }
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     const { results } = await executeBatch(issues, (issue) => issuesService.updateIssue({ id: issue.identifier, projectId: options.project }, "adding"));
     outputSuccess({
         action: "move",
@@ -254,9 +253,7 @@ async function handleBatchStatus(options, command) {
         });
         return;
     }
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     const { results } = await executeBatch(issues, (issue) => issuesService.updateIssue({ id: issue.identifier, statusId: options.status }, "adding"));
     outputSuccess({
         action: "status",

package/dist/commands/comments.js

@@ -11,39 +11,38 @@ import { resolveMentions } from "../utils/mention-resolver.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { validateReferences } from "../utils/validate-references.js";
+import { parsePositiveInt } from "../utils/validators.js";
 import { getWorkspaceUrlKey } from "../utils/workspace-url.js";
 // Match Linear's bodyData validation error in multiple phrasings so a wording
 // tweak on their side doesn't silently regress the fallback path.
 const BODY_DATA_ERROR_RE = /prosemirror|bodydata|invalid.*body/i;
 const ISSUE_IDENTIFIER_REGEX = /^[A-Z][A-Z0-9]*-\d+$/;
 function readBody(options) {
-    if (options.file) {
-        return readFileSync(options.file, "utf-8");
+    if (options.bodyFile) {
+        return readFileSync(options.bodyFile, "utf-8");
     }
     if (options.body) {
         return options.body;
     }
-    throw new Error("Either --body or --file is required");
+    throw new Error("Either --body or --body-file is required");
 }
 async function fetchSelfUserId(graphQLService) {
     try {
         const result = await graphQLService.rawRequest("{ viewer { id } }");
-        const viewer = result.viewer;
-        return viewer?.id;
+        return result.viewer?.id;
     }
     catch {
         return;
     }
 }
 function transformComment(comment) {
-    const user = comment.user;
     return {
         id: comment.id,
         body: comment.body,
         user: {
-            id: user.id,
-            name: resolveUserDisplayName(user.id, user.name),
-            url: user.url || undefined,
+            id: comment.user.id,
+            name: resolveUserDisplayName(comment.user.id, comment.user.name),
+            url: comment.user.url ?? undefined,
         },
         createdAt: comment.createdAt,
         updatedAt: comment.updatedAt,
@@ -133,9 +132,7 @@ async function handleCreateComment(issueId, options, command) {
     }
     let result;
     try {
-        result = await graphQLService.rawRequest(CREATE_COMMENT_MUTATION, {
-            input,
-        });
+        result = await graphQLService.rawRequest(CREATE_COMMENT_MUTATION, { input });
     }
     catch (err) {
         // If the bodyData ProseMirror document is rejected (invalid shape,
@@ -147,16 +144,14 @@ async function handleCreateComment(issueId, options, command) {
                 issueId: resolvedIssueId,
                 body,
             };
-            result = await graphQLService.rawRequest(CREATE_COMMENT_MUTATION, {
-                input: fallbackInput,
-            });
+            result = await graphQLService.rawRequest(CREATE_COMMENT_MUTATION, { input: fallbackInput });
         }
         else {
             throw err;
         }
     }
     const mutation = result.commentCreate;
-    if (!mutation.success) {
+    if (!mutation.success || !mutation.comment) {
         throw new Error("Failed to create comment");
     }
     // We don't have the parent issue's identifier from the create mutation response,
@@ -201,22 +196,18 @@ async function handleUpdateComment(commentId, options, command) {
     else {
         input.body = body;
     }
-    const result = await graphQLService.rawRequest(UPDATE_COMMENT_MUTATION, {
-        id: commentId,
-        input,
-    });
+    const result = await graphQLService.rawRequest(UPDATE_COMMENT_MUTATION, { id: commentId, input });
     const mutation = result.commentUpdate;
-    if (!mutation.success) {
+    if (!mutation.success || !mutation.comment) {
         throw new Error("Failed to update comment");
     }
     const comment = mutation.comment;
-    const issue = comment.issue;
     let autoLinked;
-    if (issue) {
+    if (comment.issue) {
         // rawBody (pre-wrap) — see note in handleCreateComment about keyword inference
         autoLinked = await autoLinkCommentReferences({
-            parentIssueUuid: issue.id,
-            parentIssueIdentifier: issue.identifier ?? "",
+            parentIssueUuid: comment.issue.id,
+            parentIssueIdentifier: comment.issue.identifier,
             body: rawBody,
             preResolved,
             options,
@@ -234,19 +225,17 @@ async function handleListComments(issueId, options, command) {
     const resolvedId = await linearService.resolveIssueId(issueId);
     const result = await graphQLService.rawRequest(LIST_COMMENTS_QUERY, {
         issueId: resolvedId,
-        first: Number.parseInt(options.limit, 10),
+        first: parsePositiveInt(options.limit, "--limit"),
     });
-    const issue = result.issue;
-    if (!issue) {
+    if (!result.issue) {
         throw new Error(`Issue "${issueId}" not found`);
     }
-    const commentsData = issue.comments;
-    const nodes = commentsData.nodes.map(transformComment);
+    const nodes = result.issue.comments.nodes.map(transformComment);
     outputSuccess({
         data: nodes,
         meta: {
             count: nodes.length,
-            issue: issue.identifier,
+            issue: result.issue.identifier,
         },
     });
 }
@@ -261,7 +250,7 @@ export function setupCommentsCommands(program) {
         .description("Create new comment on issue.")
         .addHelpText("after", "\nBoth UUID and identifiers like ABC-123 are supported.\nBare references to known team members (e.g. 'Dima') are auto-converted to @mentions — pass --no-auto-mention to disable.\nIssue identifiers (e.g. DEV-123) are wrapped as markdown links and added as 'related' relations on the parent issue — pass --no-auto-link to disable.")
         .option("--body <body>", "comment body (inline)")
-        .option("--file <path>", "read comment body from file")
+        .option("--body-file <path>", "read comment body from file")
         .option("--no-auto-mention", "do not auto-convert bare team-member names to @mentions")
         .option("--no-auto-link", "skip wrapping issue refs as markdown links and creating sidebar relations")
         .option("--footer <text>", "text appended to the comment body (overrides config.messageFooter)")
@@ -271,7 +260,7 @@ export function setupCommentsCommands(program) {
         .command("update <commentId>")
         .description("Update an existing comment.")
         .option("--body <body>", "new comment body (inline)")
-        .option("--file <path>", "read new comment body from file")
+        .option("--body-file <path>", "read new comment body from file")
         .option("--no-auto-mention", "do not auto-convert bare team-member names to @mentions")
         .option("--no-auto-link", "skip wrapping issue refs as markdown links and creating sidebar relations")
         .action(handleAsyncCommand(handleUpdateComment));

package/dist/commands/config.js

@@ -1,5 +1,47 @@
-import { loadConfig } from "../config/config.js";
-import { outputSuccess } from "../utils/output.js";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { getActiveTeamConfigInfo, getActiveTeamConfigPath, loadConfig, loadLocalConfig, } from "../config/config.js";
+import { resolveActiveProfile } from "../config/paths.js";
+import { handleAsyncCommand, outputSuccess, outputWarning, } from "../utils/output.js";
+import { updateConfig } from "./init/shared.js";
+/**
+ * Expand a leading `~` to the user's home directory. Shells expand `~` before
+ * the command sees it, but a literal `~/...` pasted from documentation reaches
+ * Node verbatim. We handle it so `el-linear config team set-path ~/git/...`
+ * works regardless of whether the shell did the expansion first.
+ */
+function expandHome(p) {
+    if (p === "~")
+        return os.homedir();
+    if (p.startsWith("~/"))
+        return path.join(os.homedir(), p.slice(2));
+    return p;
+}
+/**
+ * Render the team-config source token returned by `getActiveTeamConfigInfo()`
+ * as a human-readable string for `config team show`. Kept next to the command
+ * (not in `config/config.ts`) so the wire format is owned by the renderer,
+ * not the resolver. DEV-4258.
+ */
+function sourceLabel(source) {
+    switch (source) {
+        case "env":
+            return "EL_LINEAR_TEAM_CONFIG env var";
+        case "personal":
+            return "teamConfigPath in personal config";
+        case "marker":
+            return "auto-discovered via ~/.config/el-tools-root";
+        case null:
+            return null;
+    }
+}
+const LOCAL_SETTABLE_KEYS = [
+    "assigneeEmail",
+    "defaultAssignee",
+    "defaultPriority",
+    "cacheTTLSeconds",
+];
 export function setupConfigCommands(program) {
     const config = program
         .command("config")
@@ -7,9 +49,140 @@ export function setupConfigCommands(program) {
     config.action(() => config.help());
     config
         .command("show")
-        .description("Show resolved configuration")
-        .addHelpText("after", "\nDumps the merged config from ~/.config/el-linear/config.json.\n\nExamples:\n  el-linear config show")
+        .description("Show resolved configuration (team file → personal config → local overrides)")
+        .addHelpText("after", "\nDumps the merged config from the active team file + config.json + local.json.\n\nExamples:\n  el-linear config show")
+        .action(() => {
+        const data = loadConfig();
+        const teamConfig = getActiveTeamConfigPath();
+        const local = loadLocalConfig();
+        const out = { data };
+        if (teamConfig)
+            out.teamConfig = teamConfig;
+        if (Object.keys(local).length > 0)
+            out.local = local;
+        outputSuccess(out);
+    });
+    const local = config
+        .command("local")
+        .description("Manage user-local config overrides (local.json)");
+    local.action(() => local.help());
+    local
+        .command("show")
+        .description("Show the raw contents of local.json")
+        .addHelpText("after", `\nShows ~/.config/el-linear/local.json (or the per-profile equivalent).\n\nExamples:\n  el-linear config local show`)
+        .action(() => {
+        outputSuccess({ data: loadLocalConfig() });
+    });
+    const team = config
+        .command("team")
+        .description("Manage the shared team config layer (teamConfigPath in personal config)");
+    team.action(() => team.help());
+    team
+        .command("show")
+        .description("Show the active team config layer: path, source (env var, personal config, or auto-discovered marker), file status, top-level keys it contributes")
+        .addHelpText("after", "\nResolves the team config in the same order loadConfig() does:\n  EL_LINEAR_TEAM_CONFIG (env)  >  teamConfigPath (personal config)  >  ~/.config/el-tools-root marker\n\nExamples:\n  el-linear config team show")
         .action(() => {
-        outputSuccess({ data: loadConfig() });
+        const info = getActiveTeamConfigInfo();
+        const teamPath = info.path;
+        const source = sourceLabel(info.source);
+        const out = {
+            teamConfigPath: teamPath ?? null,
+            source,
+        };
+        if (teamPath) {
+            try {
+                const raw = fs.readFileSync(teamPath, "utf8");
+                const parsed = JSON.parse(raw);
+                out.exists = true;
+                out.valid = true;
+                out.providedKeys = Object.keys(parsed).sort();
+            }
+            catch (err) {
+                out.exists = fs.existsSync(teamPath);
+                out.valid = false;
+                out.error = err.message;
+            }
+        }
+        outputSuccess({ data: out });
     });
+    team
+        .command("set-path <path>")
+        .description("Write teamConfigPath into personal config.json. Path is resolved to an absolute path. The target file must exist and be valid JSON — a pointer to a missing or broken file is footgun-shaped and refused.")
+        .addHelpText("after", "\nUse this when adopting a shared team config (e.g. one checked into a tools repo):\n  el-linear config team set-path ~/git/enrichlayer/tools/config/el-linear.shared.json\n\nRelative paths resolve against the current working directory; absolute paths are stored as-is. EL_LINEAR_TEAM_CONFIG in the environment still overrides the personal field when both are set — a warning surfaces in that case.")
+        .action(handleAsyncCommand(async (rawPath) => {
+        const resolved = path.resolve(expandHome(rawPath));
+        if (!fs.existsSync(resolved)) {
+            throw new Error(`Team config file not found at ${resolved}. Create the file (or fix the path) before pointing personal config at it.`);
+        }
+        try {
+            JSON.parse(fs.readFileSync(resolved, "utf8"));
+        }
+        catch (err) {
+            throw new Error(`Team config at ${resolved} is not valid JSON: ${err.message}`);
+        }
+        await updateConfig((current) => ({
+            ...current,
+            teamConfigPath: resolved,
+        }));
+        const envOverride = process.env.EL_LINEAR_TEAM_CONFIG?.trim() || undefined;
+        if (envOverride !== undefined && envOverride !== resolved) {
+            outputWarning(`EL_LINEAR_TEAM_CONFIG=${envOverride} is set in this shell and overrides the personal config field. Unset it (or align it) for the persistent setting to take effect.`);
+        }
+        outputSuccess({
+            data: {
+                teamConfigPath: resolved,
+                written: resolveActiveProfile().configPath,
+            },
+        });
+    }));
+    team
+        .command("clear")
+        .description("Remove teamConfigPath from personal config.json. EL_LINEAR_TEAM_CONFIG (env) is unaffected and continues to override if set.")
+        .action(handleAsyncCommand(async () => {
+        let removed;
+        await updateConfig((current) => {
+            removed = current.teamConfigPath;
+            const { teamConfigPath: _drop, ...rest } = current;
+            return rest;
+        });
+        const envOverride = process.env.EL_LINEAR_TEAM_CONFIG?.trim() || undefined;
+        if (envOverride !== undefined) {
+            outputWarning(`EL_LINEAR_TEAM_CONFIG=${envOverride} is still set in this shell; it overrides the personal field and remains active until unset.`);
+        }
+        outputSuccess({
+            data: {
+                cleared: true,
+                previousTeamConfigPath: removed ?? null,
+                written: resolveActiveProfile().configPath,
+            },
+        });
+    }));
+    local
+        .command("set <key> <value>")
+        .description(`Set a key in local.json. Keys: ${LOCAL_SETTABLE_KEYS.join(", ")}`)
+        .addHelpText("after", `\nAllowed keys:\n  assigneeEmail    — your Linear account email (used as default --assignee)\n  defaultAssignee  — alias / display name / email / UUID\n  defaultPriority  — none|urgent|high|medium|normal|low\n  cacheTTLSeconds  — integer seconds (0 = disable cache)\n\nExamples:\n  el-linear config local set assigneeEmail you@example.com\n  el-linear config local set defaultPriority medium\n  el-linear config local set cacheTTLSeconds 0`)
+        .action(handleAsyncCommand(async (key, value) => {
+        if (!LOCAL_SETTABLE_KEYS.includes(key)) {
+            throw new Error(`Unknown local config key "${key}". Allowed: ${LOCAL_SETTABLE_KEYS.join(", ")}`);
+        }
+        const active = resolveActiveProfile();
+        const localPath = active.localConfigPath;
+        let existing = {};
+        if (fs.existsSync(localPath)) {
+            try {
+                existing = JSON.parse(fs.readFileSync(localPath, "utf8"));
+            }
+            catch {
+                // overwrite a corrupt file
+            }
+        }
+        const typedValue = key === "cacheTTLSeconds" ? Number(value) : value;
+        if (key === "cacheTTLSeconds" && Number.isNaN(typedValue)) {
+            throw new Error(`cacheTTLSeconds must be an integer, got "${value}"`);
+        }
+        const updated = { ...existing, [key]: typedValue };
+        fs.mkdirSync(path.dirname(localPath), { recursive: true });
+        fs.writeFileSync(localPath, `${JSON.stringify(updated, null, 2)}\n`, "utf8");
+        outputSuccess({ data: updated });
+    }));
 }

package/dist/commands/cycles.js

@@ -3,6 +3,7 @@ import { invalidParameterError, notFoundError, requiresParameterError, } from ".
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
 export function setupCyclesCommands(program) {
     const cycles = program
         .command("cycles")
@@ -23,7 +24,7 @@ export function setupCyclesCommands(program) {
         const rootOpts = getRootOpts(command);
         const teamFilter = options.team ? resolveTeam(options.team) : undefined;
         const linearService = await createLinearService(rootOpts);
-        const allCycles = await linearService.getCycles(teamFilter, options.active || undefined, Number.parseInt(options.limit, 10));
+        const allCycles = await linearService.getCycles(teamFilter, options.active || undefined, parsePositiveInt(options.limit, "--limit"));
         if (options.aroundActive) {
             const n = Number.parseInt(options.aroundActive, 10);
             if (Number.isNaN(n) || n < 0) {

package/dist/commands/documents.js

@@ -3,6 +3,7 @@ import { createGraphQLDocumentsService } from "../utils/graphql-documents-servic
 import { createLinearService } from "../utils/linear-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
 function extractDocumentIdFromUrl(url) {
     try {
         const parsed = new URL(url);
@@ -70,7 +71,7 @@ async function handleListDocuments(options, command) {
     const rootOpts = getRootOpts(command);
     const documentsService = await createGraphQLDocumentsService(rootOpts);
     const linearService = await createLinearService(rootOpts);
-    const limit = Number.parseInt(options.limit || "50", 10);
+    const limit = parsePositiveInt(options.limit || "50", "--limit");
     if (Number.isNaN(limit) || limit < 1) {
         throw new Error(`Invalid limit "${options.limit}": must be a positive number`);
     }

package/dist/commands/graphql.js

@@ -46,16 +46,14 @@ export function setupGraphQLCommands(program) {
         const graphQLService = await createGraphQLService(rootOpts);
         if (typeName) {
             const result = await graphQLService.rawRequest(INTROSPECT_TYPE_QUERY, { typeName });
-            const typeInfo = result.__type;
-            if (!typeInfo) {
+            if (!result.__type) {
                 throw new Error(`Type "${typeName}" not found in schema`);
             }
-            outputSuccess(typeInfo);
+            outputSuccess(result.__type);
         }
         else {
             const result = await graphQLService.rawRequest(INTROSPECT_ROOT_QUERY);
-            const queryType = result.__type;
-            let fields = queryType?.fields ?? [];
+            let fields = result.__type?.fields ?? [];
             if (options.filter) {
                 const pattern = options.filter.toLowerCase();
                 fields = fields.filter((f) => f.name.toLowerCase().includes(pattern));
@@ -63,7 +61,7 @@ export function setupGraphQLCommands(program) {
             const summary = fields.map((f) => ({
                 name: f.name,
                 description: f.description ?? null,
-                args: (f.args ?? []).map((a) => a.name),
+                args: f.args.map((a) => a.name),
             }));
             outputSuccess({ fields: summary, count: summary.length });
         }

package/dist/commands/init/aliases.js

@@ -22,7 +22,7 @@ const USERS_QUERY = /* GraphQL */ `
   }
 `;
 export async function fetchAllUsers(token) {
-    const service = new GraphQLService(token);
+    const service = new GraphQLService({ apiKey: token });
     const out = [];
     let after;
     for (;;) {

package/dist/commands/init/defaults.d.ts

@@ -6,7 +6,7 @@
  * with no input is a no-op.
  */
 import { type WizardConfig } from "./shared.js";
-export interface DefaultsStepResult {
+interface DefaultsStepResult {
     defaultLabels: string[] | undefined;
     /**
      * Default assignee identifier (alias / display name / email / UUID — same
@@ -40,3 +40,4 @@ export interface DefaultsStepResult {
     cacheTTLSeconds: number | undefined;
 }
 export declare function runDefaultsStep(existing: WizardConfig): Promise<DefaultsStepResult>;
+export {};