@enrichlayer/el-linear 1.2.0

package/dist/commands/releases.js

@@ -0,0 +1,142 @@
+import { CREATE_RELEASE_MUTATION, GET_RELEASE_BY_ID_QUERY, GET_RELEASE_PIPELINES_QUERY, GET_RELEASES_QUERY, } from "../queries/releases.js";
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+function transformRelease(release) {
+    return {
+        id: release.id,
+        name: release.name,
+        description: release.description || undefined,
+        version: release.version || undefined,
+        url: release.url || undefined,
+        startDate: release.startDate || undefined,
+        targetDate: release.targetDate || undefined,
+        startedAt: release.startedAt || undefined,
+        completedAt: release.completedAt || undefined,
+        canceledAt: release.canceledAt || undefined,
+        stage: release.stage
+            ? {
+                id: release.stage.id,
+                name: release.stage.name,
+                type: release.stage.type,
+            }
+            : undefined,
+        pipeline: release.pipeline
+            ? {
+                id: release.pipeline.id,
+                name: release.pipeline.name,
+            }
+            : undefined,
+        documents: release.documents?.nodes?.map((d) => ({
+            id: d.id,
+            title: d.title,
+            slugId: d.slugId,
+        })),
+        createdAt: release.createdAt,
+        updatedAt: release.updatedAt,
+    };
+}
+async function handleCreateRelease(name, options, command) {
+    const rootOpts = command.parent.parent.opts();
+    const graphQLService = createGraphQLService(rootOpts);
+    const pipelines = await graphQLService.rawRequest(GET_RELEASE_PIPELINES_QUERY, { first: 50 });
+    const pipelineNodes = pipelines.releasePipelines
+        ?.nodes;
+    const pipeline = pipelineNodes?.find((p) => p.id === options.pipeline ||
+        p.name.toLowerCase() === options.pipeline.toLowerCase());
+    if (!pipeline) {
+        const available = (pipelineNodes ?? [])
+            .map((p) => p.name)
+            .join(", ");
+        throw new Error(`Pipeline "${options.pipeline}" not found. Available: ${available || "none"}`);
+    }
+    const input = { name, pipelineId: pipeline.id };
+    if (options.description) {
+        input.description = options.description;
+    }
+    if (options.version) {
+        input.version = options.version;
+    }
+    if (options.stage) {
+        const stageNodes = pipeline.stages?.nodes;
+        const stage = stageNodes?.find((s) => s.id === options.stage ||
+            s.name.toLowerCase() === options.stage.toLowerCase());
+        if (stage) {
+            input.stageId = stage.id;
+        }
+    }
+    const result = await graphQLService.rawRequest(CREATE_RELEASE_MUTATION, {
+        input,
+    });
+    const releaseCreate = result.releaseCreate;
+    if (!releaseCreate?.success) {
+        throw new Error(`Failed to create release "${name}"`);
+    }
+    outputSuccess(transformRelease(releaseCreate.release));
+}
+export function setupReleasesCommands(program) {
+    const releases = program
+        .command("releases")
+        .description("Release operations");
+    releases.action(() => releases.help());
+    releases
+        .command("list")
+        .description("List releases")
+        .option("--pipeline <pipeline>", "filter by pipeline name or ID")
+        .option("-l, --limit <number>", "limit results", "25")
+        .action(handleAsyncCommand(async (options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const graphQLService = createGraphQLService(rootOpts);
+        const filter = {};
+        if (options.pipeline) {
+            filter.pipeline = { name: { eqIgnoreCase: options.pipeline } };
+        }
+        const result = await graphQLService.rawRequest(GET_RELEASES_QUERY, {
+            first: Number.parseInt(options.limit, 10),
+            filter: Object.keys(filter).length > 0 ? filter : undefined,
+        });
+        const data = (result.releases
+            ?.nodes ?? []).map(transformRelease);
+        outputSuccess({ data, meta: { count: data.length } });
+    }));
+    releases
+        .command("read <releaseId>")
+        .description("Get release details including linked documents")
+        .action(handleAsyncCommand(async (releaseId, _options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const graphQLService = createGraphQLService(rootOpts);
+        const result = await graphQLService.rawRequest(GET_RELEASE_BY_ID_QUERY, { id: releaseId });
+        if (!result.release) {
+            throw new Error(`Release "${releaseId}" not found`);
+        }
+        outputSuccess(transformRelease(result.release));
+    }));
+    releases
+        .command("create <name>")
+        .description("Create a new release")
+        .requiredOption("--pipeline <pipeline>", "pipeline name or ID")
+        .option("-d, --description <desc>", "release description")
+        .option("--version <version>", "version string")
+        .option("--stage <stage>", "stage name or ID")
+        .action(handleAsyncCommand(handleCreateRelease));
+    releases
+        .command("pipelines")
+        .description("List release pipelines and their stages")
+        .action(handleAsyncCommand(async (_options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const graphQLService = createGraphQLService(rootOpts);
+        const result = await graphQLService.rawRequest(GET_RELEASE_PIPELINES_QUERY, { first: 50 });
+        const data = (result.releasePipelines
+            ?.nodes ?? []).map((p) => ({
+            id: p.id,
+            name: p.name,
+            stages: (p.stages
+                ?.nodes ?? []).map((s) => ({
+                id: s.id,
+                name: s.name,
+                type: s.type,
+                color: s.color,
+            })),
+        }));
+        outputSuccess({ data, meta: { count: data.length } });
+    }));
+}

