@enrichlayer/el-linear 1.2.0 → 1.4.0

package/README.md

@@ -17,6 +17,8 @@ first-class command.
 
 ## Install
 
+Published on npm as [`@enrichlayer/el-linear`](https://www.npmjs.com/package/@enrichlayer/el-linear).
+
 ```bash
 pnpm add -g @enrichlayer/el-linear
 # or
@@ -76,11 +78,50 @@ The API token is resolved in this order:
 
 1. `--api-token <token>` flag.
 2. `LINEAR_API_TOKEN` environment variable.
-3. `~/.config/el-linear/token` file (recommended for human use).
-4. `~/.linear_api_token` file (legacy, still honored).
+3. **Active profile's** `~/.config/el-linear/profiles/<name>/token` file (see *Profiles* below).
+4. `~/.config/el-linear/token` file (legacy single-profile, recommended for human use when only one workspace is needed).
+5. `~/.linear_api_token` file (legacy, still honored).
 
 el-linear never logs the token.
 
+## Profiles
+
+Use **profiles** to switch between multiple Linear workspaces (e.g.
+day-job and side-project) with separate tokens + configs.
+
+```bash
+# Create a profile + run the init wizard scoped to it.
+# After this finishes, <name> becomes the active profile.
+el-linear profile add forage
+
+# Switch the default at any time:
+el-linear profile use day-job
+el-linear profile current        # → day-job
+el-linear profile list           # all profiles + which is active
+
+# One-off override for a single command:
+el-linear --profile forage issues list
+EL_LINEAR_PROFILE=forage el-linear teams list
+
+# Remove a profile (token + config gone; confirms first):
+el-linear profile remove old-profile
+```
+
+Each profile lives at `~/.config/el-linear/profiles/<name>/` and owns:
+
+- `token` — its Linear API token (mode 0600)
+- `config.json` — its full el-linear config (defaultTeam, terms, etc.)
+
+The active profile is selected by, in priority:
+
+1. `--profile <name>` flag (per-invocation)
+2. `EL_LINEAR_PROFILE` env var
+3. `~/.config/el-linear/active-profile` (one-line marker, written by `profile use`)
+4. Legacy single-file layout (`~/.config/el-linear/{token,config.json}`)
+
+The legacy fallback means **existing single-profile users see no
+behavior change** — profiles are purely opt-in.
+
 ## Configuration
 
 el-linear reads `~/.config/el-linear/config.json` on startup. All keys are
@@ -174,12 +215,43 @@ el-linear <command> --help       # detailed help for one command
 | Releases | `releases {list, read, create, pipelines}` |
 | Files | `embeds {upload, download}`, `attachments {list, create, delete}` |
 | Search | `search <query>` (semantic, cross-resource) |
+| Refs | `refs wrap` (rewrite issue identifiers in arbitrary text as links) |
 | Escape hatch | `graphql [query]` (with `--introspect`) |
 | Config | `config show`, `users list`, `teams list`, `templates list` |
 
 All `list` subcommands support `-l, --limit <n>`. All commands accept the
 top-level filters: `--raw`, `--jq <expr>`, `--fields <list>`.
 
+## Wrapping Linear references in arbitrary text
+
+`el-linear refs wrap` takes plain text on stdin (or via `--file`) and rewrites
+every recognized Linear issue identifier (e.g. `DEV-123`, `LIN-1`) as a real
+link. By default it validates each candidate against the workspace — strings
+that match the `[A-Z]+-\d+` shape but aren't real issues (e.g. `ISO-1424`)
+are left untouched.
+
+```bash
+# stdin → stdout, markdown output (default)
+echo "see DEV-100 and ISO-1424" | el-linear refs wrap
+# → see [DEV-100](https://linear.app/acme/issue/DEV-100/) and ISO-1424
+
+# read from a file
+el-linear refs wrap --file notes.md > notes.linked.md
+
+# Slack mrkdwn output: <url|label>
+el-linear refs wrap --target slack < release-notes.md
+
+# offline regex-only fallback — wraps every match, no API calls,
+# may produce broken links for IDs that don't exist in the workspace
+el-linear refs wrap --no-validate < notes.md
+```
+
+Wrapping is **idempotent** — running it again on already-wrapped output is a
+no-op. Refs are also skipped inside fenced code blocks, inline backticks,
+existing markdown or Slack links, angle-bracket autolinks, and bare URLs, so
+it's safe to pipe documents that already contain a mix of formatted links
+and bare identifiers.
+
 ## Use with Claude Code
 
 el-linear ships a Claude Code skill at `claude-skills/linear-operations/SKILL.md`.

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

@@ -16,3 +16,10 @@
  */
 import type { Command } from "commander";
 export declare function setupInitCommands(program: Command): void;
+/**
+ * Full wizard: walk through all four steps in sequence. Each step writes its
+ * own slice of the config and is restartable on its own.
+ */
+export declare function runFullWizard(options?: {
+    force?: boolean;
+}): Promise<void>;

package/dist/commands/init/index.js

@@ -129,7 +129,11 @@ export function setupInitCommands(program) {
  * Full wizard: walk through all four steps in sequence. Each step writes its
  * own slice of the config and is restartable on its own.
  */
-async function runFullWizard(options) {
+export async function runFullWizard(options = {}) {
+    const opts = { force: options.force ?? false };
+    await runFullWizardImpl(opts);
+}
+async function runFullWizardImpl(options) {
     // biome-ignore lint/suspicious/noConsole: wizard
     console.log("Welcome to el-linear. This wizard will set up your config.");
     // biome-ignore lint/suspicious/noConsole: wizard

package/dist/commands/init/shared.js

@@ -7,9 +7,27 @@
  */
 import { randomBytes } from "node:crypto";
 import fs from "node:fs/promises";
-import { ALIASES_PROGRESS_PATH, CONFIG_DIR, CONFIG_PATH, TOKEN_PATH, } from "../../config/paths.js";
+import path from "node:path";
+import { ALIASES_PROGRESS_PATH, CONFIG_DIR, CONFIG_PATH, resolveActiveProfile, TOKEN_PATH, } from "../../config/paths.js";
 // Re-export for tests and call sites that already pulled the paths from here.
 export { ALIASES_PROGRESS_PATH, CONFIG_PATH, TOKEN_PATH };
+/**
+ * Profile-aware paths for the active wizard run. The wizard always
+ * writes to (and reads from) the active profile — switched via
+ * `EL_LINEAR_PROFILE`, `--profile`, or the on-disk `active-profile`
+ * marker. When no profile is selected, paths fall through to the
+ * legacy single-file layout (CONFIG_PATH / TOKEN_PATH).
+ */
+function activePaths() {
+    const active = resolveActiveProfile();
+    return {
+        // Profile dir is always the directory of configPath (whether
+        // that's the legacy CONFIG_DIR or a per-profile subdirectory).
+        configDir: path.dirname(active.configPath),
+        configPath: active.configPath,
+        tokenPath: active.tokenPath,
+    };
+}
 /**
  * Atomic file write: write to a sibling tmp file then rename. Survives SIGINT,
  * OOM, and laptop suspend mid-write — the original file is either untouched
@@ -38,11 +56,18 @@ async function atomicWrite(targetPath, data, mode = 0o644) {
     }
 }
 export async function ensureConfigDir() {
+    // Always make sure the legacy CONFIG_DIR exists (it's where the
+    // `active-profile` marker + `profiles/` tree live), then make the
+    // active profile's directory if it differs.
     await fs.mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    const dir = activePaths().configDir;
+    if (dir !== CONFIG_DIR) {
+        await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    }
 }
 export async function readConfig() {
     try {
-        const raw = await fs.readFile(CONFIG_PATH, "utf8");
+        const raw = await fs.readFile(activePaths().configPath, "utf8");
         return JSON.parse(raw);
     }
     catch (err) {
@@ -56,11 +81,11 @@ export async function writeConfig(config) {
     await ensureConfigDir();
     // Stable key order so byte-identical config produces byte-identical output.
     const sorted = sortKeys(config);
-    await atomicWrite(CONFIG_PATH, `${JSON.stringify(sorted, null, 2)}\n`, 0o644);
+    await atomicWrite(activePaths().configPath, `${JSON.stringify(sorted, null, 2)}\n`, 0o644);
 }
 export async function readToken() {
     try {
-        const raw = await fs.readFile(TOKEN_PATH, "utf8");
+        const raw = await fs.readFile(activePaths().tokenPath, "utf8");
         return raw.trim() || null;
     }
     catch (err) {
@@ -82,7 +107,7 @@ export async function readToken() {
  */
 export async function writeToken(token) {
     await ensureConfigDir();
-    await atomicWrite(TOKEN_PATH, `${token.trim()}\n`, 0o600);
+    await atomicWrite(activePaths().tokenPath, `${token.trim()}\n`, 0o600);
 }
 /**
  * Build a new object containing only the keys whose values are not `undefined`.

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,185 @@
+/**
+ * `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";
+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);
+    });
+}
+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;

