team-toon-tack 1.0.11 → 1.6.0

package/dist/scripts/status.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+export {};

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.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/scripts/sync.js

@@ -1,171 +1,247 @@
-import {
-  getLinearClient,
-  getPrioritySortIndex,
-  getTeamId,
-  loadConfig,
-  loadCycleData,
-  loadLocalConfig,
-  saveConfig,
-  saveCycleData
-} from "./utils.js";
-import"../cli-pyanjjwn.js";
-
-// scripts/sync.ts
+import { getLinearClient, getPrioritySortIndex, getTeamId, loadConfig, loadCycleData, loadLocalConfig, saveConfig, saveCycleData, } from "./utils.js";
 async function sync() {
-  const args = process.argv.slice(2);
-  if (args.includes("--help") || args.includes("-h")) {
-    console.log(`Usage: ttt 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 label
+  - Downloads all issues matching configured filters
   - Preserves local status for existing tasks
   - Updates config with new cycle info
 
 Examples:
-  ttt sync              # Sync in current directory
+  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);
-  }
-  const config = await loadConfig();
-  const localConfig = await loadLocalConfig();
-  const client = getLinearClient();
-  const teamId = getTeamId(config, localConfig.team);
-  const excludedEmails = new Set((localConfig.exclude_assignees ?? []).map((key) => config.users[key]?.email).filter(Boolean));
-  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] ?? ""
-  };
-  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}`);
-    if (config.current_cycle) {
-      config.cycle_history = config.cycle_history ?? [];
-      config.cycle_history = config.cycle_history.filter((c) => c.id !== config.current_cycle.id);
-      config.cycle_history.unshift(config.current_cycle);
-      if (config.cycle_history.length > 10) {
-        config.cycle_history = config.cycle_history.slice(0, 10);
-      }
+        process.exit(0);
     }
-    config.current_cycle = newCycleInfo;
-    await saveConfig(config);
-    console.log("Config updated with new cycle (old cycle saved to history).");
-  } else {
-    if (!config.current_cycle || config.current_cycle.id !== cycleId) {
-      config.current_cycle = newCycleInfo;
-      await saveConfig(config);
+    // 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);
     }
-    console.log(`Current cycle: ${cycleName}`);
-  }
-  const workflowStates = await client.workflowStates({
-    filter: { team: { id: { eq: teamId } } }
-  });
-  const stateMap = new Map(workflowStates.nodes.map((s) => [s.name, s.id]));
-  const testingStateId = stateMap.get("Testing");
-  const existingTasksMap = new Map(existingData?.tasks.map((t) => [t.id, t]));
-  const filterLabel = localConfig.label ?? "Frontend";
-  console.log(`Fetching issues with label: ${filterLabel}...`);
-  const issues = await client.issues({
-    filter: {
-      team: { id: { eq: teamId } },
-      cycle: { id: { eq: cycleId } },
-      labels: { name: { eq: filterLabel } },
-      state: { name: { in: ["Todo", "In Progress"] } }
-    },
-    first: 50
-  });
-  if (issues.nodes.length === 0) {
-    console.log(`No ${filterLabel} issues found in current cycle with Todo/In Progress status.`);
-  }
-  const tasks = [];
-  let updatedCount = 0;
-  for (const issue of issues.nodes) {
-    const assignee = await issue.assignee;
-    const assigneeEmail = assignee?.email;
-    if (assigneeEmail && excludedEmails.has(assigneeEmail)) {
-      continue;
+    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).");
     }
-    const labels = await issue.labels();
-    const state = await issue.state;
-    const parent = await issue.parent;
-    const attachmentsData = await issue.attachments();
-    const commentsData = await issue.comments();
-    const attachments = attachmentsData.nodes.map((a) => ({
-      id: a.id,
-      title: a.title,
-      url: a.url,
-      sourceType: a.sourceType ?? undefined
-    }));
-    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";
-    if (existingTasksMap.has(issue.identifier)) {
-      const existing = existingTasksMap.get(issue.identifier);
-      localStatus = existing.localStatus;
-      if (localStatus === "completed" && state && testingStateId) {
-        if (!["Testing", "Done", "In Review", "Canceled"].includes(state.name)) {
-          console.log(`Updating ${issue.identifier} to Testing in Linear...`);
-          await client.updateIssue(issue.id, { stateId: testingStateId });
-          updatedCount++;
+    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}`);
     }
-    const task = {
-      id: issue.identifier,
-      linearId: issue.id,
-      title: issue.title,
-      status: state ? state.name : "Unknown",
-      localStatus,
-      assignee: assigneeEmail,
-      priority: issue.priority,
-      labels: labels.nodes.map((l) => l.name),
-      branch: issue.branchName,
-      description: issue.description,
-      parentIssueId: parent ? parent.identifier : undefined,
-      url: issue.url,
-      attachments: attachments.length > 0 ? attachments : undefined,
-      comments: comments.length > 0 ? comments : undefined
+    // 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",
     };
-    tasks.push(task);
-  }
-  tasks.sort((a, b) => {
-    const pa = getPrioritySortIndex(a.priority, config.priority_order);
-    const pb = getPrioritySortIndex(b.priority, config.priority_order);
-    return pa - pb;
-  });
-  const newData = {
-    cycleId,
-    cycleName,
-    updatedAt: new Date().toISOString(),
-    tasks
-  };
-  await saveCycleData(newData);
-  console.log(`
-✅ Synced ${tasks.length} tasks for ${cycleName}.`);
-  if (updatedCount > 0) {
-    console.log(`   Updated ${updatedCount} issues to Testing in Linear.`);
-  }
+    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);