package/dist/commands/search.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupSearchCommands(program: Command): void;

package/dist/commands/search.js

@@ -0,0 +1,171 @@
+import { resolveTeam, resolveUserDisplayName } from "../config/resolver.js";
+import { SEMANTIC_SEARCH_QUERY } from "../queries/search.js";
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+const TEMPLATES_QUERY = `
+  query {
+    templates {
+      id
+      name
+      type
+      description
+      team { key }
+      creator { name }
+    }
+  }
+`;
+const VALID_TYPES = new Set([
+    "issue",
+    "project",
+    "initiative",
+    "document",
+    "template",
+]);
+const WHITESPACE_RE = /\s+/;
+function transformSearchResult(r) {
+    const rType = r.type;
+    switch (rType) {
+        case "issue": {
+            const issue = r.issue;
+            const state = issue?.state;
+            const team = issue?.team;
+            const assignee = issue?.assignee;
+            const project = issue?.project;
+            return {
+                type: "issue",
+                identifier: issue?.identifier,
+                title: issue?.title,
+                state: state?.name,
+                team: team?.key,
+                assignee: assignee
+                    ? resolveUserDisplayName(assignee.id, assignee.name)
+                    : undefined,
+                priority: issue?.priority,
+                project: project?.name,
+                id: issue?.id,
+            };
+        }
+        case "project": {
+            const project = r.project;
+            return {
+                type: "project",
+                name: project?.name,
+                state: project?.state,
+                id: project?.id,
+            };
+        }
+        case "initiative": {
+            const initiative = r.initiative;
+            return {
+                type: "initiative",
+                name: initiative?.name,
+                status: initiative?.status,
+                id: initiative?.id,
+            };
+        }
+        case "document": {
+            const doc = r.document;
+            const docProject = doc?.project;
+            return {
+                type: "document",
+                title: doc?.title,
+                project: docProject?.name,
+                slugId: doc?.slugId,
+                id: doc?.id,
+            };
+        }
+        default:
+            return { type: rType, id: null };
+    }
+}
+function matchesQuery(name, query) {
+    const lower = name.toLowerCase();
+    const terms = query.toLowerCase().split(WHITESPACE_RE);
+    return terms.every((term) => lower.includes(term));
+}
+function searchTemplates(templates, query) {
+    return templates
+        .filter((t) => matchesQuery(t.name, query) ||
+        (t.description && matchesQuery(t.description, query)))
+        .map((t) => ({
+        type: "template",
+        name: t.name,
+        templateType: t.type,
+        team: t.team?.key ?? null,
+        creator: t.creator?.name ?? null,
+        id: t.id,
+    }));
+}
+function validateTypes(requestedTypes) {
+    for (const t of requestedTypes) {
+        if (!VALID_TYPES.has(t)) {
+            throw new Error(`Invalid type "${t}". Valid types: ${[...VALID_TYPES].join(", ")}`);
+        }
+    }
+}
+function parseTypeFilters(requestedTypes) {
+    const onlyTemplates = requestedTypes?.length === 1 && requestedTypes[0] === "template";
+    const includeTemplates = !requestedTypes || requestedTypes.includes("template");
+    const includeSemanticTypes = !requestedTypes || requestedTypes.some((t) => t !== "template");
+    return { onlyTemplates, includeTemplates, includeSemanticTypes };
+}
+function buildSemanticQuery(graphQLService, query, limit, teamOption) {
+    const filters = {};
+    if (teamOption) {
+        filters.issues = { team: { id: { eq: resolveTeam(teamOption) } } };
+    }
+    return graphQLService.rawRequest(SEMANTIC_SEARCH_QUERY, {
+        query,
+        maxResults: limit,
+        filters: Object.keys(filters).length > 0 ? filters : undefined,
+    });
+}
+function extractSemanticResults(semanticResult, requestedTypes, onlyTemplates) {
+    const semanticSearch = semanticResult.semanticSearch;
+    let results = semanticSearch?.results ?? [];
+    if (requestedTypes && !onlyTemplates) {
+        const semanticTypes = requestedTypes.filter((t) => t !== "template");
+        results = results.filter((r) => semanticTypes.includes(r.type));
+    }
+    return results.map(transformSearchResult);
+}
+export function setupSearchCommands(program) {
+    program
+        .command("search <query>")
+        .description("Natural language search across issues, projects, initiatives, documents, and templates.")
+        .option("--type <types>", "filter by type (comma-separated: issue,project,initiative,document,template)")
+        .option("--team <team>", "filter issue results by team key")
+        .option("-l, --limit <number>", "max results", "10")
+        .action(handleAsyncCommand(async (query, options, command) => {
+        const rootOpts = command.parent.opts();
+        const graphQLService = createGraphQLService(rootOpts);
+        const limit = Number.parseInt(options.limit, 10);
+        const requestedTypes = options.type
+            ? options.type.split(",").map((t) => t.trim().toLowerCase())
+            : null;
+        if (requestedTypes) {
+            validateTypes(requestedTypes);
+        }
+        const { onlyTemplates, includeTemplates, includeSemanticTypes } = parseTypeFilters(requestedTypes);
+        const [semanticResult, templateResult] = await Promise.all([
+            includeSemanticTypes
+                ? buildSemanticQuery(graphQLService, query, limit, options.team)
+                : null,
+            includeTemplates
+                ? graphQLService.rawRequest(TEMPLATES_QUERY)
+                : null,
+        ]);
+        let data = [];
+        if (semanticResult) {
+            data = extractSemanticResults(semanticResult, requestedTypes, onlyTemplates ?? false);
+        }
+        if (templateResult) {
+            const templates = templateResult.templates ?? [];
+            data = [...data, ...searchTemplates(templates, query)];
+        }
+        outputSuccess({
+            data: data.slice(0, limit),
+            meta: { count: Math.min(data.length, limit), query },
+        });
+    }));
+}

