team-toon-tack 1.0.12 → 1.6.0

package/dist/scripts/status.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env bun
+import { getLinearClient, getTeamId, loadConfig, loadCycleData, loadLocalConfig, saveCycleData, } from "./utils.js";
+const PRIORITY_LABELS = {
+    0: "⚪ None",
+    1: "🔴 Urgent",
+    2: "🟠 High",
+    3: "🟡 Medium",
+    4: "🟢 Low",
+};
+const LOCAL_STATUS_ORDER = [
+    "pending",
+    "in-progress",
+    "completed",
+    "blocked-backend",
+];
+function parseArgs(args) {
+    let issueId;
+    let setStatus;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--set" || arg === "-s") {
+            setStatus = args[++i];
+        }
+        else if (!arg.startsWith("-")) {
+            issueId = arg;
+        }
+    }
+    return { issueId, setStatus };
+}
+async function status() {
+    const args = process.argv.slice(2);
+    // Handle help flag
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(`Usage: ttt status [issue-id] [--set <status>]
+
+Show or modify the status of an issue.
+
+Arguments:
+  issue-id              Issue ID (e.g., MP-624). If omitted, shows in-progress task.
+
+Options:
+  -s, --set <status>    Set local and Linear status. Values:
+                        +1       Move to next status (pending → in-progress → completed)
+                        -1       Move to previous status
+                        +2       Skip two statuses forward
+                        -2       Skip two statuses backward
+                        pending  Set to pending
+                        in-progress  Set to in-progress
+                        completed    Set to completed
+                        blocked      Set to blocked-backend
+                        todo     Set Linear to Todo status
+                        done     Set Linear to Done status
+
+Examples:
+  ttt status                    # Show current in-progress task
+  ttt status MP-624             # Show status of specific issue
+  ttt status MP-624 --set +1    # Move to next status
+  ttt status MP-624 --set done  # Mark as done
+  ttt status --set pending      # Reset current task to pending`);
+        process.exit(0);
+    }
+    const { issueId: argIssueId, setStatus } = parseArgs(args);
+    const config = await loadConfig();
+    const localConfig = await loadLocalConfig();
+    const data = await loadCycleData();
+    if (!data) {
+        console.error("No cycle data found. Run ttt sync first.");
+        process.exit(1);
+    }
+    // Find task
+    let task;
+    let issueId = argIssueId;
+    if (!issueId) {
+        // Find current in-progress task
+        const inProgressTasks = data.tasks.filter((t) => t.localStatus === "in-progress");
+        if (inProgressTasks.length === 0) {
+            console.log("No in-progress task found.");
+            console.log("\nAll tasks:");
+            for (const t of data.tasks) {
+                const statusIcon = t.localStatus === "completed"
+                    ? "✅"
+                    : t.localStatus === "in-progress"
+                        ? "🔄"
+                        : t.localStatus === "blocked-backend"
+                            ? "🚫"
+                            : "📋";
+                console.log(`  ${statusIcon} ${t.id}: ${t.title} [${t.localStatus}]`);
+            }
+            process.exit(0);
+        }
+        task = inProgressTasks[0];
+        issueId = task.id;
+    }
+    else {
+        task = data.tasks.find((t) => t.id === issueId || t.id === `MP-${issueId}`);
+        if (!task) {
+            console.error(`Issue ${issueId} not found in local data.`);
+            process.exit(1);
+        }
+    }
+    // If setting status
+    if (setStatus) {
+        const currentIndex = LOCAL_STATUS_ORDER.indexOf(task.localStatus);
+        let newLocalStatus;
+        let newLinearStatus;
+        // Parse status change
+        if (setStatus === "+1") {
+            const newIndex = Math.min(currentIndex + 1, LOCAL_STATUS_ORDER.length - 1);
+            newLocalStatus = LOCAL_STATUS_ORDER[newIndex];
+        }
+        else if (setStatus === "-1") {
+            const newIndex = Math.max(currentIndex - 1, 0);
+            newLocalStatus = LOCAL_STATUS_ORDER[newIndex];
+        }
+        else if (setStatus === "+2") {
+            const newIndex = Math.min(currentIndex + 2, LOCAL_STATUS_ORDER.length - 1);
+            newLocalStatus = LOCAL_STATUS_ORDER[newIndex];
+        }
+        else if (setStatus === "-2") {
+            const newIndex = Math.max(currentIndex - 2, 0);
+            newLocalStatus = LOCAL_STATUS_ORDER[newIndex];
+        }
+        else if ([
+            "pending",
+            "in-progress",
+            "completed",
+            "blocked-backend",
+            "blocked",
+        ].includes(setStatus)) {
+            newLocalStatus =
+                setStatus === "blocked"
+                    ? "blocked-backend"
+                    : setStatus;
+        }
+        else if (["todo", "in_progress", "done", "testing"].includes(setStatus)) {
+            // Map to Linear status
+            const statusTransitions = config.status_transitions || {
+                todo: "Todo",
+                in_progress: "In Progress",
+                done: "Done",
+                testing: "Testing",
+            };
+            newLinearStatus =
+                statusTransitions[setStatus];
+            // Also update local status accordingly
+            if (setStatus === "todo") {
+                newLocalStatus = "pending";
+            }
+            else if (setStatus === "in_progress") {
+                newLocalStatus = "in-progress";
+            }
+            else if (setStatus === "done") {
+                newLocalStatus = "completed";
+            }
+        }
+        else {
+            console.error(`Unknown status: ${setStatus}`);
+            process.exit(1);
+        }
+        // Update local status
+        if (newLocalStatus && newLocalStatus !== task.localStatus) {
+            const oldStatus = task.localStatus;
+            task.localStatus = newLocalStatus;
+            await saveCycleData(data);
+            console.log(`Local: ${task.id} ${oldStatus} → ${newLocalStatus}`);
+        }
+        // Update Linear status
+        if (newLinearStatus || newLocalStatus) {
+            try {
+                const client = getLinearClient();
+                const teamId = getTeamId(config, localConfig.team);
+                const workflowStates = await client.workflowStates({
+                    filter: { team: { id: { eq: teamId } } },
+                });
+                let targetStateName = newLinearStatus;
+                if (!targetStateName && newLocalStatus) {
+                    // Map local status to Linear status
+                    const statusTransitions = config.status_transitions || {
+                        todo: "Todo",
+                        in_progress: "In Progress",
+                        done: "Done",
+                    };
+                    if (newLocalStatus === "pending") {
+                        targetStateName = statusTransitions.todo;
+                    }
+                    else if (newLocalStatus === "in-progress") {
+                        targetStateName = statusTransitions.in_progress;
+                    }
+                    else if (newLocalStatus === "completed") {
+                        targetStateName = statusTransitions.done;
+                    }
+                }
+                if (targetStateName) {
+                    const targetState = workflowStates.nodes.find((s) => s.name === targetStateName);
+                    if (targetState) {
+                        await client.updateIssue(task.linearId, {
+                            stateId: targetState.id,
+                        });
+                        console.log(`Linear: ${task.id} → ${targetStateName}`);
+                    }
+                }
+            }
+            catch (e) {
+                console.error("Failed to update Linear:", e);
+            }
+        }
+    }
+    // Display task info
+    console.log(`\n${"═".repeat(50)}`);
+    const statusIcon = task.localStatus === "completed"
+        ? "✅"
+        : task.localStatus === "in-progress"
+            ? "🔄"
+            : task.localStatus === "blocked-backend"
+                ? "🚫"
+                : "📋";
+    console.log(`${statusIcon} ${task.id}: ${task.title}`);
+    console.log(`${"═".repeat(50)}`);
+    console.log(`\nStatus:`);
+    console.log(`  Local: ${task.localStatus}`);
+    console.log(`  Linear: ${task.status}`);
+    console.log(`\nInfo:`);
+    console.log(`  Priority: ${PRIORITY_LABELS[task.priority] || "None"}`);
+    console.log(`  Labels: ${task.labels.join(", ")}`);
+    console.log(`  Assignee: ${task.assignee || "Unassigned"}`);
+    console.log(`  Branch: ${task.branch || "N/A"}`);
+    if (task.url)
+        console.log(`  URL: ${task.url}`);
+    if (task.description) {
+        console.log(`\n📝 Description:\n${task.description}`);
+    }
+    if (task.attachments && task.attachments.length > 0) {
+        console.log(`\n📎 Attachments:`);
+        for (const att of task.attachments) {
+            console.log(`   - ${att.title}: ${att.url}`);
+        }
+    }
+    if (task.comments && task.comments.length > 0) {
+        console.log(`\n💬 Comments (${task.comments.length}):`);
+        for (const comment of task.comments) {
+            const date = new Date(comment.createdAt).toLocaleDateString();
+            console.log(`\n   [${comment.user || "Unknown"} - ${date}]`);
+            const lines = comment.body.split("\n");
+            for (const line of lines) {
+                console.log(`   ${line}`);
+            }
+        }
+    }
+    console.log(`\n${"─".repeat(50)}`);
+}
+status().catch(console.error);

