@10et/cli 1.0.0

package/dist/commands/linear.js

@@ -0,0 +1,740 @@
+/**
+ * jfl linear — Linear project sync
+ *
+ * Bidirectional sync between Linear projects and GitHub Issues (jfl kanban).
+ * Subcommands: link, unlink, status, sync
+ *
+ * @purpose CLI commands for Linear ↔ GitHub kanban bidirectional sync
+ */
+import chalk from "chalk";
+import ora from "ora";
+import inquirer from "inquirer";
+import { execSync } from "child_process";
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { join } from "path";
+import { getLinearClient, getLinearTeams, getLinearProjects, getTeamStates, getProjectIssues, createLinearIssue, updateLinearIssue, } from "../lib/linear-client.js";
+import { readMap, writeMap, addMapping, } from "../lib/linear-id-map.js";
+import { linearToTenet, kanbanToTenet, tenetToLinearCreate, tenetToGitHubBody, tenetToGitHubLabels, findLinearStateId, } from "../lib/linear-kanban.js";
+import { GitHubKanban } from "../lib/kanban-github.js";
+import { getProjectDataDir } from "../utils/jfl-config.js";
+import { TENET_PLATFORM_URL } from "../utils/tenet-env.js";
+// ============================================================================
+// Helpers
+// ============================================================================
+function gh(args, cwd) {
+    return execSync(`gh ${args}`, {
+        cwd,
+        encoding: "utf-8",
+        timeout: 15000,
+        stdio: ["pipe", "pipe", "pipe"],
+    }).trim();
+}
+function readProjectConfig(projectRoot) {
+    const dataDir = getProjectDataDir(projectRoot);
+    const configPath = join(projectRoot, dataDir, "config.json");
+    if (!existsSync(configPath))
+        return {};
+    try {
+        return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeProjectConfig(projectRoot, config) {
+    const dataDir = getProjectDataDir(projectRoot);
+    const configPath = join(projectRoot, dataDir, "config.json");
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n");
+}
+// Env vars override file config — enables CI/GitHub Actions usage without .jfl/config.json
+function requireLinearConfig(projectRoot) {
+    const config = readProjectConfig(projectRoot);
+    const base = config.linear ?? {};
+    const merged = {
+        apiKey: process.env.LINEAR_API_KEY ?? base.apiKey ?? "",
+        teamId: process.env.LINEAR_TEAM_ID ?? base.teamId ?? "",
+        projectId: process.env.LINEAR_PROJECT_ID ?? base.projectId ?? "",
+        scope: process.env.LINEAR_SCOPE ?? base.scope,
+        kanbanRepo: base.kanbanRepo,
+        webhookUrl: base.webhookUrl,
+        syncEnabled: base.syncEnabled,
+        teamName: base.teamName,
+        projectName: base.projectName,
+    };
+    if (!merged.apiKey || !merged.teamId || !merged.projectId) {
+        console.error(chalk.red("No Linear config found. Run: jfl linear link  (or set LINEAR_API_KEY, LINEAR_TEAM_ID, LINEAR_PROJECT_ID env vars)"));
+        process.exit(1);
+    }
+    return merged;
+}
+function getGitHubRepo(projectRoot) {
+    try {
+        const remote = execSync("git remote get-url origin", {
+            cwd: projectRoot, encoding: "utf-8", timeout: 5000,
+        }).trim();
+        const match = remote.match(/github\.com[:/](.+?)(?:\.git)?$/);
+        return match ? match[1] : "";
+    }
+    catch {
+        return "";
+    }
+}
+function getColumnLabel(status) {
+    const map = {
+        backlog: "jfl/backlog",
+        in_progress: "jfl/in-progress",
+        eval: "jfl/eval",
+        done: "jfl/done",
+    };
+    return map[status] ?? "jfl/backlog";
+}
+// ============================================================================
+// jfl linear link
+// ============================================================================
+export async function linearLink(projectRoot) {
+    console.log(chalk.bold("\n  Link Linear Project\n"));
+    const { apiKey } = await inquirer.prompt([
+        {
+            type: "password",
+            name: "apiKey",
+            message: "Linear API key (lin_api_...):",
+            validate: (v) => v.startsWith("lin_api_") ? true : "Must start with lin_api_",
+        },
+    ]);
+    const spinner = ora("Fetching Linear teams...").start();
+    let client;
+    let teams;
+    try {
+        client = getLinearClient(apiKey);
+        teams = await getLinearTeams(client);
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail("Failed to connect to Linear: " + (err.message ?? err));
+        return;
+    }
+    if (teams.length === 0) {
+        console.error(chalk.red("No Linear teams found for this API key."));
+        return;
+    }
+    const { teamId } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "teamId",
+            message: "Select Linear team:",
+            choices: teams.map(t => ({ name: `${t.name} (${t.key})`, value: t.id })),
+        },
+    ]);
+    spinner.start("Fetching Linear projects...");
+    let projects;
+    try {
+        projects = await getLinearProjects(client, teamId);
+        spinner.stop();
+    }
+    catch (err) {
+        spinner.fail("Failed to fetch projects: " + (err.message ?? err));
+        return;
+    }
+    if (projects.length === 0) {
+        console.error(chalk.red("No Linear projects found for this team."));
+        console.log(chalk.gray("  Create a project in Linear first, then run jfl linear link again."));
+        return;
+    }
+    const { projectId } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "projectId",
+            message: "Select Linear project:",
+            choices: projects.map(p => ({
+                name: p.description ? `${p.name} — ${p.description.slice(0, 50)}` : p.name,
+                value: p.id,
+            })),
+        },
+    ]);
+    // ── Scope detection ────────────────────────────────────────────────────────
+    // Detect if we're in a service (has gtm_parent) or a GTM with registered services.
+    // Linear project → JFL scope is a natural 1:1 mapping.
+    const projectConfig = readProjectConfig(projectRoot);
+    const registeredServices = projectConfig.registered_services ?? [];
+    const gtmParent = projectConfig.gtm_parent;
+    // Determine kanban repo: if this is a service, the kanban lives in the parent GTM
+    let kanbanRoot = projectRoot;
+    let kanbanRepoHint = "";
+    if (gtmParent && existsSync(gtmParent)) {
+        kanbanRoot = gtmParent;
+        kanbanRepoHint = getGitHubRepo(gtmParent);
+    }
+    const detectedRepo = getGitHubRepo(kanbanRoot) || kanbanRepoHint;
+    // Scope detection — build list of available scopes
+    const availableScopes = [];
+    if (gtmParent) {
+        // Service context — scope is this service's name
+        const { basename } = await import("path");
+        const serviceName = projectConfig.name ?? basename(projectRoot);
+        availableScopes.push(serviceName);
+    }
+    else if (registeredServices.length > 0) {
+        for (const svc of registeredServices)
+            availableScopes.push(svc.name);
+    }
+    let scopes = [];
+    if (availableScopes.length > 0) {
+        const checkboxChoices = [
+            { name: chalk.dim("— no scope (all issues, no service label) —"), value: "__none__" },
+            new inquirer.Separator("  "),
+            ...availableScopes.map(s => ({ name: `scope:${s}`, value: s })),
+        ];
+        const answer = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "scopes",
+                message: "Which scopes should this Linear project sync to? (space to select, enter to confirm)",
+                choices: checkboxChoices,
+                validate: (v) => true,
+            },
+        ]);
+        // Filter out the sentinel none value
+        scopes = answer.scopes.filter(s => s !== "__none__");
+    }
+    // Build webhook URL(s): one per scope (or one without scope if none selected)
+    const platformUrl = TENET_PLATFORM_URL || "https://tenet.ai";
+    const baseUrl = detectedRepo
+        ? `${platformUrl}/api/webhooks/linear?repo=${detectedRepo}`
+        : `${platformUrl}/api/webhooks/linear?repo=owner/repo`;
+    const defaultWebhookUrl = scopes.length > 0
+        ? scopes.map(s => `${baseUrl}&scope=${s}`).join("\n")
+        : baseUrl;
+    const { webhookUrl } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "webhookUrl",
+            message: "Webhook URL for real-time sync (press enter to accept or skip):",
+            default: scopes.length === 1 ? defaultWebhookUrl : defaultWebhookUrl.split("\n")[0],
+        },
+    ]);
+    // Save config
+    const config = readProjectConfig(projectRoot);
+    const team = teams.find(t => t.id === teamId);
+    const project = projects.find(p => p.id === projectId);
+    config.linear = {
+        apiKey,
+        teamId,
+        teamName: team.name,
+        projectId,
+        projectName: project.name,
+        scopes: scopes.length > 0 ? scopes : undefined,
+        scope: scopes.length === 1 ? scopes[0] : undefined, // legacy compat
+        kanbanRepo: detectedRepo || undefined,
+        webhookUrl: webhookUrl || undefined,
+        syncEnabled: true,
+        linkedAt: new Date().toISOString(),
+    };
+    writeProjectConfig(projectRoot, config);
+    // Initialize map
+    const existingMap = readMap(projectRoot);
+    writeMap(projectRoot, {
+        ...existingMap,
+        projectId,
+        teamId,
+        mappings: existingMap.mappings ?? {},
+    });
+    console.log();
+    console.log(chalk.green(`  ✓ Linked to Linear project: ${project.name} (team: ${team.name})`));
+    if (scopes.length > 0)
+        console.log(chalk.gray(`  Scopes: ${scopes.map(s => `scope:${s}`).join(", ")}`));
+    if (detectedRepo)
+        console.log(chalk.gray(`  Kanban repo: ${detectedRepo}`));
+    if (scopes.length > 1) {
+        console.log(chalk.yellow("  → Register one webhook URL per scope in Linear: Settings → API → Webhooks"));
+        for (const s of scopes)
+            console.log(chalk.gray(`    ${baseUrl}&scope=${s}`));
+    }
+    else if (webhookUrl) {
+        console.log(chalk.gray(`  Webhook URL: ${webhookUrl}`));
+        console.log(chalk.yellow("  → Register this URL in Linear: Settings → API → Webhooks"));
+    }
+    console.log();
+    console.log(chalk.gray("  Run 'jfl linear sync' to do an initial sync"));
+    console.log();
+}
+// ============================================================================
+// jfl linear unlink
+// ============================================================================
+export async function linearUnlink(projectRoot) {
+    const config = readProjectConfig(projectRoot);
+    if (!config.linear) {
+        console.log(chalk.gray("No Linear project linked."));
+        return;
+    }
+    const { confirm } = await inquirer.prompt([
+        {
+            type: "confirm",
+            name: "confirm",
+            message: `Unlink Linear project "${config.linear.projectName}"?`,
+            default: false,
+        },
+    ]);
+    if (!confirm)
+        return;
+    delete config.linear;
+    writeProjectConfig(projectRoot, config);
+    console.log(chalk.green("  ✓ Unlinked Linear project"));
+}
+// ============================================================================
+// jfl linear status
+// ============================================================================
+export async function linearStatus(projectRoot) {
+    const config = readProjectConfig(projectRoot);
+    if (!config.linear) {
+        console.log(chalk.gray("\n  No Linear project linked. Run: jfl linear link\n"));
+        return;
+    }
+    const { teamName, projectName, linkedAt, webhookUrl, syncEnabled } = config.linear;
+    const map = readMap(projectRoot);
+    const mappingCount = Object.keys(map.mappings).length;
+    console.log(chalk.bold("\n  Linear Sync Status\n"));
+    console.log(`  Project:   ${chalk.cyan(projectName)} (team: ${teamName})`);
+    console.log(`  Linked:    ${chalk.gray(new Date(linkedAt).toLocaleString())}`);
+    console.log(`  Sync:      ${syncEnabled ? chalk.green("enabled") : chalk.yellow("disabled")}`);
+    console.log(`  Webhook:   ${webhookUrl ? chalk.gray(webhookUrl) : chalk.yellow("not configured")}`);
+    console.log(`  Mapped:    ${chalk.bold(String(mappingCount))} issues`);
+    console.log();
+    if (mappingCount > 0) {
+        const repo = getGitHubRepo(projectRoot);
+        console.log(chalk.gray("  Issue Mappings:"));
+        for (const [ghNum, linearId] of Object.entries(map.mappings).slice(0, 10)) {
+            const linearUrl = `https://linear.app/issue/${linearId}`;
+            console.log(chalk.gray(`    GitHub #${ghNum} ↔ ${linearId}`));
+        }
+        if (mappingCount > 10) {
+            console.log(chalk.gray(`    ... and ${mappingCount - 10} more`));
+        }
+    }
+    console.log();
+}
+// ============================================================================
+// jfl linear sync
+// ============================================================================
+export async function linearSync(projectRoot, options) {
+    const linearConfig = requireLinearConfig(projectRoot);
+    const jsonMode = options.json ?? false;
+    // Resolve kanban root: service → parent GTM, otherwise this repo
+    const projectConf = readProjectConfig(projectRoot);
+    const gtmParent = linearConfig.kanbanRepo
+        ? undefined
+        : projectConf.gtm_parent;
+    const kanbanRoot = gtmParent && existsSync(gtmParent) ? gtmParent : projectRoot;
+    const repo = linearConfig.kanbanRepo ?? getGitHubRepo(kanbanRoot);
+    if (!repo) {
+        console.error(chalk.red("Cannot determine GitHub repo. Set kanbanRepo in .jfl/config.json linear section."));
+        process.exit(1);
+    }
+    const scope = linearConfig.scope;
+    const direction = options.direction ?? "both";
+    const dryRun = options.dryRun ?? false;
+    const result = { direction, dryRun, repo, scope, changes: [], skipped: 0, errors: [] };
+    const log = (msg) => { if (!jsonMode)
+        console.log(msg); };
+    const logSection = (msg) => { if (!jsonMode)
+        console.log(chalk.bold(msg)); };
+    if (dryRun)
+        log(chalk.yellow("  [dry run] No changes will be made\n"));
+    const client = getLinearClient(linearConfig.apiKey);
+    if (!jsonMode)
+        ora("Fetching data...").start().stop();
+    let linearIssues;
+    let states;
+    let kanban;
+    let githubCards;
+    try {
+        ;
+        [linearIssues, states] = await Promise.all([
+            getProjectIssues(client, linearConfig.projectId),
+            getTeamStates(client, linearConfig.teamId),
+        ]);
+        kanban = new GitHubKanban(kanbanRoot);
+        githubCards = await kanban.getCards(scope ? { scope } : undefined);
+    }
+    catch (err) {
+        const msg = err.message ?? String(err);
+        if (jsonMode) {
+            process.stdout.write(JSON.stringify({ ...result, errors: [{ title: "fetch", error: msg }] }) + "\n");
+        }
+        else {
+            console.error(chalk.red("Failed to fetch: " + msg));
+        }
+        process.exit(1);
+    }
+    const map = readMap(projectRoot);
+    const linearToGhMap = {};
+    for (const [ghNum, lid] of Object.entries(map.mappings)) {
+        linearToGhMap[lid] = parseInt(ghNum);
+    }
+    const ghByNumber = {};
+    for (const card of githubCards)
+        ghByNumber[card.number] = card;
+    // ── GitHub → Linear ──────────────────────────────────────────────────────
+    if (direction === "github" || direction === "both") {
+        logSection("\n  GitHub → Linear");
+        for (const card of githubCards) {
+            const existingLinearId = map.mappings[card.number];
+            if (existingLinearId) {
+                const linearIssue = linearIssues.find(i => i.id === existingLinearId);
+                if (linearIssue) {
+                    const expectedColumn = linearToTenet(linearIssue).status;
+                    if (expectedColumn !== card.column) {
+                        const stateId = findLinearStateId(states, card.column);
+                        if (stateId && !dryRun) {
+                            try {
+                                await updateLinearIssue(client, existingLinearId, { stateId });
+                                result.changes.push({ side: "linear", action: "updated", githubNumber: card.number, linearId: existingLinearId, title: card.title, field: "status", from: expectedColumn, to: card.column });
+                                log(chalk.gray(`  ↑ Linear ${linearIssue.identifier} "${card.title}" → ${card.column}`));
+                            }
+                            catch (err) {
+                                result.errors.push({ title: card.title, error: err.message });
+                            }
+                        }
+                        else {
+                            result.skipped++;
+                        }
+                    }
+                    else {
+                        result.skipped++;
+                    }
+                }
+                continue;
+            }
+            // New → create in Linear
+            const tenet = kanbanToTenet(card);
+            const input = tenetToLinearCreate(tenet, linearConfig.teamId, linearConfig.projectId, states);
+            if (dryRun) {
+                result.changes.push({ side: "linear", action: "created", githubNumber: card.number, title: card.title });
+                log(chalk.gray(`  [dry] Would create in Linear: "${card.title}"`));
+                continue;
+            }
+            try {
+                const created_issue = await createLinearIssue(client, input);
+                if (created_issue) {
+                    addMapping(projectRoot, card.number, created_issue.id);
+                    result.changes.push({ side: "linear", action: "created", githubNumber: card.number, linearIdentifier: created_issue.identifier, linearId: created_issue.id, title: card.title });
+                    log(chalk.green(`  ✓ Linear ${created_issue.identifier} ← GitHub #${card.number} "${card.title}"`));
+                }
+            }
+            catch (err) {
+                result.errors.push({ title: card.title, error: err.message });
+                log(chalk.red(`  ✗ "${card.title}": ${err.message}`));
+            }
+        }
+    }
+    // ── Linear → GitHub ──────────────────────────────────────────────────────
+    if (direction === "linear" || direction === "both") {
+        logSection("\n  Linear → GitHub");
+        // Build a body-based fallback map once — catches webhook-created issues that
+        // weren't committed to linear-map.json, preventing duplicates on every cron run
+        const bodyBasedMap = {};
+        try {
+            const raw = gh(`issue list --repo ${repo} --label "source:linear" --state all --limit 500 --json number,body`, kanbanRoot);
+            const candidates = JSON.parse(raw);
+            for (const c of candidates) {
+                const m = c.body?.match(/linear_id:\s*([a-f0-9-]{36})/);
+                if (m)
+                    bodyBasedMap[m[1]] = c.number;
+            }
+            // Persist any new mappings discovered this way
+            let recovered = 0;
+            for (const [linearId, ghNum] of Object.entries(bodyBasedMap)) {
+                if (!linearToGhMap[linearId]) {
+                    addMapping(projectRoot, ghNum, linearId);
+                    linearToGhMap[linearId] = ghNum;
+                    recovered++;
+                }
+            }
+            if (recovered > 0)
+                log(chalk.gray(`  ↺ Recovered ${recovered} missing mappings from issue bodies`));
+        }
+        catch { /* non-fatal */ }
+        for (const issue of linearIssues) {
+            const existingGhNum = linearToGhMap[issue.id];
+            if (existingGhNum) {
+                const ghCard = ghByNumber[existingGhNum];
+                if (ghCard) {
+                    const tenet = linearToTenet(issue);
+                    if (tenet.status !== ghCard.column) {
+                        const newLabel = getColumnLabel(tenet.status);
+                        const allColLabels = ["jfl/backlog", "jfl/in-progress", "jfl/eval", "jfl/done"];
+                        const removeArgs = allColLabels.filter(l => l !== newLabel).map(l => `--remove-label "${l}"`).join(" ");
+                        if (!dryRun) {
+                            try {
+                                gh(`issue edit ${existingGhNum} --repo ${repo} ${removeArgs} --add-label "${newLabel}"`, kanbanRoot);
+                                if (tenet.status === "done") {
+                                    try {
+                                        gh(`issue edit ${existingGhNum} --repo ${repo} --state closed`, kanbanRoot);
+                                    }
+                                    catch { }
+                                }
+                                result.changes.push({ side: "github", action: "updated", githubNumber: existingGhNum, linearIdentifier: issue.identifier, title: issue.title, field: "status", from: ghCard.column, to: tenet.status });
+                                log(chalk.gray(`  ↓ GitHub #${existingGhNum} "${issue.title}" → ${tenet.status}`));
+                            }
+                            catch (err) {
+                                result.errors.push({ title: issue.title, error: err.message });
+                            }
+                        }
+                        else {
+                            result.changes.push({ side: "github", action: "updated", githubNumber: existingGhNum, title: issue.title, field: "status", from: ghCard.column, to: tenet.status });
+                            log(chalk.gray(`  [dry] GitHub #${existingGhNum} → ${tenet.status}`));
+                        }
+                    }
+                    else {
+                        result.skipped++;
+                    }
+                }
+                continue;
+            }
+            // New → create GitHub issue
+            const tenet = linearToTenet(issue);
+            const labels = tenetToGitHubLabels(tenet, scope);
+            const body = tenetToGitHubBody(tenet);
+            if (dryRun) {
+                result.changes.push({ side: "github", action: "created", linearIdentifier: issue.identifier, linearId: issue.id, title: issue.title });
+                log(chalk.gray(`  [dry] Would create GitHub issue: "${issue.title}"`));
+                continue;
+            }
+            try {
+                const labelArgs = labels.map(l => `--label "${l}"`).join(" ");
+                const { join: pathJoin } = await import("path");
+                const { writeFileSync: wf, unlinkSync: ul } = await import("fs");
+                const tmpFile = pathJoin(kanbanRoot, ".jfl", `.linear-sync-${Date.now()}.tmp`);
+                wf(tmpFile, body);
+                let ghNum = 0;
+                try {
+                    const ghResult = gh(`issue create --repo ${repo} --title "${issue.title.replace(/"/g, '\\"')}" --body-file "${tmpFile}" ${labelArgs}`, kanbanRoot);
+                    const numMatch = ghResult.match(/\/issues\/(\d+)/);
+                    ghNum = numMatch ? parseInt(numMatch[1]) : 0;
+                }
+                finally {
+                    try {
+                        ul(tmpFile);
+                    }
+                    catch { }
+                }
+                if (ghNum > 0) {
+                    addMapping(projectRoot, ghNum, issue.id);
+                    result.changes.push({ side: "github", action: "created", githubNumber: ghNum, linearIdentifier: issue.identifier, linearId: issue.id, title: issue.title });
+                    log(chalk.green(`  ✓ GitHub #${ghNum} ← Linear ${issue.identifier} "${issue.title}"`));
+                }
+            }
+            catch (err) {
+                result.errors.push({ title: issue.title, error: err.message });
+                log(chalk.red(`  ✗ "${issue.title}": ${err.message}`));
+            }
+        }
+    }
+    // Output
+    if (jsonMode) {
+        process.stdout.write(JSON.stringify(result) + "\n");
+    }
+    else {
+        const created = result.changes.filter(c => c.action === "created").length;
+        const updated = result.changes.filter(c => c.action === "updated").length;
+        console.log();
+        console.log(chalk.bold("  Sync complete:"), chalk.green(`${created} created`), chalk.yellow(`${updated} updated`), chalk.gray(`${result.skipped} skipped`), result.errors.length > 0 ? chalk.red(`${result.errors.length} errors`) : "");
+        console.log();
+    }
+    return result;
+}
+// ============================================================================
+// jfl linear bootstrap — deploy GitHub Actions workflow + set secrets
+// ============================================================================
+const WORKFLOW_TEMPLATE = `name: Linear Sync
+
+on:
+  issues:
+    types: [opened, edited, closed, labeled, unlabeled]
+  schedule:
+    - cron: '*/30 * * * *'
+  workflow_dispatch:
+    inputs:
+      direction:
+        description: 'Sync direction: github, linear, or both'
+        default: 'both'
+        type: choice
+        options: [both, github, linear]
+
+jobs:
+  sync:
+    name: Sync Linear ↔ GitHub Issues
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      contents: write
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+
+      - name: Install jfl
+        run: npm install -g jfl@latest
+
+      - name: Bootstrap kanban labels
+        run: jfl kanban bootstrap --repo \${{ github.repository }}
+        env:
+          GH_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+        continue-on-error: true
+
+      - name: Sync
+        id: sync
+        run: |
+          # issues event → push that change to Linear immediately (github direction)
+          # schedule/dispatch → full bidirectional
+          if [ "\${{ github.event_name }}" = "issues" ]; then
+            DIRECTION="github"
+          else
+            DIRECTION="\${{ inputs.direction || 'both' }}"
+          fi
+
+          jfl linear sync --direction \$DIRECTION --json | tee /tmp/sync-result.json
+          echo "result=$(cat /tmp/sync-result.json)" >> \$GITHUB_OUTPUT
+        env:
+          LINEAR_API_KEY: \${{ secrets.LINEAR_API_KEY }}
+          LINEAR_TEAM_ID: \${{ vars.LINEAR_TEAM_ID }}
+          LINEAR_PROJECT_ID: \${{ vars.LINEAR_PROJECT_ID }}
+          LINEAR_SCOPE: \${{ vars.LINEAR_SCOPE }}
+          GH_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+
+      - name: Summary
+        if: always()
+        run: |
+          cat /tmp/sync-result.json 2>/dev/null | node -e "
+            const r = JSON.parse(require('fs').readFileSync('/dev/stdin','utf8'));
+            const created = r.changes.filter(c=>c.action==='created').length;
+            const updated = r.changes.filter(c=>c.action==='updated').length;
+            console.log('## Linear Sync');
+            console.log(\`- **Direction:** \${r.direction}\`);
+            console.log(\`- **Created:** \${created}\`);
+            console.log(\`- **Updated:** \${updated}\`);
+            console.log(\`- **Skipped:** \${r.skipped}\`);
+            if(r.errors.length) console.log(\`- **Errors:** \${r.errors.length}\`);
+            if(r.changes.length) {
+              console.log('');
+              console.log('### Changes');
+              r.changes.forEach(c => {
+                const loc = c.githubNumber ? \`GitHub #\${c.githubNumber}\` : \`Linear \${c.linearIdentifier}\`;
+                const dest = c.side === 'github' ? 'GitHub' : 'Linear';
+                console.log(\`- [\${c.action}] \${dest}: \${c.title} (\${loc})\`);
+              });
+            }
+          " >> \$GITHUB_STEP_SUMMARY || true
+`;
+export async function linearBootstrap(projectRoot) {
+    const linearConfig = requireLinearConfig(projectRoot);
+    const projectConf = readProjectConfig(projectRoot);
+    const gtmParent = linearConfig.kanbanRepo ? undefined : projectConf.gtm_parent;
+    const kanbanRoot = gtmParent && existsSync(gtmParent) ? gtmParent : projectRoot;
+    const repo = linearConfig.kanbanRepo ?? getGitHubRepo(kanbanRoot);
+    if (!repo) {
+        console.error(chalk.red("Cannot determine GitHub repo. Run from inside the project or set kanbanRepo."));
+        process.exit(1);
+    }
+    console.log(chalk.bold("\n  Bootstrap Linear Sync — GitHub Actions\n"));
+    console.log(chalk.gray(`  Repo:    ${repo}`));
+    console.log(chalk.gray(`  Project: ${linearConfig.projectName ?? linearConfig.projectId}`));
+    if (linearConfig.scope)
+        console.log(chalk.gray(`  Scope:   ${linearConfig.scope}`));
+    console.log();
+    // Write workflow file
+    const workflowDir = join(kanbanRoot, ".github", "workflows");
+    const workflowPath = join(workflowDir, "linear-sync.yml");
+    if (!existsSync(workflowDir)) {
+        const { mkdirSync } = await import("fs");
+        mkdirSync(workflowDir, { recursive: true });
+    }
+    if (existsSync(workflowPath)) {
+        const { overwrite } = await inquirer.prompt([{
+                type: "confirm", name: "overwrite",
+                message: "linear-sync.yml already exists — overwrite?",
+                default: false,
+            }]);
+        if (!overwrite) {
+            console.log(chalk.gray("  Skipped workflow file."));
+        }
+        else {
+            writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+            console.log(chalk.green(`  ✓ Written: .github/workflows/linear-sync.yml`));
+        }
+    }
+    else {
+        writeFileSync(workflowPath, WORKFLOW_TEMPLATE);
+        console.log(chalk.green(`  ✓ Written: .github/workflows/linear-sync.yml`));
+    }
+    // Set GitHub secrets + variables
+    console.log();
+    console.log(chalk.gray("  Setting GitHub secrets and variables..."));
+    const spinner = ora("Setting LINEAR_API_KEY secret...").start();
+    try {
+        gh(`secret set LINEAR_API_KEY --body "${linearConfig.apiKey}" --repo ${repo}`, kanbanRoot);
+        spinner.succeed(chalk.green("  ✓ SECRET: LINEAR_API_KEY"));
+    }
+    catch (err) {
+        spinner.fail(chalk.yellow(`  ✗ SECRET: LINEAR_API_KEY (${err.message}) — set manually: gh secret set LINEAR_API_KEY --repo ${repo}`));
+    }
+    // Variables (non-sensitive)
+    for (const [name, value] of [
+        ["LINEAR_TEAM_ID", linearConfig.teamId],
+        ["LINEAR_PROJECT_ID", linearConfig.projectId],
+        ...(linearConfig.scope ? [["LINEAR_SCOPE", linearConfig.scope]] : []),
+    ]) {
+        try {
+            gh(`variable set ${name} --body "${value}" --repo ${repo}`, kanbanRoot);
+            console.log(chalk.green(`  ✓ VAR:    ${name}=${value}`));
+        }
+        catch (err) {
+            console.log(chalk.yellow(`  ✗ VAR:    ${name} — set manually: gh variable set ${name} --body "${value}" --repo ${repo}`));
+        }
+    }
+    // Commit the workflow file
+    console.log();
+    const { commit } = await inquirer.prompt([{
+            type: "confirm", name: "commit",
+            message: "Commit and push workflow file now?",
+            default: true,
+        }]);
+    if (commit) {
+        try {
+            const { execSync: exec } = await import("child_process");
+            exec(`git add .github/workflows/linear-sync.yml && git commit -m "ci: add Linear sync workflow" && git push`, {
+                cwd: kanbanRoot, encoding: "utf-8", stdio: "inherit",
+            });
+            console.log(chalk.green("  ✓ Pushed"));
+        }
+        catch (err) {
+            console.log(chalk.yellow("  Could not push automatically — commit manually."));
+        }
+    }
+    // Trigger initial run
+    console.log();
+    const { trigger } = await inquirer.prompt([{
+            type: "confirm", name: "trigger",
+            message: "Trigger an initial sync run now?",
+            default: true,
+        }]);
+    if (trigger) {
+        try {
+            gh(`workflow run linear-sync.yml --repo ${repo} --field direction=both`, kanbanRoot);
+            console.log(chalk.green(`  ✓ Triggered — watch at: https://github.com/${repo}/actions`));
+        }
+        catch {
+            console.log(chalk.gray(`  Run manually: gh workflow run linear-sync.yml --repo ${repo}`));
+        }
+    }
+    console.log();
+    console.log(chalk.bold("  Done! How sync works:"));
+    console.log(chalk.gray("  • GitHub issue label changed  →  Linear updates within seconds (issues trigger)"));
+    console.log(chalk.gray("  • Linear issue created/moved  →  GitHub syncs every 30 minutes (schedule)"));
+    console.log(chalk.gray("  • Manual:  jfl linear sync    →  runs immediately from your machine"));
+    console.log(chalk.gray(`  • Actions: https://github.com/${repo}/actions`));
+    console.log();
+}
+//# sourceMappingURL=linear.js.map