package/dist/commands/teams.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupTeamsCommands(program: Command): void;

package/dist/commands/teams.js

@@ -0,0 +1,19 @@
+import { createLinearService } from "../utils/linear-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+export function setupTeamsCommands(program) {
+    const teams = program
+        .command("teams")
+        .alias("team")
+        .description("Team operations");
+    teams.action(() => teams.help());
+    teams
+        .command("list")
+        .description("List all teams")
+        .option("-l, --limit <number>", "limit results", "100")
+        .action(handleAsyncCommand(async (options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const service = createLinearService(rootOpts);
+        const result = await service.getTeams(Number.parseInt(options.limit, 10));
+        outputSuccess({ data: result, meta: { count: result.length } });
+    }));
+}

package/dist/commands/templates.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupTemplatesCommands(program: Command): void;

package/dist/commands/templates.js

@@ -0,0 +1,58 @@
+import { TEMPLATE_BY_ID_QUERY, TEMPLATES_LIST_QUERY, } from "../queries/templates.js";
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { parsePositiveInt } from "../utils/validators.js";
+function formatTemplateSummary(t) {
+    return {
+        id: t.id,
+        name: t.name,
+        type: t.type,
+        description: t.description,
+        team: t.team?.key ?? null,
+        creator: t.creator?.name ?? null,
+        updatedAt: t.updatedAt,
+    };
+}
+export function setupTemplatesCommands(program) {
+    const templates = program
+        .command("templates")
+        .description("Template operations (issue, document, and project templates)");
+    templates.action(() => templates.help());
+    templates
+        .command("list")
+        .alias("ls")
+        .description("List all templates")
+        .option("--type <type>", "filter by type (issue, document, project, recurringIssue)")
+        .option("-l, --limit <number>", "limit results", "50")
+        .action(handleAsyncCommand(async (options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const graphQLService = createGraphQLService(rootOpts);
+        const limit = parsePositiveInt(options.limit, "--limit");
+        const result = await graphQLService.rawRequest(TEMPLATES_LIST_QUERY);
+        let items = result.templates ?? [];
+        if (options.type) {
+            const filterType = options.type.toLowerCase();
+            items = items.filter((t) => t.type.toLowerCase() === filterType);
+        }
+        items = items.slice(0, limit);
+        outputSuccess({
+            data: items.map(formatTemplateSummary),
+            meta: { count: items.length },
+        });
+    }));
+    templates
+        .command("read <templateId>")
+        .description("Read a template including its full content (templateData)")
+        .action(handleAsyncCommand(async (templateId, _options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const graphQLService = createGraphQLService(rootOpts);
+        const result = await graphQLService.rawRequest(TEMPLATE_BY_ID_QUERY, {
+            id: templateId,
+        });
+        const template = result.template;
+        if (!template) {
+            throw new Error(`Template "${templateId}" not found`);
+        }
+        outputSuccess(template);
+    }));
+}