package/dist/scripts/sync.js

@@ -0,0 +1,247 @@
+import { getLinearClient, getPrioritySortIndex, getTeamId, loadConfig, loadCycleData, loadLocalConfig, saveConfig, saveCycleData, } from "./utils.js";
+async function sync() {
+    const args = process.argv.slice(2);
+    // Handle help flag
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(`Usage: ttt sync [issue-id]
+
+Sync issues from Linear to local cycle.ttt file.
+
+Arguments:
+  issue-id    Optional. Sync only this specific issue (e.g., MP-624)
+
+What it does:
+  - Fetches active cycle from Linear
+  - Downloads all issues matching configured filters
+  - Preserves local status for existing tasks
+  - Updates config with new cycle info
+
+Examples:
+  ttt sync              # Sync all matching issues
+  ttt sync MP-624       # Sync only this specific issue
+  ttt sync -d .ttt     # Sync using .ttt directory`);
+        process.exit(0);
+    }
+    // Parse issue ID argument (if provided)
+    const singleIssueId = args.find((arg) => !arg.startsWith("-") && arg.match(/^[A-Z]+-\d+$/i));
+    const config = await loadConfig();
+    const localConfig = await loadLocalConfig();
+    const client = getLinearClient();
+    const teamId = getTeamId(config, localConfig.team);
+    // Build excluded emails from local config
+    const excludedEmails = new Set((localConfig.exclude_assignees ?? [])
+        .map((key) => config.users[key]?.email)
+        .filter(Boolean));
+    // Build excluded labels set
+    const excludedLabels = new Set(localConfig.exclude_labels ?? []);
+    // Phase 1: Fetch active cycle directly from team
+    console.log("Fetching latest cycle...");
+    const team = await client.team(teamId);
+    const activeCycle = await team.activeCycle;
+    if (!activeCycle) {
+        console.error("No active cycle found.");
+        process.exit(1);
+    }
+    const cycleId = activeCycle.id;
+    const cycleName = activeCycle.name ?? `Cycle #${activeCycle.number}`;
+    const newCycleInfo = {
+        id: cycleId,
+        name: cycleName,
+        start_date: activeCycle.startsAt?.toISOString().split("T")[0] ?? "",
+        end_date: activeCycle.endsAt?.toISOString().split("T")[0] ?? "",
+    };
+    // Check if cycle changed and update config with history
+    const existingData = await loadCycleData();
+    const oldCycleId = config.current_cycle?.id ?? existingData?.cycleId;
+    if (oldCycleId && oldCycleId !== cycleId) {
+        const oldCycleName = config.current_cycle?.name ?? existingData?.cycleName ?? "Unknown";
+        console.log(`Cycle changed: ${oldCycleName} → ${cycleName}`);
+        // Move old cycle to history (avoid duplicates)
+        if (config.current_cycle) {
+            config.cycle_history = config.cycle_history ?? [];
+            // Remove if already exists in history
+            config.cycle_history = config.cycle_history.filter((c) => c.id !== config.current_cycle?.id);
+            config.cycle_history.unshift(config.current_cycle);
+            // Keep only last 10 cycles
+            if (config.cycle_history.length > 10) {
+                config.cycle_history = config.cycle_history.slice(0, 10);
+            }
+        }
+        // Update current cycle
+        config.current_cycle = newCycleInfo;
+        await saveConfig(config);
+        console.log("Config updated with new cycle (old cycle saved to history).");
+    }
+    else {
+        // Update current cycle info even if ID unchanged (dates might change)
+        if (!config.current_cycle || config.current_cycle.id !== cycleId) {
+            config.current_cycle = newCycleInfo;
+            await saveConfig(config);
+        }
+        console.log(`Current cycle: ${cycleName}`);
+    }
+    // Phase 2: Fetch workflow states and get status mappings
+    const workflowStates = await client.workflowStates({
+        filter: { team: { id: { eq: teamId } } },
+    });
+    const stateMap = new Map(workflowStates.nodes.map((s) => [s.name, s.id]));
+    // Get status names from config or use defaults
+    const statusTransitions = config.status_transitions || {
+        todo: "Todo",
+        in_progress: "In Progress",
+        done: "Done",
+        testing: "Testing",
+    };
+    const testingStateId = statusTransitions.testing
+        ? stateMap.get(statusTransitions.testing)
+        : undefined;
+    // Phase 3: Build existing tasks map for preserving local status
+    const existingTasksMap = new Map(existingData?.tasks.map((t) => [t.id, t]));
+    // Phase 4: Fetch current issues with full content
+    const filterLabel = localConfig.label;
+    const syncStatuses = [statusTransitions.todo, statusTransitions.in_progress];
+    let issues;
+    if (singleIssueId) {
+        // Sync single issue by ID
+        console.log(`Fetching issue ${singleIssueId}...`);
+        const searchResult = await client.searchIssues(singleIssueId);
+        const matchingIssue = searchResult.nodes.find((i) => i.identifier === singleIssueId);
+        if (!matchingIssue) {
+            console.error(`Issue ${singleIssueId} not found.`);
+            process.exit(1);
+        }
+        issues = { nodes: [matchingIssue] };
+    }
+    else {
+        // Sync all matching issues
+        console.log(`Fetching issues with status: ${syncStatuses.join(", ")}${filterLabel ? ` and label: ${filterLabel}` : ""}...`);
+        // Build filter - label is optional
+        const issueFilter = {
+            team: { id: { eq: teamId } },
+            cycle: { id: { eq: cycleId } },
+            state: { name: { in: syncStatuses } },
+        };
+        if (filterLabel) {
+            issueFilter.labels = { name: { eq: filterLabel } };
+        }
+        issues = await client.issues({
+            filter: issueFilter,
+            first: 50,
+        });
+    }
+    if (issues.nodes.length === 0) {
+        console.log(`No issues found in current cycle with ${syncStatuses.join("/")} status${filterLabel ? ` and label: ${filterLabel}` : ""}.`);
+    }
+    const tasks = [];
+    let updatedCount = 0;
+    for (const issueNode of issues.nodes) {
+        // Fetch full issue to get all relations (searchIssues returns IssueSearchResult which lacks some methods)
+        const issue = await client.issue(issueNode.id);
+        const assignee = await issue.assignee;
+        const assigneeEmail = assignee?.email;
+        // Skip excluded assignees
+        if (assigneeEmail && excludedEmails.has(assigneeEmail)) {
+            continue;
+        }
+        const labels = await issue.labels();
+        const labelNames = labels.nodes.map((l) => l.name);
+        // Skip if any label is in excluded list
+        if (labelNames.some((name) => excludedLabels.has(name))) {
+            continue;
+        }
+        const state = await issue.state;
+        const parent = await issue.parent;
+        const attachmentsData = await issue.attachments();
+        const commentsData = await issue.comments();
+        // Build attachments list
+        const attachments = attachmentsData.nodes.map((a) => ({
+            id: a.id,
+            title: a.title,
+            url: a.url,
+            sourceType: a.sourceType ?? undefined,
+        }));
+        // Build comments list
+        const comments = await Promise.all(commentsData.nodes.map(async (c) => {
+            const user = await c.user;
+            return {
+                id: c.id,
+                body: c.body,
+                createdAt: c.createdAt.toISOString(),
+                user: user?.displayName ?? user?.email,
+            };
+        }));
+        let localStatus = "pending";
+        // Preserve local status & sync completed tasks to Linear
+        if (existingTasksMap.has(issue.identifier)) {
+            const existing = existingTasksMap.get(issue.identifier);
+            localStatus = existing?.localStatus ?? "pending";
+            if (localStatus === "completed" && state && testingStateId) {
+                // Skip if already in terminal states (done, testing, or cancelled type)
+                const terminalStates = [statusTransitions.done];
+                if (statusTransitions.testing)
+                    terminalStates.push(statusTransitions.testing);
+                const isTerminal = terminalStates.includes(state.name) || state.type === "cancelled";
+                if (!isTerminal) {
+                    console.log(`Updating ${issue.identifier} to ${statusTransitions.testing} in Linear...`);
+                    await client.updateIssue(issue.id, { stateId: testingStateId });
+                    updatedCount++;
+                }
+            }
+        }
+        const task = {
+            id: issue.identifier,
+            linearId: issue.id,
+            title: issue.title,
+            status: state ? state.name : "Unknown",
+            localStatus: localStatus,
+            assignee: assigneeEmail,
+            priority: issue.priority,
+            labels: labelNames,
+            branch: issue.branchName,
+            description: issue.description ?? undefined,
+            parentIssueId: parent ? parent.identifier : undefined,
+            url: issue.url,
+            attachments: attachments.length > 0 ? attachments : undefined,
+            comments: comments.length > 0 ? comments : undefined,
+        };
+        tasks.push(task);
+    }
+    // Sort by priority using config order
+    tasks.sort((a, b) => {
+        const pa = getPrioritySortIndex(a.priority, config.priority_order);
+        const pb = getPrioritySortIndex(b.priority, config.priority_order);
+        return pa - pb;
+    });
+    let finalTasks;
+    if (singleIssueId && existingData) {
+        // Merge single issue into existing tasks
+        const existingTasks = existingData.tasks.filter((t) => t.id !== singleIssueId);
+        finalTasks = [...existingTasks, ...tasks];
+        // Re-sort after merge
+        finalTasks.sort((a, b) => {
+            const pa = getPrioritySortIndex(a.priority, config.priority_order);
+            const pb = getPrioritySortIndex(b.priority, config.priority_order);
+            return pa - pb;
+        });
+    }
+    else {
+        finalTasks = tasks;
+    }
+    const newData = {
+        cycleId: cycleId,
+        cycleName: cycleName,
+        updatedAt: new Date().toISOString(),
+        tasks: finalTasks,
+    };
+    await saveCycleData(newData);
+    if (singleIssueId) {
+        console.log(`\n✅ Synced issue ${singleIssueId}.`);
+    }
+    else {
+        console.log(`\n✅ Synced ${tasks.length} tasks for ${cycleName}.`);
+    }
+    if (updatedCount > 0) {
+        console.log(`   Updated ${updatedCount} issues to ${statusTransitions.testing} in Linear.`);
+    }
+}
+sync().catch(console.error);