package/dist/config/config.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import { outputWarning } from "../utils/output.js";
-import { CONFIG_PATH } from "./paths.js";
+import { CONFIG_PATH, resolveActiveProfile } from "./paths.js";
 const DEFAULT_CONFIG = {
     defaultTeam: "",
     defaultLabels: [],
@@ -23,13 +23,25 @@ const DEFAULT_CONFIG = {
     terms: [],
 };
 let cachedConfig;
+/** Test seam — resets the cache between test cases. */
+export function _resetConfigCacheForTests() {
+    cachedConfig = undefined;
+}
 export function loadConfig() {
     if (cachedConfig) {
         return cachedConfig;
     }
-    if (fs.existsSync(CONFIG_PATH)) {
+    // Profile-aware: read from <CONFIG_DIR>/profiles/<name>/config.json
+    // when a profile is active, falling back to the legacy single-file
+    // path so existing setups keep working without migration.
+    const active = resolveActiveProfile();
+    const candidates = [active.configPath];
+    if (active.configPath !== CONFIG_PATH)
+        candidates.push(CONFIG_PATH);
+    const sourcePath = candidates.find((p) => fs.existsSync(p));
+    if (sourcePath) {
         try {
-            const userConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"));
+            const userConfig = JSON.parse(fs.readFileSync(sourcePath, "utf8"));
             // Migration: the legacy `brand: { name, reject }` config is auto-promoted to
             // a single entry in `terms[]`. We warn (not throw) so existing users get a
             // grace period to update their config.
@@ -52,12 +64,15 @@ export function loadConfig() {
             cachedConfig = deepMerge(DEFAULT_CONFIG, userConfig);
         }
         catch {
-            outputWarning(`Failed to parse ${CONFIG_PATH}, using empty defaults`);
+            outputWarning(`Failed to parse ${sourcePath}, using empty defaults`);
             cachedConfig = DEFAULT_CONFIG;
         }
     }
     else {
-        outputWarning(`No config found at ${CONFIG_PATH}. Run with --init to create one.`);
+        const profileNote = active.name
+            ? ` (active profile: \`${active.name}\` — expected at ${active.configPath})`
+            : "";
+        outputWarning(`No config found at ${active.configPath}${profileNote}. Run \`el-linear init\` (or \`el-linear profile add ${active.name ?? "<name>"}\`) to create one.`);
         cachedConfig = DEFAULT_CONFIG;
     }
     return cachedConfig;

package/dist/config/paths.d.ts

@@ -18,3 +18,30 @@ export declare const LEGACY_LINCTL_CONFIG_PATH: string;
 export declare const LEGACY_LINCTL_TOKEN_PATH: string;
 /** Even older fallback from before the `~/.config/...` move (one release). */
 export declare const LEGACY_TOKEN_PATH: string;
+export declare const PROFILES_DIR: string;
+export declare const ACTIVE_PROFILE_FILE: string;
+export interface ProfilePaths {
+    /** Profile name; null when using the legacy single-file layout. */
+    name: string | null;
+    configPath: string;
+    tokenPath: string;
+}
+export interface ProfileFsOps {
+    readFileSync: (p: string) => string;
+    existsSync: (p: string) => boolean;
+}
+/**
+ * Set the active profile for the duration of this process. Pass `null`
+ * to clear the override and fall back to env / on-disk markers.
+ */
+export declare function setActiveProfileForSession(name: string | null): void;
+/** Read-only accessor for the per-session override (test seam). */
+export declare function getSessionProfileOverride(): string | null;
+/**
+ * Resolve the active profile name + on-disk paths. Returns the legacy
+ * single-file layout when no profile is selected, so existing setups
+ * keep working without migration.
+ */
+export declare function resolveActiveProfile(env?: NodeJS.ProcessEnv, fsImpl?: ProfileFsOps): ProfilePaths;
+/** Build profile-relative paths for a named profile. Pure. */
+export declare function profilePaths(name: string): ProfilePaths;

package/dist/config/paths.js

@@ -3,6 +3,7 @@
  * config loader, the auth module, and the init wizard all agree on where to
  * read and write.
  */
+import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 export const CONFIG_DIR = path.join(os.homedir(), ".config", "el-linear");
@@ -20,3 +21,79 @@ export const LEGACY_LINCTL_CONFIG_PATH = path.join(LEGACY_LINCTL_CONFIG_DIR, "co
 export const LEGACY_LINCTL_TOKEN_PATH = path.join(LEGACY_LINCTL_CONFIG_DIR, "token");
 /** Even older fallback from before the `~/.config/...` move (one release). */
 export const LEGACY_TOKEN_PATH = path.join(os.homedir(), ".linear_api_token");
+// ---- Profiles --------------------------------------------------------
+//
+// el-linear supports named profiles for switching between Linear
+// workspaces (org A vs org B vs scratch token). Each profile owns its
+// own config + token. The single-profile layout (CONFIG_PATH +
+// TOKEN_PATH above) keeps working unchanged — existing users see no
+// behavior change. A user opts in to multi-profile by either:
+//   - calling `el-linear profile add <name>`, OR
+//   - hand-creating <CONFIG_DIR>/profiles/<name>/{config.json,token}
+//
+// Resolution order (highest priority first):
+//   1. Per-call --profile <name> flag (set via setActiveProfileForSession)
+//   2. EL_LINEAR_PROFILE env var
+//   3. <CONFIG_DIR>/active-profile (single-line text file)
+//   4. Legacy single-file paths (CONFIG_PATH / TOKEN_PATH) — default,
+//      keeps backward compatibility.
+export const PROFILES_DIR = path.join(CONFIG_DIR, "profiles");
+export const ACTIVE_PROFILE_FILE = path.join(CONFIG_DIR, "active-profile");
+const DEFAULT_FS_OPS = {
+    readFileSync: (p) => fs.readFileSync(p, "utf8"),
+    existsSync: (p) => fs.existsSync(p),
+};
+/**
+ * Per-process override for the active profile name. Set by main.ts when
+ * `--profile <name>` is passed (highest priority).
+ */
+let sessionProfileOverride = null;
+/**
+ * Set the active profile for the duration of this process. Pass `null`
+ * to clear the override and fall back to env / on-disk markers.
+ */
+export function setActiveProfileForSession(name) {
+    sessionProfileOverride = name && name.trim().length > 0 ? name.trim() : null;
+}
+/** Read-only accessor for the per-session override (test seam). */
+export function getSessionProfileOverride() {
+    return sessionProfileOverride;
+}
+/**
+ * Resolve the active profile name + on-disk paths. Returns the legacy
+ * single-file layout when no profile is selected, so existing setups
+ * keep working without migration.
+ */
+export function resolveActiveProfile(env = process.env, fsImpl = DEFAULT_FS_OPS) {
+    const explicit = sessionProfileOverride ??
+        (env.EL_LINEAR_PROFILE?.trim() || null) ??
+        readActiveProfileMarker(fsImpl);
+    if (explicit) {
+        return profilePaths(explicit);
+    }
+    return {
+        name: null,
+        configPath: CONFIG_PATH,
+        tokenPath: TOKEN_PATH,
+    };
+}
+/** Build profile-relative paths for a named profile. Pure. */
+export function profilePaths(name) {
+    const dir = path.join(PROFILES_DIR, name);
+    return {
+        name,
+        configPath: path.join(dir, "config.json"),
+        tokenPath: path.join(dir, "token"),
+    };
+}
+function readActiveProfileMarker(fsImpl) {
+    if (!fsImpl.existsSync(ACTIVE_PROFILE_FILE))
+        return null;
+    try {
+        const value = fsImpl.readFileSync(ACTIVE_PROFILE_FILE).toString().trim();
+        return value.length > 0 ? value : null;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/main.js

@@ -13,22 +13,26 @@ import { setupInitCommands } from "./commands/init/index.js";
 import { setupIssueIdCommand } from "./commands/issue-id.js";
 import { setupIssuesCommands } from "./commands/issues.js";
 import { setupLabelsCommands } from "./commands/labels.js";
+import { setupProfileCommands } from "./commands/profile.js";
 import { setupProjectMilestonesCommands } from "./commands/project-milestones.js";
 import { setupProjectsCommands } from "./commands/projects.js";
 import { setupReadShortcut } from "./commands/read-shortcut.js";
+import { setupRefsCommands } from "./commands/refs.js";
 import { setupReleasesCommands } from "./commands/releases.js";
 import { setupSearchCommands } from "./commands/search.js";
 import { setupTeamsCommands } from "./commands/teams.js";
 import { setupTemplatesCommands } from "./commands/templates.js";
 import { setupUsersCommands } from "./commands/users.js";
+import { setActiveProfileForSession } from "./config/paths.js";
 import { setFieldsFilter, setJqFilter, setRawMode } from "./utils/output.js";
 import { outputUsageInfo } from "./utils/usage.js";
 import { splitList } from "./utils/validators.js";
 program
     .name("el-linear")
     .description("A pragmatic CLI for Linear.app — deterministic resolution, structured validation, GraphQL escape hatch.")
-    .version("1.2.0")
+    .version("1.3.0")
     .option("--api-token <token>", "Linear API token")
+    .option("--profile <name>", "named profile (under ~/.config/el-linear/profiles/<name>/) for this invocation. Overrides EL_LINEAR_PROFILE env + the on-disk active-profile marker.")
     .option("--json", "output as JSON (default, accepted for compatibility)")
     .option("--raw", "strip { data, meta } wrapper from list output — emit the array directly")
     .option("--jq <filter>", "apply a jq filter to the JSON output")
@@ -44,6 +48,13 @@ program.hook("preAction", (_thisCommand, actionCommand) => {
     if (rootOpts.fields) {
         setFieldsFilter(splitList(rootOpts.fields));
     }
+    // `--profile <name>` is highest-priority. preAction runs BEFORE the
+    // command body, which is BEFORE getApiToken / loadConfig fire — so
+    // setting the override here means the rest of the run picks up the
+    // right profile's token + config.
+    if (rootOpts.profile) {
+        setActiveProfileForSession(rootOpts.profile);
+    }
 });
 program.action(() => {
     program.help();
@@ -68,6 +79,8 @@ setupGdocCommands(program);
 setupGraphQLCommands(program);
 setupConfigCommands(program);
 setupInitCommands(program);
+setupProfileCommands(program);
+setupRefsCommands(program);
 setupReadShortcut(program);
 program
     .command("usage")

package/dist/utils/auth.js

@@ -1,5 +1,5 @@
 import fs from "node:fs";
-import { LEGACY_LINCTL_TOKEN_PATH, LEGACY_TOKEN_PATH, TOKEN_PATH, } from "../config/paths.js";
+import { LEGACY_LINCTL_TOKEN_PATH, LEGACY_TOKEN_PATH, resolveActiveProfile, TOKEN_PATH, } from "../config/paths.js";
 export function getApiToken(options) {
     if (options.apiToken) {
         return options.apiToken;
@@ -7,7 +7,18 @@ export function getApiToken(options) {
     if (process.env.LINEAR_API_TOKEN) {
         return process.env.LINEAR_API_TOKEN;
     }
-    if (fs.existsSync(TOKEN_PATH)) {
+    // Profile-aware: read from <CONFIG_DIR>/profiles/<name>/token when a
+    // profile is active, falling back to the legacy single-file path
+    // (TOKEN_PATH) for the no-profile case.
+    const active = resolveActiveProfile();
+    if (fs.existsSync(active.tokenPath)) {
+        return fs.readFileSync(active.tokenPath, "utf8").trim();
+    }
+    // Even when a profile is selected, fall through to the legacy token
+    // path so an operator who only has the single-file layout doesn't
+    // suddenly fail. The active-profile name is informational only when
+    // no profile-scoped token exists yet.
+    if (active.tokenPath !== TOKEN_PATH && fs.existsSync(TOKEN_PATH)) {
         return fs.readFileSync(TOKEN_PATH, "utf8").trim();
     }
     // Fallback to the linctl-era token (the CLI was briefly published as
@@ -19,5 +30,8 @@ export function getApiToken(options) {
     if (fs.existsSync(LEGACY_TOKEN_PATH)) {
         return fs.readFileSync(LEGACY_TOKEN_PATH, "utf8").trim();
     }
-    throw new Error("No API token found. Use --api-token, LINEAR_API_TOKEN env var, ~/.config/el-linear/token, or ~/.linear_api_token file");
+    const profileNote = active.name
+        ? ` (active profile: \`${active.name}\` — expected token at ${active.tokenPath})`
+        : "";
+    throw new Error(`No API token found${profileNote}. Use --api-token, LINEAR_API_TOKEN env var, ~/.config/el-linear/token, or ~/.linear_api_token file. To switch profiles, use \`el-linear profile use <name>\` or \`--profile <name>\`.`);
 }

package/dist/utils/issue-reference-wrapper.d.ts

@@ -1,12 +1,26 @@
+/**
+ * Output emitter target. `markdown` produces `[ID](url)`; `slack` produces
+ * Slack mrkdwn `<url|ID>`. New targets (e.g. `html`) can be added to the
+ * discriminated map without touching callers.
+ */
+export type WrapTarget = "markdown" | "slack";
 /**
  * Rewrite `text`, wrapping each occurrence of a known-valid Linear issue identifier
- * as a markdown link. Skips any occurrence inside protected ranges (code blocks,
- * inline code, existing markdown links, angle-bracket autolinks).
+ * as a link in the chosen `target` syntax. Skips any occurrence inside protected
+ * ranges (code blocks, inline code, existing markdown links, Slack links,
+ * angle-bracket autolinks, bare URLs).
  *
  * Only IDs in `validIdentifiers` are wrapped — IDs that don't resolve in the
  * workspace are left as plain text (handles false positives like ISO codes).
  *
- * If `text` already contains `[ID](url)` for a given ID, that occurrence is left
- * alone (it's inside a protected range), so this function is idempotent.
+ * If `text` already contains a wrapped `[ID](url)` or `<url|ID>` for a given ID,
+ * that occurrence is left alone (it's inside a protected range), so this
+ * function is idempotent for the matching target. Running `markdown` then
+ * `slack` (or vice versa) will not re-wrap previously-wrapped IDs because the
+ * existing link's content stays inside a protected range.
+ *
+ * The 3-arg signature is preserved as a positional `target` defaulting to
+ * `"markdown"` for backward compatibility with existing callers
+ * (`issues create/update`, `comments create/update`).
  */
-export declare function wrapIssueReferencesAsLinks(text: string, validIdentifiers: Set<string>, workspaceUrlKey: string): string;
+export declare function wrapIssueReferencesAsLinks(text: string, validIdentifiers: Set<string>, workspaceUrlKey: string, target?: WrapTarget): string;

package/dist/utils/issue-reference-wrapper.js

@@ -9,6 +9,9 @@ const FENCED_CODE_BLOCK_REGEX = /(?:^|\n)([ \t]*)(?:```|~~~)[^\n]*\n[\s\S]*?\n\1
 const INLINE_CODE_REGEX = /`[^`\n]+?`/g;
 // Existing markdown links: [text](url). We protect both the text and the url.
 const MARKDOWN_LINK_REGEX = /\[([^\]]*)\]\(([^)]*)\)/g;
+// Existing Slack mrkdwn links: <url|text>. We protect both halves so identifiers
+// inside an already-wrapped Slack link aren't double-wrapped.
+const SLACK_LINK_REGEX = /<https?:\/\/[^|>\s]+\|[^>]*>/g;
 // Angle-bracket autolinks: <https://...>
 const ANGLE_AUTOLINK_REGEX = /<[^>\s]+>/g;
 // Bare URLs in prose. We protect these so identifiers inside paths
@@ -30,6 +33,11 @@ function findProtectedRanges(text) {
         FENCED_CODE_BLOCK_REGEX,
         INLINE_CODE_REGEX,
         MARKDOWN_LINK_REGEX,
+        // Slack links must be protected before generic angle-bracket autolinks,
+        // otherwise the autolink regex would still match `<https://…|label>` because
+        // it doesn't include the pipe boundary. matchAll resets per regex so order
+        // in this list is irrelevant for correctness — both ranges still cover the span.
+        SLACK_LINK_REGEX,
         ANGLE_AUTOLINK_REGEX,
         BARE_URL_REGEX,
     ]) {
@@ -51,22 +59,41 @@ function isProtected(pos, ranges) {
 function buildIssueUrl(identifier, workspaceUrlKey) {
     return `https://linear.app/${workspaceUrlKey}/issue/${identifier}/`;
 }
+/**
+ * Per-target emitters. Each takes the resolved url and human identifier and
+ * returns the wrapped link string. Add a new target by adding a key here.
+ */
+const EMITTERS = {
+    markdown: (id, url) => `[${id}](${url})`,
+    // Slack mrkdwn link syntax: <url|label>. Reference:
+    // https://api.slack.com/reference/surfaces/formatting#linking-urls
+    slack: (id, url) => `<${url}|${id}>`,
+};
 /**
  * Rewrite `text`, wrapping each occurrence of a known-valid Linear issue identifier
- * as a markdown link. Skips any occurrence inside protected ranges (code blocks,
- * inline code, existing markdown links, angle-bracket autolinks).
+ * as a link in the chosen `target` syntax. Skips any occurrence inside protected
+ * ranges (code blocks, inline code, existing markdown links, Slack links,
+ * angle-bracket autolinks, bare URLs).
  *
  * Only IDs in `validIdentifiers` are wrapped — IDs that don't resolve in the
  * workspace are left as plain text (handles false positives like ISO codes).
  *
- * If `text` already contains `[ID](url)` for a given ID, that occurrence is left
- * alone (it's inside a protected range), so this function is idempotent.
+ * If `text` already contains a wrapped `[ID](url)` or `<url|ID>` for a given ID,
+ * that occurrence is left alone (it's inside a protected range), so this
+ * function is idempotent for the matching target. Running `markdown` then
+ * `slack` (or vice versa) will not re-wrap previously-wrapped IDs because the
+ * existing link's content stays inside a protected range.
+ *
+ * The 3-arg signature is preserved as a positional `target` defaulting to
+ * `"markdown"` for backward compatibility with existing callers
+ * (`issues create/update`, `comments create/update`).
  */
-export function wrapIssueReferencesAsLinks(text, validIdentifiers, workspaceUrlKey) {
+export function wrapIssueReferencesAsLinks(text, validIdentifiers, workspaceUrlKey, target = "markdown") {
     if (!text || validIdentifiers.size === 0) {
         return text;
     }
     const ranges = findProtectedRanges(text);
+    const emit = EMITTERS[target];
     // Walk through matches and build the result string in pieces.
     // We can't use String.replace with a callback because we need positional protection checks.
     let result = "";
@@ -83,7 +110,7 @@ export function wrapIssueReferencesAsLinks(text, validIdentifiers, workspaceUrlK
         }
         // Append everything up to this match unchanged
         result += text.slice(cursor, start);
-        result += `[${id}](${buildIssueUrl(id, workspaceUrlKey)})`;
+        result += emit(id, buildIssueUrl(id, workspaceUrlKey));
         cursor = end;
     }
     result += text.slice(cursor);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enrichlayer/el-linear",
-  "version": "1.2.0",
+  "version": "1.4.0",
   "description": "A pragmatic CLI for Linear.app — deterministic team/label/member resolution, structured issue validation, configurable term enforcement, and a GraphQL escape hatch.",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",
@@ -52,11 +52,11 @@
     "picocolors": "^1.1.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.4.0",
+    "@biomejs/biome": "^2.4.14",
     "@types/node": "^25.0.0",
     "graphql": "^16.0.0",
-    "tsx": "^4.20.5",
-    "typescript": "^5.0.0",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3",
     "vitest": "^4.0.18"
   },
   "scripts": {