package/dist/commands/users.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupUsersCommands(program: Command): void;

package/dist/commands/users.js

@@ -0,0 +1,17 @@
+import { createLinearService } from "../utils/linear-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+export function setupUsersCommands(program) {
+    const users = program.command("users").description("User operations");
+    users.action(() => users.help());
+    users
+        .command("list")
+        .description("List all users")
+        .option("--active", "Only show active users")
+        .option("-l, --limit <number>", "limit results", "100")
+        .action(handleAsyncCommand(async (options, command) => {
+        const rootOpts = command.parent.parent.opts();
+        const service = createLinearService(rootOpts);
+        const result = await service.getUsers(options.active, Number.parseInt(options.limit, 10));
+        outputSuccess({ data: result, meta: { count: result.length } });
+    }));
+}

package/dist/config/config.d.ts

@@ -0,0 +1,43 @@
+import type { TermRule } from "./term-enforcer.js";
+/**
+ * Canonical shape of `~/.config/el-linear/config.json`. This is the single source
+ * of truth for the on-disk config — the wizard reads/writes the same shape
+ * (as `Partial<ElLinearConfig>` since wizard runs may only set a subset).
+ */
+export interface ElLinearConfig {
+    defaultLabels: string[];
+    defaultTeam: string;
+    labels: {
+        workspace: Record<string, string>;
+        teams: Record<string, Record<string, string>>;
+    };
+    members: {
+        aliases: Record<string, string>;
+        fullNames: Record<string, string>;
+        handles: Record<string, Record<string, string>>;
+        uuids: Record<string, string>;
+    };
+    statusDefaults: {
+        noProject: string;
+        withAssigneeAndProject: string;
+    };
+    teamAliases: Record<string, string>;
+    teams: Record<string, string>;
+    /**
+     * Term-enforcement rules. Each rule has a canonical form and a list of
+     * rejected forms; rejected forms in issue titles/descriptions are flagged
+     * (or thrown on, in strict mode) with a hint to use the canonical form.
+     */
+    terms: TermRule[];
+    validation?: {
+        enabled: boolean;
+        typeLabels?: string[];
+    };
+    /**
+     * Optional override for the Linear workspace URL key (the part after
+     * `linear.app/` in issue URLs). When omitted, el-linear queries the Linear API
+     * once per session and caches the result.
+     */
+    workspaceUrlKey?: string;
+}
+export declare function loadConfig(): ElLinearConfig;