package/{scripts → dist/scripts}/utils.d.ts

@@ -1,4 +1,4 @@
-import { LinearClient } from '@linear/sdk';
+import { LinearClient } from "@linear/sdk";
 export declare function getPaths(): {
     baseDir: string;
     configPath: string;
@@ -27,6 +27,12 @@ export interface CycleInfo {
     start_date: string;
     end_date: string;
 }
+export interface StatusTransitions {
+    todo: string;
+    in_progress: string;
+    done: string;
+    testing?: string;
+}
 export interface Config {
     teams: Record<string, TeamConfig>;
     users: Record<string, UserConfig>;
@@ -39,7 +45,7 @@ export interface Config {
         name: string;
         type: string;
     }>;
-    status_transitions?: Record<string, string>;
+    status_transitions?: StatusTransitions;
     priority_order?: string[];
     current_cycle?: CycleInfo;
     cycle_history?: CycleInfo[];
@@ -64,7 +70,7 @@ export interface Task {
     linearId: string;
     title: string;
     status: string;
-    localStatus: 'pending' | 'in-progress' | 'completed' | 'blocked-backend';
+    localStatus: "pending" | "in-progress" | "completed" | "blocked-backend";
     assignee?: string;
     priority: number;
     labels: string[];
@@ -85,7 +91,9 @@ export interface CycleData {
 export interface LocalConfig {
     current_user: string;
     team: string;
+    teams?: string[];
     exclude_assignees?: string[];
+    exclude_labels?: string[];
     label?: string;
 }
 export declare function fileExists(filePath: string): Promise<boolean>;

package/{scripts → dist/scripts}/utils.js

@@ -1,7 +1,7 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { LinearClient } from '@linear/sdk';
-import { decode, encode } from '@toon-format/toon';
+import fs from "node:fs/promises";
+import path from "node:path";
+import { LinearClient } from "@linear/sdk";
+import { decode, encode } from "@toon-format/toon";
 // Resolve base directory - supports multiple configuration methods
 function getBaseDir() {
     // 1. Check for TOON_DIR environment variable (set by CLI or user)
@@ -13,12 +13,12 @@ function getBaseDir() {
         return path.resolve(process.env.LINEAR_TOON_DIR);
     }
     // 3. Default: .ttt directory in current working directory
-    return path.join(process.cwd(), '.ttt');
+    return path.join(process.cwd(), ".ttt");
 }
 const BASE_DIR = getBaseDir();
-const CONFIG_PATH = path.join(BASE_DIR, 'config.toon');
-const CYCLE_PATH = path.join(BASE_DIR, 'cycle.toon');
-const LOCAL_PATH = path.join(BASE_DIR, 'local.toon');
+const CONFIG_PATH = path.join(BASE_DIR, "config.toon");
+const CYCLE_PATH = path.join(BASE_DIR, "cycle.toon");
+const LOCAL_PATH = path.join(BASE_DIR, "local.toon");
 export function getPaths() {
     return {
         baseDir: BASE_DIR,
@@ -29,16 +29,22 @@ export function getPaths() {
 }
 // Linear priority value to name mapping (fixed by Linear API)
 export const PRIORITY_NAMES = {
-    0: 'none',
-    1: 'urgent',
-    2: 'high',
-    3: 'medium',
-    4: 'low'
+    0: "none",
+    1: "urgent",
+    2: "high",
+    3: "medium",
+    4: "low",
 };
-export const DEFAULT_PRIORITY_ORDER = ['urgent', 'high', 'medium', 'low', 'none'];
+export const DEFAULT_PRIORITY_ORDER = [
+    "urgent",
+    "high",
+    "medium",
+    "low",
+    "none",
+];
 export function getPrioritySortIndex(priority, priorityOrder) {
     const order = priorityOrder ?? DEFAULT_PRIORITY_ORDER;
-    const name = PRIORITY_NAMES[priority] ?? 'none';
+    const name = PRIORITY_NAMES[priority] ?? "none";
     const index = order.indexOf(name);
     return index === -1 ? order.length : index;
 }
@@ -53,23 +59,23 @@ export async function fileExists(filePath) {
 }
 export async function loadConfig() {
     try {
-        const fileContent = await fs.readFile(CONFIG_PATH, 'utf-8');
+        const fileContent = await fs.readFile(CONFIG_PATH, "utf-8");
         return decode(fileContent);
     }
     catch (error) {
         console.error(`Error loading config from ${CONFIG_PATH}:`, error);
-        console.error('Run `bun run init` to create configuration files.');
+        console.error("Run `bun run init` to create configuration files.");
         process.exit(1);
     }
 }
 export async function loadLocalConfig() {
     try {
-        const fileContent = await fs.readFile(LOCAL_PATH, 'utf-8');
+        const fileContent = await fs.readFile(LOCAL_PATH, "utf-8");
         return decode(fileContent);
     }
     catch {
         console.error(`Error: ${LOCAL_PATH} not found.`);
-        console.error('Run `bun run init` to create local configuration.');
+        console.error("Run `bun run init` to create local configuration.");
         process.exit(1);
     }
 }
@@ -79,7 +85,7 @@ export async function getUserEmail() {
     const user = config.users[localConfig.current_user];
     if (!user) {
         console.error(`Error: User "${localConfig.current_user}" not found in config.toon`);
-        console.error(`Available users: ${Object.keys(config.users).join(', ')}`);
+        console.error(`Available users: ${Object.keys(config.users).join(", ")}`);
         process.exit(1);
     }
     return user.email;
@@ -87,7 +93,7 @@ export async function getUserEmail() {
 export function getLinearClient() {
     const apiKey = process.env.LINEAR_API_KEY;
     if (!apiKey) {
-        console.error('Error: LINEAR_API_KEY environment variable is not set.');
+        console.error("Error: LINEAR_API_KEY environment variable is not set.");
         console.error('Set it in your shell: export LINEAR_API_KEY="lin_api_xxxxx"');
         process.exit(1);
     }
@@ -96,7 +102,7 @@ export function getLinearClient() {
 export async function loadCycleData() {
     try {
         await fs.access(CYCLE_PATH);
-        const fileContent = await fs.readFile(CYCLE_PATH, 'utf-8');
+        const fileContent = await fs.readFile(CYCLE_PATH, "utf-8");
         return decode(fileContent);
     }
     catch {
@@ -105,21 +111,21 @@ export async function loadCycleData() {
 }
 export async function saveCycleData(data) {
     const toonString = encode(data);
-    await fs.writeFile(CYCLE_PATH, toonString, 'utf-8');
+    await fs.writeFile(CYCLE_PATH, toonString, "utf-8");
 }
 export async function saveConfig(config) {
     const toonString = encode(config);
-    await fs.writeFile(CONFIG_PATH, toonString, 'utf-8');
+    await fs.writeFile(CONFIG_PATH, toonString, "utf-8");
 }
 export async function saveLocalConfig(config) {
     const toonString = encode(config);
-    await fs.writeFile(LOCAL_PATH, toonString, 'utf-8');
+    await fs.writeFile(LOCAL_PATH, toonString, "utf-8");
 }
 // Get first team key from config
 export function getDefaultTeamKey(config) {
     const keys = Object.keys(config.teams);
     if (keys.length === 0) {
-        console.error('Error: No teams defined in config.toon');
+        console.error("Error: No teams defined in config.toon");
         process.exit(1);
     }
     return keys[0];
@@ -130,7 +136,7 @@ export function getTeamId(config, teamKey) {
     const team = config.teams[key];
     if (!team) {
         console.error(`Error: Team "${key}" not found in config.toon`);
-        console.error(`Available teams: ${Object.keys(config.teams).join(', ')}`);
+        console.error(`Available teams: ${Object.keys(config.teams).join(", ")}`);
         process.exit(1);
     }
     return team.id;