@enrichlayer/el-linear 1.2.0 → 1.5.0

package/dist/commands/profile/migrate-legacy.js

@@ -0,0 +1,272 @@
+/**
+ * `el-linear profile migrate-legacy` — one-shot migration from the legacy
+ * single-file config layout (`~/.config/el-linear/{token,config.json}`) to
+ * the named-profiles layout introduced in 1.4 (`~/.config/el-linear/
+ * profiles/<name>/{token,config.json}`).
+ *
+ * Why this command exists:
+ *
+ *   When a user upgraded el-linear to >=1.4, their existing single-file
+ *   `config.json` was preserved verbatim, but the legacy `token` slot was
+ *   sometimes cleared (depending on how the upgrade was performed) and
+ *   1.4 expects per-profile tokens. Result: every command failed with
+ *   "Authentication required" while the rich legacy config (member
+ *   aliases, brand rules, default labels) sat right there on disk with
+ *   no documented migration path.
+ *
+ * Design constraints:
+ *
+ * - **Each step is independently idempotent.** Re-running the command
+ *   after a successful migration is a no-op — config + token files match,
+ *   active-profile already points at the right name. Re-running after a
+ *   partial failure picks up where it left off without `--force`.
+ *
+ * - **Validate before writing.** A token that doesn't pass `viewer { ... }`
+ *   never lands on disk. The validate-then-write order means an interrupted
+ *   migration can't leave a dud token in a freshly-created profile dir.
+ *
+ * - **Legacy preservation.** We never delete the legacy `config.json` or
+ *   `token` — the user gets a rollback path. A one-line stdout hint says
+ *   so explicitly.
+ *
+ * - **`--force` is opt-in destruction.** When the destination profile
+ *   already has a config.json or token that *differs* from the source,
+ *   the command refuses by default with a clear diff hint. `--force`
+ *   overwrites; `--yes` skips the interactive confirm. Both are
+ *   required-together for unattended (CI / scripted) overwrites.
+ */
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { confirm, input, password } from "@inquirer/prompts";
+import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, PROFILES_DIR, profilePaths, TOKEN_PATH, } from "../../config/paths.js";
+import { sanitizeForLog, validateToken } from "../init/token.js";
+const DEFAULT_PROMPTS = { input, password, confirm };
+/** Register `el-linear profile migrate-legacy` under the parent `profile` command. */
+export function registerMigrateLegacy(profile) {
+    profile
+        .command("migrate-legacy")
+        .description("Copy the legacy ~/.config/el-linear/{config.json,token} into a named profile so >=1.4 commands work again.")
+        .option("--name <name>", "Target profile name. Defaults to `default`.", "default")
+        .option("--token-from <path>", "Read the API token from this file instead of prompting.")
+        .option("--force", "Overwrite an existing per-profile config.json or token even when contents differ.")
+        .option("--yes", "Skip interactive confirmations (still respects --force semantics).")
+        .action(async (opts) => {
+        await runMigrateLegacy({
+            name: opts.name,
+            tokenFrom: opts.tokenFrom,
+            force: opts.force === true,
+            yes: opts.yes === true,
+        });
+    });
+}
+/**
+ * Top-level orchestrator. Each helper below is independently idempotent;
+ * this function just sequences them and prints the final ✓ banner.
+ *
+ * Exit semantics:
+ *
+ *   - Missing legacy config → `process.exit(1)` (user error, nothing to do).
+ *   - Refused overwrite (no --force) → throws — handled by handleAsyncCommand
+ *     elsewhere in the CLI and surfaces as a structured JSON error on stdout.
+ *   - Token validation failure → throws (no on-disk change has happened yet).
+ */
+export async function runMigrateLegacy(options, deps = {}) {
+    const stdout = deps.stdout ?? process.stdout;
+    const prompts = deps.prompts ?? DEFAULT_PROMPTS;
+    const validate = deps.validateToken ?? validateToken;
+    // 1. Pre-flight: legacy config must exist. There's nothing to migrate
+    //    on a freshly-onboarded machine and we don't want to silently
+    //    create an empty profile.
+    if (!(await pathExists(CONFIG_PATH))) {
+        stdout.write(`Nothing to migrate — no legacy config found at ${CONFIG_PATH}.\n`);
+        stdout.write("If this is a fresh install, run `el-linear init` instead.\n");
+        process.exit(1);
+    }
+    const initialName = (options.name ?? "default").trim() || "default";
+    let name = initialName;
+    // Allow an interactive override of the target name unless --yes was passed
+    // (scripted) or --name was explicitly set to something other than the
+    // default. Keeps backward compat with the CLI flag while not surprising
+    // CI runs.
+    if (!options.skipPrompt && !options.yes && options.name === undefined) {
+        const answer = await prompts.input({
+            message: "Target profile name:",
+            default: name,
+        });
+        const trimmed = answer.trim();
+        if (trimmed.length > 0)
+            name = trimmed;
+    }
+    if (!isSafeName(name)) {
+        throw new Error(`Invalid profile name "${name}". Allowed: [a-z0-9_.-], up to 64 chars.`);
+    }
+    // 2. Token source priority: --token-from > EL_LINEAR_TOKEN > prompt.
+    //    Validate before writing anything to disk.
+    const token = await resolveAndValidateToken(options, prompts, validate);
+    // 3. Profile dir.
+    const paths = profilePaths(name);
+    const profileDir = path.dirname(paths.configPath);
+    await fsp.mkdir(profileDir, { recursive: true, mode: 0o700 });
+    // 4. Config copy with idempotent + force semantics.
+    await copyConfigIntoProfile(paths.configPath, options, prompts);
+    // 5. Token write with idempotent + force semantics.
+    await writeProfileToken(paths.tokenPath, token, options, prompts);
+    // 6. active-profile marker.
+    await ensureActiveProfile(name);
+    // 7. Legacy preservation hint. We do NOT delete the legacy paths —
+    //    the user gets a rollback if anything went sideways.
+    stdout.write(`legacy ${CONFIG_PATH} kept for rollback; safe to remove later if no longer needed\n`);
+    // 8. Final verify against the freshly-written profile token. This is
+    //    a defensive double-check: the token was already validated above,
+    //    but verifying *after* the write catches any FS-level surprise
+    //    (e.g. wrong token landed in the wrong dir on a multi-profile box).
+    const onDiskToken = (await fsp.readFile(paths.tokenPath, "utf8")).trim();
+    const viewer = await validate(onDiskToken);
+    stdout.write(`✓ Migrated. Active profile: ${name}. Workspace: ${viewer.organization.urlKey}\n`);
+}
+// ---- Helpers --------------------------------------------------------
+async function resolveAndValidateToken(options, prompts, validate) {
+    if (options.tokenFrom) {
+        const raw = await fsp.readFile(options.tokenFrom, "utf8");
+        const token = raw.trim();
+        if (!token) {
+            throw new Error(`Token file ${options.tokenFrom} is empty.`);
+        }
+        await validate(token);
+        return token;
+    }
+    const envToken = process.env.EL_LINEAR_TOKEN?.trim();
+    if (envToken) {
+        await validate(envToken);
+        return envToken;
+    }
+    // Interactive: up to three attempts, hidden input. We re-prompt on
+    // validation failure rather than aborting so the user can paste a
+    // fresh token without re-running the whole command.
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const candidate = (await prompts.password({
+            message: attempt === 0
+                ? "Linear API token (input hidden):"
+                : "Try again (input hidden):",
+            mask: "*",
+            validate: (s) => s.trim().length > 0 || "Token cannot be empty",
+        })).trim();
+        try {
+            await validate(candidate);
+            return candidate;
+        }
+        catch (err) {
+            const raw = err instanceof Error ? err.message : String(err);
+            // biome-ignore lint/suspicious/noConsole: interactive prompt feedback
+            console.log(`  ✗ ${sanitizeForLog(raw)}`);
+        }
+    }
+    throw new Error("Could not validate a Linear API token after 3 attempts. Aborting migration.");
+}
+async function copyConfigIntoProfile(destConfigPath, options, prompts) {
+    const sourceContent = await fsp.readFile(CONFIG_PATH, "utf8");
+    if (!(await pathExists(destConfigPath))) {
+        await fsp.writeFile(destConfigPath, sourceContent, {
+            mode: 0o644,
+            encoding: "utf8",
+        });
+        return;
+    }
+    const destContent = await fsp.readFile(destConfigPath, "utf8");
+    if (destContent === sourceContent) {
+        // Idempotent re-run — nothing to do.
+        return;
+    }
+    if (!options.force) {
+        throw new Error([
+            `Refusing to overwrite ${destConfigPath} — its contents differ from ${CONFIG_PATH}.`,
+            "Re-run with --force to overwrite. The legacy file is kept either way; only the per-profile copy changes.",
+            `Diff hint: \`diff ${CONFIG_PATH} ${destConfigPath}\``,
+        ].join("\n"));
+    }
+    if (!options.yes) {
+        const ok = await prompts.confirm({
+            message: `Overwrite ${destConfigPath} with the legacy config?`,
+            default: false,
+        });
+        if (!ok) {
+            throw new Error("Aborted by user.");
+        }
+    }
+    await fsp.writeFile(destConfigPath, sourceContent, {
+        mode: 0o644,
+        encoding: "utf8",
+    });
+}
+async function writeProfileToken(destTokenPath, token, options, prompts) {
+    const newline = `${token}\n`;
+    if (!(await pathExists(destTokenPath))) {
+        await fsp.writeFile(destTokenPath, newline, {
+            mode: 0o600,
+            encoding: "utf8",
+        });
+        // fs.writeFile mode is only honored on file creation; chmod defensively
+        // in case a parent process pre-created the file with permissive perms.
+        await fsp.chmod(destTokenPath, 0o600);
+        return;
+    }
+    const existing = (await fsp.readFile(destTokenPath, "utf8")).trim();
+    if (existing === token) {
+        // Idempotent re-run — already correct; force perms regardless.
+        await fsp.chmod(destTokenPath, 0o600);
+        return;
+    }
+    if (!options.force) {
+        throw new Error([
+            `Refusing to overwrite ${destTokenPath} — it contains a different token.`,
+            "Re-run with --force to overwrite the per-profile token.",
+        ].join("\n"));
+    }
+    if (!options.yes) {
+        const ok = await prompts.confirm({
+            message: `Overwrite the existing token at ${destTokenPath}?`,
+            default: false,
+        });
+        if (!ok) {
+            throw new Error("Aborted by user.");
+        }
+    }
+    await fsp.writeFile(destTokenPath, newline, {
+        mode: 0o600,
+        encoding: "utf8",
+    });
+    await fsp.chmod(destTokenPath, 0o600);
+}
+async function ensureActiveProfile(name) {
+    await fsp.mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    let current = null;
+    if (await pathExists(ACTIVE_PROFILE_FILE)) {
+        current = (await fsp.readFile(ACTIVE_PROFILE_FILE, "utf8")).trim();
+    }
+    if (current === name)
+        return;
+    await fsp.writeFile(ACTIVE_PROFILE_FILE, `${name}\n`, {
+        mode: 0o644,
+        encoding: "utf8",
+    });
+}
+async function pathExists(p) {
+    try {
+        await fsp.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Profile names land in filesystem paths and the active-profile marker.
+ * Same conservative charset as `profile add` to avoid `..` traversal,
+ * shell metacharacters, and Unicode lookalikes.
+ */
+function isSafeName(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(name);
+}
+// Re-export internals so the integration test (and follow-up commands)
+// can compose them without re-implementing the idempotency rules.
+export { CONFIG_PATH, PROFILES_DIR, TOKEN_PATH };

package/dist/commands/profile.d.ts

@@ -0,0 +1,46 @@
+/**
+ * `el-linear profile` — manage named profiles.
+ *
+ * A profile is a named directory under `~/.config/el-linear/profiles/`
+ * that holds its own `token` + `config.json`. Profiles let one user
+ * keep multiple Linear workspaces (e.g. day-job + side-project) on the
+ * same machine without juggling tokens.
+ *
+ * Subcommands:
+ *
+ *   el-linear profile list                — show all profiles + which is active
+ *   el-linear profile current             — print the active profile name (or `<default>`)
+ *   el-linear profile use <name>          — make <name> the default profile
+ *   el-linear profile add <name>          — create a profile + run init for it
+ *   el-linear profile remove <name>       — delete the profile dir (with confirmation)
+ *
+ * The `--profile <name>` flag (top-level, see main.ts) overrides the
+ * active profile for one invocation only.
+ *
+ * Backward-compat: when no profile is configured, every read still
+ * falls back to the legacy single-file paths (CONFIG_PATH / TOKEN_PATH).
+ */
+import type { Command } from "commander";
+export declare function setupProfileCommands(program: Command): void;
+export interface ProfileListEntry {
+    name: string;
+    active: boolean;
+    hasToken: boolean;
+    hasConfig: boolean;
+    configPath: string;
+    tokenPath: string;
+}
+export interface ProfileListReport {
+    activeName: string | null;
+    defaultPaths: {
+        configPath: string;
+        tokenPath: string;
+    };
+    hasLegacyToken: boolean;
+    hasLegacyConfig: boolean;
+    profiles: ProfileListEntry[];
+}
+export declare function runProfileList(): Promise<ProfileListReport>;
+export declare function runProfileUse(name: string): Promise<void>;
+export declare function runProfileAdd(name: string): Promise<void>;
+export declare function runProfileRemove(name: string, force: boolean): Promise<void>;

package/dist/commands/profile.js

@@ -0,0 +1,191 @@
+/**
+ * `el-linear profile` — manage named profiles.
+ *
+ * A profile is a named directory under `~/.config/el-linear/profiles/`
+ * that holds its own `token` + `config.json`. Profiles let one user
+ * keep multiple Linear workspaces (e.g. day-job + side-project) on the
+ * same machine without juggling tokens.
+ *
+ * Subcommands:
+ *
+ *   el-linear profile list                — show all profiles + which is active
+ *   el-linear profile current             — print the active profile name (or `<default>`)
+ *   el-linear profile use <name>          — make <name> the default profile
+ *   el-linear profile add <name>          — create a profile + run init for it
+ *   el-linear profile remove <name>       — delete the profile dir (with confirmation)
+ *
+ * The `--profile <name>` flag (top-level, see main.ts) overrides the
+ * active profile for one invocation only.
+ *
+ * Backward-compat: when no profile is configured, every read still
+ * falls back to the legacy single-file paths (CONFIG_PATH / TOKEN_PATH).
+ */
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { confirm } from "@inquirer/prompts";
+import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, PROFILES_DIR, profilePaths, resolveActiveProfile, setActiveProfileForSession, TOKEN_PATH, } from "../config/paths.js";
+import { outputSuccess, outputWarning } from "../utils/output.js";
+import { runFullWizard } from "./init/index.js";
+import { registerMigrateLegacy } from "./profile/migrate-legacy.js";
+export function setupProfileCommands(program) {
+    const profile = program
+        .command("profile")
+        .description("Manage el-linear profiles (named workspaces with separate tokens + configs).");
+    profile.action(() => profile.help());
+    profile
+        .command("list")
+        .description("List configured profiles + which one is active.")
+        .action(async () => {
+        const data = await runProfileList();
+        outputSuccess({ data });
+    });
+    profile
+        .command("current")
+        .description("Print the active profile name (or `<default>` for the legacy single-profile setup).")
+        .action(() => {
+        const active = resolveActiveProfile();
+        outputSuccess({
+            data: {
+                name: active.name ?? "<default>",
+                configPath: active.configPath,
+                tokenPath: active.tokenPath,
+            },
+        });
+    });
+    profile
+        .command("use <name>")
+        .description("Make <name> the active profile (writes ~/.config/el-linear/active-profile).")
+        .action(async (name) => {
+        await runProfileUse(name);
+        outputSuccess({ data: { name, activeProfileFile: ACTIVE_PROFILE_FILE } });
+    });
+    profile
+        .command("add <name>")
+        .description("Create a new profile named <name> + run the init wizard scoped to it. After this finishes, <name> becomes the active profile.")
+        .action(async (name) => {
+        await runProfileAdd(name);
+    });
+    profile
+        .command("remove <name>")
+        .alias("rm")
+        .description("Delete the profile directory + its token (with confirmation).")
+        .option("--force", "skip the confirmation prompt")
+        .action(async (name, opts) => {
+        await runProfileRemove(name, opts.force === true);
+    });
+    // `el-linear profile migrate-legacy` — registered alongside add/list/etc.
+    // Lives in its own module so the multi-step migration logic stays
+    // self-contained and unit-testable without dragging in the full
+    // profile-management surface.
+    registerMigrateLegacy(profile);
+}
+export async function runProfileList() {
+    const active = resolveActiveProfile();
+    const profiles = [];
+    let entries = [];
+    try {
+        entries = (await fsp.readdir(PROFILES_DIR, { withFileTypes: true }))
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name)
+            .sort();
+    }
+    catch (err) {
+        if (err.code !== "ENOENT")
+            throw err;
+    }
+    for (const name of entries) {
+        const paths = profilePaths(name);
+        profiles.push({
+            name,
+            active: active.name === name,
+            hasToken: await pathExists(paths.tokenPath),
+            hasConfig: await pathExists(paths.configPath),
+            configPath: paths.configPath,
+            tokenPath: paths.tokenPath,
+        });
+    }
+    return {
+        activeName: active.name,
+        defaultPaths: { configPath: CONFIG_PATH, tokenPath: TOKEN_PATH },
+        hasLegacyToken: await pathExists(TOKEN_PATH),
+        hasLegacyConfig: await pathExists(CONFIG_PATH),
+        profiles,
+    };
+}
+export async function runProfileUse(name) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        throw new Error("Profile name must be non-empty.");
+    if (!isSafeName(trimmed)) {
+        throw new Error(`Profile name "${trimmed}" must contain only [a-z0-9_-]. Pick a different name.`);
+    }
+    await fsp.mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    await fsp.writeFile(ACTIVE_PROFILE_FILE, `${trimmed}\n`, { mode: 0o644 });
+}
+export async function runProfileAdd(name) {
+    const trimmed = name.trim();
+    if (!trimmed)
+        throw new Error("Profile name must be non-empty.");
+    if (!isSafeName(trimmed)) {
+        throw new Error(`Profile name "${trimmed}" must contain only [a-z0-9_-]. Pick a different name.`);
+    }
+    const dir = path.dirname(profilePaths(trimmed).configPath);
+    await fsp.mkdir(dir, { recursive: true, mode: 0o700 });
+    // Activate the profile for the rest of THIS process so the wizard's
+    // readConfig/writeConfig/readToken/writeToken IO targets the new
+    // profile's directory (not the legacy single-file path).
+    setActiveProfileForSession(trimmed);
+    // Persist activation: write `active-profile` so subsequent invocations
+    // stay on the new profile until `profile use <other>` switches away.
+    await runProfileUse(trimmed);
+    outputWarning(`Created profile "${trimmed}" at ${dir}. Running init wizard scoped to this profile…`);
+    await runFullWizard();
+}
+export async function runProfileRemove(name, force) {
+    const trimmed = name.trim();
+    if (!trimmed || !isSafeName(trimmed)) {
+        throw new Error(`Invalid profile name "${name}".`);
+    }
+    const paths = profilePaths(trimmed);
+    const dir = path.dirname(paths.configPath);
+    if (!(await pathExists(dir))) {
+        throw new Error(`Profile "${trimmed}" not found at ${dir}.`);
+    }
+    if (!force) {
+        const confirmed = await confirm({
+            message: `Delete profile "${trimmed}" (${dir})? Token + config will be lost.`,
+            default: false,
+        });
+        if (!confirmed) {
+            outputWarning("Aborted.");
+            return;
+        }
+    }
+    await fsp.rm(dir, { recursive: true, force: true });
+    // If the just-removed profile was the active one, clear the marker
+    // so subsequent invocations fall back to the default paths.
+    const active = resolveActiveProfile();
+    if (active.name === trimmed && (await pathExists(ACTIVE_PROFILE_FILE))) {
+        await fsp.rm(ACTIVE_PROFILE_FILE, { force: true });
+    }
+    outputSuccess({ data: { removed: trimmed, dir } });
+}
+// ---- Helpers ------------------------------------------------------------
+async function pathExists(p) {
+    try {
+        await fsp.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Profile names land in filesystem paths AND get written to a
+ * single-line marker. Restrict to a conservative charset so we can't
+ * accidentally pick up `..` traversal, command-line metacharacters, or
+ * Unicode lookalikes that would confuse `profile use`.
+ */
+function isSafeName(name) {
+    return /^[A-Za-z0-9][A-Za-z0-9_.-]{0,63}$/.test(name);
+}

package/dist/commands/refs.d.ts

@@ -0,0 +1,18 @@
+import type { Command } from "commander";
+import { type WrapTarget } from "../utils/issue-reference-wrapper.js";
+interface WrapDeps {
+    resolveValidIdentifiers: (ids: readonly string[]) => Promise<Set<string>>;
+    resolveUrlKey: () => Promise<string>;
+}
+interface WrapInput {
+    text: string;
+    target: WrapTarget;
+    validate: boolean;
+}
+/**
+ * Pure-ish core of `refs wrap` — split out so tests can drive it directly with
+ * a stubbed `WrapDeps`, no commander parsing or stdin/fs IO.
+ */
+export declare function wrapRefsCore(input: WrapInput, deps: WrapDeps): Promise<string>;
+export declare function setupRefsCommands(program: Command): void;
+export {};

package/dist/commands/refs.js

@@ -0,0 +1,95 @@
+import { readFileSync } from "node:fs";
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { extractIssueReferences } from "../utils/issue-reference-extractor.js";
+import { wrapIssueReferencesAsLinks, } from "../utils/issue-reference-wrapper.js";
+import { createLinearService } from "../utils/linear-service.js";
+import { handleAsyncCommand } from "../utils/output.js";
+import { validateReferences } from "../utils/validate-references.js";
+import { getWorkspaceUrlKey } from "../utils/workspace-url.js";
+const VALID_TARGETS = new Set(["markdown", "slack"]);
+function isWrapTarget(value) {
+    return VALID_TARGETS.has(value);
+}
+/**
+ * Read all input bytes from a Readable stream as a UTF-8 string. Used to slurp
+ * stdin when the user pipes content (`el-linear refs wrap < input.md`).
+ */
+async function readAllStdin() {
+    if (process.stdin.isTTY) {
+        throw new Error("No input provided. Pipe text to stdin or pass --file <path>.");
+    }
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}
+/**
+ * Pure-ish core of `refs wrap` — split out so tests can drive it directly with
+ * a stubbed `WrapDeps`, no commander parsing or stdin/fs IO.
+ */
+export async function wrapRefsCore(input, deps) {
+    const refs = extractIssueReferences(input.text);
+    if (refs.length === 0) {
+        return input.text;
+    }
+    const candidateIds = refs.map((r) => r.identifier);
+    let validIds;
+    if (input.validate) {
+        validIds = await deps.resolveValidIdentifiers(candidateIds);
+    }
+    else {
+        // --no-validate: trust every regex match, skip the API.
+        validIds = new Set(candidateIds);
+    }
+    if (validIds.size === 0) {
+        return input.text;
+    }
+    const urlKey = await deps.resolveUrlKey();
+    return wrapIssueReferencesAsLinks(input.text, validIds, urlKey, input.target);
+}
+async function handleWrap(options, command) {
+    const target = options.target ?? "markdown";
+    if (!isWrapTarget(target)) {
+        throw new Error(`Invalid --target "${target}". Expected one of: ${[...VALID_TARGETS].join(", ")}`);
+    }
+    // `validate` is `true` by default and `false` when `--no-validate` is passed.
+    const validate = options.validate !== false;
+    const text = typeof options.file === "string" && options.file.length > 0
+        ? readFileSync(options.file, "utf8")
+        : await readAllStdin();
+    const rootOpts = command.parent.parent.opts();
+    const deps = {
+        async resolveValidIdentifiers(ids) {
+            const linearService = createLinearService(rootOpts);
+            const map = await validateReferences(ids, linearService);
+            return new Set(map.keys());
+        },
+        async resolveUrlKey() {
+            const graphQLService = createGraphQLService(rootOpts);
+            return getWorkspaceUrlKey(graphQLService);
+        },
+    };
+    if (!validate) {
+        // stderr advisory only — keeps stdout a clean text stream for piping.
+        process.stderr.write("el-linear refs wrap: --no-validate set; emitting links for every regex match without checking the workspace.\n");
+    }
+    const wrapped = await wrapRefsCore({ text, target, validate }, deps);
+    process.stdout.write(wrapped);
+}
+export function setupRefsCommands(program) {
+    const refs = program
+        .command("refs")
+        .description("Operations on Linear issue references found in arbitrary text.");
+    refs.action(() => refs.help());
+    refs
+        .command("wrap")
+        .description("Wrap recognized Linear issue identifiers in input text as links. " +
+        "Reads from stdin (or --file) and writes to stdout. By default, " +
+        "each candidate identifier is validated against the workspace; " +
+        "unresolvable ones are left as plain text.")
+        .option("--file <path>", "read input from a file instead of stdin")
+        .option("--target <target>", "output format: markdown (default) or slack", "markdown")
+        .option("--no-validate", "skip workspace validation; wrap every regex match. Faster, but may produce broken links for IDs that don't exist.")
+        .action(handleAsyncCommand(handleWrap));
+}

package/dist/config/config.d.ts

@@ -40,4 +40,6 @@ export interface ElLinearConfig {
      */
     workspaceUrlKey?: string;
 }
+/** Test seam — resets the cache between test cases. */
+export declare function _resetConfigCacheForTests(): void;
 export declare function loadConfig(): ElLinearConfig;