package/dist/config/config.js

@@ -0,0 +1,81 @@
+import fs from "node:fs";
+import { outputWarning } from "../utils/output.js";
+import { CONFIG_PATH } from "./paths.js";
+const DEFAULT_CONFIG = {
+    defaultTeam: "",
+    defaultLabels: [],
+    members: {
+        aliases: {},
+        fullNames: {},
+        handles: {},
+        uuids: {},
+    },
+    teams: {},
+    teamAliases: {},
+    labels: {
+        workspace: {},
+        teams: {},
+    },
+    statusDefaults: {
+        noProject: "Triage",
+        withAssigneeAndProject: "Todo",
+    },
+    terms: [],
+};
+let cachedConfig;
+export function loadConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    if (fs.existsSync(CONFIG_PATH)) {
+        try {
+            const userConfig = JSON.parse(fs.readFileSync(CONFIG_PATH, "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.
+            if (userConfig.brand &&
+                typeof userConfig.brand === "object" &&
+                !Array.isArray(userConfig.brand)) {
+                const legacy = userConfig.brand;
+                if (typeof legacy.name === "string" && Array.isArray(legacy.reject)) {
+                    outputWarning("config.brand is deprecated — replace it with config.terms = [{ canonical, reject }]. See README#term-enforcer.");
+                    const existing = Array.isArray(userConfig.terms)
+                        ? userConfig.terms
+                        : [];
+                    userConfig.terms = [
+                        ...existing,
+                        { canonical: legacy.name, reject: legacy.reject },
+                    ];
+                }
+                delete userConfig.brand;
+            }
+            cachedConfig = deepMerge(DEFAULT_CONFIG, userConfig);
+        }
+        catch {
+            outputWarning(`Failed to parse ${CONFIG_PATH}, using empty defaults`);
+            cachedConfig = DEFAULT_CONFIG;
+        }
+    }
+    else {
+        outputWarning(`No config found at ${CONFIG_PATH}. Run with --init to create one.`);
+        cachedConfig = DEFAULT_CONFIG;
+    }
+    return cachedConfig;
+}
+function deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+        if (source[key] &&
+            typeof source[key] === "object" &&
+            !Array.isArray(source[key]) &&
+            target[key] &&
+            typeof target[key] === "object" &&
+            !Array.isArray(target[key])) {
+            result[key] = deepMerge(target[key], source[key]);
+        }
+        else {
+            result[key] = source[key];
+        }
+    }
+    return result;
+}

package/dist/config/issue-validation.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Issue creation validation — Phase 1 of DEV-3708.
+ *
+ * Enforces structural requirements (type labels, description, label normalization)
+ * at the CLI level rather than relying on LLM skill prompts.
+ *
+ * Gated behind `validation.enabled` in config so it can be rolled out per-user
+ * before becoming the default for the team.
+ */
+export interface ValidationResult {
+    errors: string[];
+    warnings: string[];
+    /** Labels after normalization (aliases resolved, case fixed). */
+    normalizedLabels: string[] | null;
+}
+export interface ValidationInput {
+    labels: string[] | null;
+    description: string | undefined;
+    title: string;
+    assignee: string | undefined;
+    project: string | undefined;
+}
+/**
+ * Normalize a label name: resolve known aliases and fix casing.
+ * Returns the canonical form if an alias exists, otherwise the original.
+ */
+export declare function normalizeLabel(label: string): string;
+/**
+ * Validate issue creation inputs. Returns errors (block creation) and warnings (informational).
+ *
+ * Only runs when `validation.enabled` is true in config.
+ * Bypass entirely with `--no-validate`.
+ */
+export declare function validateIssueCreation(input: ValidationInput): ValidationResult;
+/**
+ * Apply validation results: emit warnings, throw on errors.
+ * Called from the create command unless `--no-validate` is set.
+ */
+export declare function enforceValidation(result: ValidationResult): void;