team-toon-tack 1.7.0 → 2.0.0

package/dist/scripts/init.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
 import fs from "node:fs/promises";
+import path from "node:path";
 import { decode, encode } from "@toon-format/toon";
 import prompts from "prompts";
 import { buildConfig, buildLocalConfig, findTeamKey, findUserKey, getDefaultStatusTransitions, } from "./lib/config-builder.js";
@@ -116,6 +117,40 @@ async function selectTeams(teams, options) {
     }
     return { selected: selectedTeams, primary: primaryTeam };
 }
+async function selectQaPmTeam(teams, primaryTeam, options) {
+    // Only ask if there are multiple teams and interactive mode
+    if (!options.interactive || teams.length <= 1) {
+        return undefined;
+    }
+    // Filter out primary team from choices
+    const otherTeams = teams.filter((t) => t.id !== primaryTeam.id);
+    if (otherTeams.length === 0) {
+        return undefined;
+    }
+    console.log("\n🔗 QA/PM Team Configuration:");
+    const response = await prompts({
+        type: "select",
+        name: "qaPmTeamId",
+        message: "Select QA/PM team (for cross-team parent issue updates):",
+        choices: [
+            {
+                title: "(None - skip)",
+                value: undefined,
+                description: "No cross-team parent updates",
+            },
+            ...otherTeams.map((t) => ({
+                title: t.name,
+                value: t.id,
+                description: "Parent issues in this team will be updated to Testing",
+            })),
+        ],
+        initial: 0,
+    });
+    if (!response.qaPmTeamId) {
+        return undefined;
+    }
+    return teams.find((t) => t.id === response.qaPmTeamId);
+}
 async function selectUser(users, options) {
     let currentUser = users[0];
     if (options.user) {
@@ -157,6 +192,31 @@ async function selectLabelFilter(labels, options) {
     }
     return undefined;
 }
+async function selectStatusSource(options) {
+    if (!options.interactive) {
+        return "remote"; // default
+    }
+    console.log("\n🔄 Configure status sync mode:");
+    const response = await prompts({
+        type: "select",
+        name: "statusSource",
+        message: "Where should status updates be stored?",
+        choices: [
+            {
+                title: "Remote (recommended)",
+                value: "remote",
+                description: "Update Linear immediately when you work-on or complete tasks",
+            },
+            {
+                title: "Local",
+                value: "local",
+                description: "Work offline, then sync to Linear with 'sync --update'",
+            },
+        ],
+        initial: 0,
+    });
+    return response.statusSource || "remote";
+}
 async function selectStatusMappings(states, options) {
     const defaults = getDefaultStatusTransitions(states);
     if (!options.interactive || states.length === 0) {
@@ -201,13 +261,215 @@ async function selectStatusMappings(states, options) {
             ? testingChoices.findIndex((c) => c.value === defaults.testing)
             : 0,
     });
+    const blockedChoices = [
+        { title: "(None)", value: undefined },
+        ...stateChoices,
+    ];
+    const blockedResponse = await prompts({
+        type: "select",
+        name: "blocked",
+        message: 'Select status for "Blocked" (optional, for blocked tasks):',
+        choices: blockedChoices,
+        initial: defaults.blocked
+            ? blockedChoices.findIndex((c) => c.value === defaults.blocked)
+            : 0,
+    });
     return {
         todo: todoResponse.todo || defaults.todo,
         in_progress: inProgressResponse.in_progress || defaults.in_progress,
         done: doneResponse.done || defaults.done,
         testing: testingResponse.testing,
+        blocked: blockedResponse.blocked,
     };
 }
+async function updateGitignore(tttDir, interactive) {
+    const gitignorePath = ".gitignore";
+    const entry = `${tttDir}/`;
+    try {
+        let content = "";
+        let exists = false;
+        try {
+            content = await fs.readFile(gitignorePath, "utf-8");
+            exists = true;
+        }
+        catch {
+            // .gitignore doesn't exist
+        }
+        // Check if already ignored
+        const lines = content.split("\n");
+        const alreadyIgnored = lines.some((line) => line.trim() === entry ||
+            line.trim() === tttDir ||
+            line.trim() === `/${entry}` ||
+            line.trim() === `/${tttDir}`);
+        if (alreadyIgnored) {
+            return;
+        }
+        // Ask user in interactive mode
+        if (interactive) {
+            const { addToGitignore } = await prompts({
+                type: "confirm",
+                name: "addToGitignore",
+                message: `Add ${entry} to .gitignore?`,
+                initial: true,
+            });
+            if (!addToGitignore)
+                return;
+        }
+        // Add to .gitignore
+        const newContent = exists
+            ? content.endsWith("\n")
+                ? `${content}${entry}\n`
+                : `${content}\n${entry}\n`
+            : `${entry}\n`;
+        await fs.writeFile(gitignorePath, newContent, "utf-8");
+        console.log(`  ✓ Added ${entry} to .gitignore`);
+    }
+    catch (_error) {
+        // Silently ignore gitignore errors
+    }
+}
+async function installClaudeCommands(interactive, statusSource) {
+    if (!interactive) {
+        return { installed: false, prefix: "" };
+    }
+    console.log("\n🤖 Claude Code Commands:");
+    // Ask if user wants to install commands
+    const { install } = await prompts({
+        type: "confirm",
+        name: "install",
+        message: "Install Claude Code commands? (work-on, done-job, sync-linear)",
+        initial: true,
+    });
+    if (!install) {
+        return { installed: false, prefix: "" };
+    }
+    // Ask for prefix
+    const { prefixChoice } = await prompts({
+        type: "select",
+        name: "prefixChoice",
+        message: "Command prefix style:",
+        choices: [
+            {
+                title: "No prefix (recommended)",
+                value: "",
+                description: "/work-on, /done-job, /sync-linear",
+            },
+            {
+                title: "ttt:",
+                value: "ttt:",
+                description: "/ttt:work-on, /ttt:done-job, /ttt:sync-linear",
+            },
+            {
+                title: "linear:",
+                value: "linear:",
+                description: "/linear:work-on, /linear:done-job, /linear:sync-linear",
+            },
+            {
+                title: "Custom...",
+                value: "custom",
+                description: "Enter your own prefix",
+            },
+        ],
+        initial: 0,
+    });
+    let prefix = prefixChoice || "";
+    if (prefixChoice === "custom") {
+        const { customPrefix } = await prompts({
+            type: "text",
+            name: "customPrefix",
+            message: "Enter custom prefix (e.g., 'my:'):",
+            initial: "",
+        });
+        prefix = customPrefix || "";
+    }
+    // Find templates directory
+    // Try multiple locations: installed package, local dev
+    const possibleTemplatePaths = [
+        path.join(__dirname, "..", "templates", "claude-code-commands"),
+        path.join(__dirname, "..", "..", "templates", "claude-code-commands"),
+        path.join(process.cwd(), "templates", "claude-code-commands"),
+    ];
+    let templateDir = null;
+    for (const p of possibleTemplatePaths) {
+        try {
+            await fs.access(p);
+            templateDir = p;
+            break;
+        }
+        catch {
+            // Try next path
+        }
+    }
+    if (!templateDir) {
+        // Try to get repo URL from package.json
+        let repoUrl = "https://github.com/wayne930242/team-toon-tack";
+        try {
+            const pkgPaths = [
+                path.join(__dirname, "..", "package.json"),
+                path.join(__dirname, "..", "..", "package.json"),
+            ];
+            for (const pkgPath of pkgPaths) {
+                try {
+                    const pkgContent = await fs.readFile(pkgPath, "utf-8");
+                    const pkg = JSON.parse(pkgContent);
+                    if (pkg.repository?.url) {
+                        // Parse git+https://github.com/user/repo.git format
+                        repoUrl = pkg.repository.url
+                            .replace(/^git\+/, "")
+                            .replace(/\.git$/, "");
+                    }
+                    break;
+                }
+                catch {
+                    // Try next path
+                }
+            }
+        }
+        catch {
+            // Use default URL
+        }
+        console.log("  ⚠ Could not find command templates. Please copy manually from:");
+        console.log(`    ${repoUrl}/tree/main/templates/claude-code-commands`);
+        return { installed: false, prefix };
+    }
+    // Create .claude/commands directory
+    const commandsDir = path.join(process.cwd(), ".claude", "commands");
+    await fs.mkdir(commandsDir, { recursive: true });
+    // Copy and rename template files
+    const templateFiles = await fs.readdir(templateDir);
+    const commandFiles = templateFiles.filter((f) => f.endsWith(".md"));
+    for (const file of commandFiles) {
+        const baseName = file.replace(".md", "");
+        const newFileName = prefix ? `${prefix}${baseName}.md` : file;
+        const srcPath = path.join(templateDir, file);
+        const destPath = path.join(commandsDir, newFileName);
+        // Read template content
+        let content = await fs.readFile(srcPath, "utf-8");
+        // Update the name in frontmatter if prefix is used
+        if (prefix) {
+            content = content.replace(/^(---\s*\n[\s\S]*?name:\s*)(\S+)/m, `$1${prefix}${baseName}`);
+        }
+        // Modify content based on statusSource for work-on and done-job
+        if (statusSource === "local") {
+            if (baseName === "work-on" || baseName.endsWith("work-on")) {
+                // Update description for local mode
+                content = content.replace(/Select a task and update status to "In Progress" on both local and Linear\./, 'Select a task and update local status to "In Progress". (Linear will be updated when you run `sync --update`)');
+                // Add reminder after Complete section
+                content = content.replace(/Use `?\/done-job`? to mark task as completed/, "Use `/done-job` to mark task as completed\n\n### 7. Sync to Linear\n\nWhen ready to update Linear with all your changes:\n\n```bash\nttt sync --update\n```");
+            }
+            if (baseName === "done-job" || baseName.endsWith("done-job")) {
+                // Update description for local mode
+                content = content.replace(/Mark a task as done and update Linear with commit details\./, "Mark a task as done locally. (Run `ttt sync --update` to push changes to Linear)");
+                // Add reminder at the end
+                content = content.replace(/## What It Does\n\n- Linear issue status → "Done"/, "## What It Does\n\n- Local status → `completed`");
+                content += `\n## Sync to Linear\n\nAfter completing tasks, push all changes to Linear:\n\n\`\`\`bash\nttt sync --update\n\`\`\`\n`;
+            }
+        }
+        await fs.writeFile(destPath, content, "utf-8");
+        console.log(`  ✓ .claude/commands/${newFileName}`);
+    }
+    return { installed: true, prefix };
+}
 async function init() {
     const args = process.argv.slice(2);
     const options = parseArgs(args);
@@ -262,24 +524,62 @@ async function init() {
     if (selectedTeams.length > 1) {
         console.log(`  Primary: ${primaryTeam.name}`);
     }
-    // Fetch data from primary team
-    const selectedTeam = await client.team(primaryTeam.id);
-    const members = await selectedTeam.members();
-    const users = members.nodes;
+    // Fetch data from ALL teams (not just primary) to support cross-team operations
+    console.log(`  Fetching data from ${teams.length} teams...`);
+    // Collect users, labels, states from all teams
+    const allUsers = [];
+    const allLabels = [];
+    const allStates = [];
+    const seenUserIds = new Set();
+    const seenLabelIds = new Set();
+    const seenStateIds = new Set();
+    for (const team of teams) {
+        try {
+            const teamData = await client.team(team.id);
+            const members = await teamData.members();
+            for (const user of members.nodes) {
+                if (!seenUserIds.has(user.id)) {
+                    seenUserIds.add(user.id);
+                    allUsers.push(user);
+                }
+            }
+            const labelsData = await client.issueLabels({
+                filter: { team: { id: { eq: team.id } } },
+            });
+            for (const label of labelsData.nodes) {
+                if (!seenLabelIds.has(label.id)) {
+                    seenLabelIds.add(label.id);
+                    allLabels.push(label);
+                }
+            }
+            const statesData = await client.workflowStates({
+                filter: { team: { id: { eq: team.id } } },
+            });
+            for (const state of statesData.nodes) {
+                if (!seenStateIds.has(state.id)) {
+                    seenStateIds.add(state.id);
+                    allStates.push(state);
+                }
+            }
+        }
+        catch (error) {
+            console.warn(`  ⚠ Could not fetch data for team ${team.name}, skipping...`);
+        }
+    }
+    const users = allUsers;
+    const labels = allLabels;
+    const states = allStates;
     console.log(`  Users: ${users.length}`);
-    const labelsData = await client.issueLabels({
-        filter: { team: { id: { eq: primaryTeam.id } } },
-    });
-    const labels = labelsData.nodes;
     console.log(`  Labels: ${labels.length}`);
-    const statesData = await client.workflowStates({
-        filter: { team: { id: { eq: primaryTeam.id } } },
-    });
-    const states = statesData.nodes;
+    console.log(`  Workflow states: ${states.length}`);
+    // Get cycle from primary team (for current work tracking)
+    const selectedTeam = await client.team(primaryTeam.id);
     const currentCycle = (await selectedTeam.activeCycle);
     // User selections
     const currentUser = await selectUser(users, options);
     const defaultLabel = await selectLabelFilter(labels, options);
+    const statusSource = await selectStatusSource(options);
+    const qaPmTeam = await selectQaPmTeam(teams, primaryTeam, options);
     const statusTransitions = await selectStatusMappings(states, options);
     // Build config
     const config = buildConfig(teams, users, labels, states, statusTransitions, currentCycle ?? undefined);
@@ -289,7 +589,11 @@ async function init() {
     const selectedTeamKeys = selectedTeams
         .map((team) => findTeamKey(config.teams, team.id))
         .filter((key) => key !== undefined);
-    const localConfig = buildLocalConfig(currentUserKey, primaryTeamKey, selectedTeamKeys, defaultLabel);
+    const qaPmTeamKey = qaPmTeam
+        ? findTeamKey(config.teams, qaPmTeam.id)
+        : undefined;
+    const localConfig = buildLocalConfig(currentUserKey, primaryTeamKey, selectedTeamKeys, defaultLabel, undefined, // excludeLabels
+    statusSource, qaPmTeamKey);
     // Write config files
     console.log("\n📝 Writing configuration files...");
     await fs.mkdir(paths.baseDir, { recursive: true });
@@ -326,10 +630,14 @@ async function init() {
                     localConfig.team = existingLocal.team;
                 if (existingLocal.teams)
                     localConfig.teams = existingLocal.teams;
+                if (existingLocal.qa_pm_team)
+                    localConfig.qa_pm_team = existingLocal.qa_pm_team;
                 if (existingLocal.label)
                     localConfig.label = existingLocal.label;
                 if (existingLocal.exclude_labels)
                     localConfig.exclude_labels = existingLocal.exclude_labels;
+                if (existingLocal.status_source)
+                    localConfig.status_source = existingLocal.status_source;
             }
         }
         catch {
@@ -338,6 +646,11 @@ async function init() {
     }
     await fs.writeFile(paths.localPath, encode(localConfig), "utf-8");
     console.log(`  ✓ ${paths.localPath}`);
+    // Update .gitignore
+    const tttDir = paths.baseDir.replace(/^\.\//, "");
+    await updateGitignore(tttDir, options.interactive ?? true);
+    // Install Claude Code commands
+    const { installed: commandsInstalled, prefix: commandPrefix } = await installClaudeCommands(options.interactive ?? true, statusSource);
     // Summary
     console.log("\n✅ Initialization complete!\n");
     console.log("Configuration summary:");
@@ -347,6 +660,10 @@ async function init() {
     }
     console.log(`  User: ${currentUser.displayName || currentUser.name} (${currentUser.email})`);
     console.log(`  Label filter: ${defaultLabel || "(none)"}`);
+    console.log(`  Status source: ${statusSource === "local" ? "local (use 'sync --update' to push)" : "remote (immediate sync)"}`);
+    if (qaPmTeam) {
+        console.log(`  QA/PM team: ${qaPmTeam.name}`);
+    }
     console.log(`  (Use 'ttt config filters' to set excluded labels/users)`);
     if (currentCycle) {
         console.log(`  Cycle: ${currentCycle.name || `Cycle #${currentCycle.number}`}`);
@@ -358,10 +675,24 @@ async function init() {
     if (statusTransitions.testing) {
         console.log(`    Testing: ${statusTransitions.testing}`);
     }
+    if (statusTransitions.blocked) {
+        console.log(`    Blocked: ${statusTransitions.blocked}`);
+    }
+    if (commandsInstalled) {
+        const cmdPrefix = commandPrefix ? `${commandPrefix}` : "";
+        console.log(`  Claude commands: /${cmdPrefix}work-on, /${cmdPrefix}done-job, /${cmdPrefix}sync-linear`);
+    }
     console.log("\nNext steps:");
     console.log("  1. Set LINEAR_API_KEY in your shell profile:");
     console.log(`     export LINEAR_API_KEY="${apiKey}"`);
-    console.log("  2. Run sync: bun run sync");
-    console.log("  3. Start working: bun run work-on");
+    console.log("  2. Run sync: ttt sync");
+    if (commandsInstalled) {
+        const cmdPrefix = commandPrefix ? `${commandPrefix}` : "";
+        console.log(`  3. In Claude Code: /${cmdPrefix}work-on next`);
+        console.log(`\n💡 Tip: Edit .claude/commands/${cmdPrefix}work-on.md to customize the "Verify" section for your project.`);
+    }
+    else {
+        console.log("  3. Start working: ttt work-on");
+    }
 }
 init().catch(console.error);

package/dist/scripts/lib/config-builder.d.ts

@@ -38,4 +38,4 @@ export declare function getDefaultStatusTransitions(states: LinearState[]): Stat
 export declare function buildConfig(teams: LinearTeam[], users: LinearUser[], labels: LinearLabel[], states: LinearState[], statusTransitions: StatusTransitions, currentCycle?: LinearCycle): Config;
 export declare function findUserKey(usersConfig: Record<string, UserConfig>, userId: string): string;
 export declare function findTeamKey(teamsConfig: Record<string, TeamConfig>, teamId: string): string;
-export declare function buildLocalConfig(currentUserKey: string, primaryTeamKey: string, selectedTeamKeys: string[], defaultLabel?: string, excludeLabels?: string[]): LocalConfig;
+export declare function buildLocalConfig(currentUserKey: string, primaryTeamKey: string, selectedTeamKeys: string[], defaultLabel?: string, excludeLabels?: string[], statusSource?: "remote" | "local", qaPmTeam?: string): LocalConfig;

package/dist/scripts/lib/config-builder.js

@@ -67,11 +67,13 @@ export function getDefaultStatusTransitions(states) {
         findStatusByKeyword(states, ["done", "complete"]) ||
         "Done";
     const defaultTesting = findStatusByKeyword(states, ["testing", "review"]) || undefined;
+    const defaultBlocked = findStatusByKeyword(states, ["blocked", "on hold", "waiting"]) || undefined;
     return {
         todo: defaultTodo,
         in_progress: defaultInProgress,
         done: defaultDone,
         testing: defaultTesting,
+        blocked: defaultBlocked,
     };
 }
 export function buildConfig(teams, users, labels, states, statusTransitions, currentCycle) {
@@ -106,12 +108,14 @@ export function findTeamKey(teamsConfig, teamId) {
     return (Object.entries(teamsConfig).find(([_, t]) => t.id === teamId)?.[0] ||
         Object.keys(teamsConfig)[0]);
 }
-export function buildLocalConfig(currentUserKey, primaryTeamKey, selectedTeamKeys, defaultLabel, excludeLabels) {
+export function buildLocalConfig(currentUserKey, primaryTeamKey, selectedTeamKeys, defaultLabel, excludeLabels, statusSource, qaPmTeam) {
     return {
         current_user: currentUserKey,
         team: primaryTeamKey,
         teams: selectedTeamKeys.length > 1 ? selectedTeamKeys : undefined,
+        qa_pm_team: qaPmTeam,
         label: defaultLabel,
         exclude_labels: excludeLabels && excludeLabels.length > 0 ? excludeLabels : undefined,
+        status_source: statusSource,
     };
 }

package/dist/scripts/lib/display.js

@@ -11,7 +11,7 @@ export function getStatusIcon(localStatus) {
             return "✅";
         case "in-progress":
             return "🔄";
-        case "blocked-backend":
+        case "blocked":
             return "🚫";
         default:
             return "📋";
@@ -39,14 +39,25 @@ export function displayTaskStatus(task) {
 }
 export function displayTaskDescription(task) {
     if (task.description) {
-        console.log(`\n📝 Description:\n${task.description}`);
+        let description = task.description;
+        // Replace Linear URLs with local paths from attachments
+        if (task.attachments) {
+            for (const att of task.attachments) {
+                if (att.localPath && att.url) {
+                    description = description.split(att.url).join(att.localPath);
+                }
+            }
+        }
+        console.log(`\n📝 Description:\n${description}`);
     }
 }
 export function displayTaskAttachments(task) {
     if (task.attachments && task.attachments.length > 0) {
         console.log(`\n📎 Attachments:`);
         for (const att of task.attachments) {
-            console.log(`   - ${att.title}: ${att.url}`);
+            // Prefer local path for Linear images (Linear URLs are not accessible)
+            const displayPath = att.localPath || att.url;
+            console.log(`   - ${att.title}: ${displayPath}`);
         }
     }
 }

package/dist/scripts/lib/images.d.ts

@@ -0,0 +1,9 @@
+export declare function isLinearImageUrl(url: string): boolean;
+/**
+ * Extract Linear image URLs from markdown text (description, comments)
+ */
+export declare function extractLinearImageUrls(text: string): string[];
+export declare function downloadLinearFile(url: string, issueId: string, attachmentId: string, outputDir: string): Promise<string | undefined>;
+export declare const downloadLinearImage: typeof downloadLinearFile;
+export declare function clearIssueImages(outputDir: string, issueId: string): Promise<void>;
+export declare function ensureOutputDir(outputDir: string): Promise<void>;

package/dist/scripts/lib/images.js

@@ -0,0 +1,107 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+const LINEAR_IMAGE_DOMAINS = [
+    "uploads.linear.app",
+    "linear-uploads.s3.us-west-2.amazonaws.com",
+];
+export function isLinearImageUrl(url) {
+    try {
+        const parsed = new URL(url);
+        return LINEAR_IMAGE_DOMAINS.some((domain) => parsed.host.includes(domain));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Extract Linear image URLs from markdown text (description, comments)
+ */
+export function extractLinearImageUrls(text) {
+    const urls = [];
+    // Match markdown image syntax ![alt](url) and plain URLs
+    const patterns = [
+        /!\[[^\]]*\]\((https?:\/\/[^)]+)\)/g, // ![alt](url)
+        /(https?:\/\/uploads\.linear\.app\/[^\s)>\]]+)/g, // Plain Linear upload URLs
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(text)) !== null) {
+            const url = match[1];
+            if (isLinearImageUrl(url) && !urls.includes(url)) {
+                urls.push(url);
+            }
+        }
+    }
+    return urls;
+}
+function getFileExtension(url, contentType) {
+    // Try to get extension from content-type header
+    if (contentType) {
+        // Image types
+        const imageMatch = contentType.match(/image\/(\w+)/);
+        if (imageMatch) {
+            const ext = imageMatch[1] === "jpeg" ? "jpg" : imageMatch[1];
+            return { ext, isImage: true };
+        }
+        // Video types
+        const videoMatch = contentType.match(/video\/(\w+)/);
+        if (videoMatch) {
+            const videoExt = videoMatch[1] === "quicktime" ? "mov" : videoMatch[1];
+            return { ext: videoExt, isImage: false };
+        }
+    }
+    // Fallback: try to get from URL path
+    const urlPath = new URL(url).pathname;
+    const ext = path.extname(urlPath).slice(1).toLowerCase();
+    if (["jpg", "jpeg", "png", "gif", "webp", "svg"].includes(ext)) {
+        return { ext: ext === "jpeg" ? "jpg" : ext, isImage: true };
+    }
+    if (["mov", "mp4", "webm", "avi"].includes(ext)) {
+        return { ext, isImage: false };
+    }
+    return { ext: "png", isImage: true }; // Default assume image
+}
+export async function downloadLinearFile(url, issueId, attachmentId, outputDir) {
+    try {
+        // Linear files require authentication
+        const headers = {};
+        if (process.env.LINEAR_API_KEY) {
+            headers["Authorization"] = process.env.LINEAR_API_KEY;
+        }
+        const response = await fetch(url, { headers });
+        if (!response.ok) {
+            console.error(`Failed to download file: ${response.status}`);
+            return undefined;
+        }
+        const contentType = response.headers.get("content-type") || undefined;
+        const { ext } = getFileExtension(url, contentType);
+        const filename = `${issueId}_${attachmentId}.${ext}`;
+        const filepath = path.join(outputDir, filename);
+        const buffer = await response.arrayBuffer();
+        await fs.writeFile(filepath, Buffer.from(buffer));
+        return filepath;
+    }
+    catch (error) {
+        console.error(`Error downloading file: ${error}`);
+        return undefined;
+    }
+}
+// Alias for backwards compatibility
+export const downloadLinearImage = downloadLinearFile;
+export async function clearIssueImages(outputDir, issueId) {
+    try {
+        const files = await fs.readdir(outputDir);
+        const issuePrefix = `${issueId}_`;
+        for (const file of files) {
+            if (file.startsWith(issuePrefix)) {
+                await fs.unlink(path.join(outputDir, file));
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist or other error, ignore
+    }
+}
+export async function ensureOutputDir(outputDir) {
+    await fs.mkdir(outputDir, { recursive: true });
+}

package/dist/scripts/lib/linear.d.ts

@@ -8,4 +8,4 @@ export declare function getWorkflowStates(config: Config, teamKey: string): Prom
 export declare function getStatusTransitions(config: Config): StatusTransitions;
 export declare function updateIssueStatus(linearId: string, targetStatusName: string, config: Config, teamKey: string): Promise<boolean>;
 export declare function addComment(issueId: string, body: string): Promise<boolean>;
-export declare function mapLocalStatusToLinear(localStatus: "pending" | "in-progress" | "completed" | "blocked-backend", config: Config): string | undefined;
+export declare function mapLocalStatusToLinear(localStatus: "pending" | "in-progress" | "completed" | "blocked", config: Config): string | undefined;

package/dist/scripts/lib/linear.js

@@ -55,6 +55,8 @@ export function mapLocalStatusToLinear(localStatus, config) {
             return transitions.in_progress;
         case "completed":
             return transitions.done;
+        case "blocked":
+            return transitions.blocked;
         default:
             return undefined;
     }