team-toon-tack 3.10.0 → 3.10.2

package/.claude-plugin/marketplace.json

@@ -13,7 +13,7 @@
 			"name": "team-toon-tack",
 			"source": "./",
 			"description": "Linear/Trello task sync & management CLI with commands and skills",
-			"version": "3.10.0"
+			"version": "3.10.2"
 		}
 	]
 }

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
 	"name": "team-toon-tack",
 	"description": "Linear/Trello task sync & management CLI for Claude Code - saves tokens vs MCP",
-	"version": "3.10.0",
+	"version": "3.10.2",
 	"author": {
 		"name": "wayne930242",
 		"email": "wayne930242@gmail.com"

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
 	"name": "team-toon-tack",
-	"version": "3.10.0",
+	"version": "3.10.2",
 	"description": "透過 ttt CLI 同步與管理 Linear、Trello 任務。",
 	"author": {
 		"name": "wayne930242"

package/dist/bin/cli.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { loadDotEnv, resolveLinearApiKey } from "../scripts/lib/env.js";
+import { findAncestorWithTtt } from "../scripts/utils.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 // When running from dist/bin/cli.js, we need to go up two levels to find package.json
 const pkg = JSON.parse(readFileSync(join(__dirname, "..", "..", "package.json"), "utf-8"));
@@ -51,7 +52,8 @@ COMMANDS:
   version    Show version
 
 GLOBAL OPTIONS:
-  --dir <path>        Config directory (default: .ttt)
+  --dir <path>        Config directory (default: nearest ancestor .ttt,
+                      searched upward from cwd, stopping at $HOME)
                       Can also set via TOON_DIR environment variable
   -d <path>           Shortcut for --dir; ignored for create/edit/comment
                       (where -d means --description)
@@ -88,19 +90,39 @@ const SHORT_D_RESERVED_FOR_SUBCOMMAND = new Set([
     "comment",
 ]);
 function parseGlobalArgs(command, args) {
-    let dir = process.env.TOON_DIR || resolve(process.cwd(), ".ttt");
+    let explicitDir;
     const commandArgs = [];
     const allowShortD = !SHORT_D_RESERVED_FOR_SUBCOMMAND.has(command);
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg === "--dir" || (allowShortD && arg === "-d")) {
-            dir = resolve(args[++i] || ".");
+            explicitDir = resolve(args[++i] || ".");
         }
         else {
             commandArgs.push(arg);
         }
     }
-    return { dir, commandArgs };
+    // --dir wins over everything, then TOON_DIR/LINEAR_TOON_DIR, then an
+    // upward search from cwd for the nearest ancestor holding `.ttt`.
+    if (explicitDir)
+        return { dir: explicitDir, commandArgs };
+    if (process.env.TOON_DIR) {
+        return { dir: resolve(process.env.TOON_DIR), commandArgs };
+    }
+    if (process.env.LINEAR_TOON_DIR) {
+        return { dir: resolve(process.env.LINEAR_TOON_DIR), commandArgs };
+    }
+    // `init` always targets cwd/.ttt: reusing a discovered ancestor would let
+    // it silently rewrite a shared monorepo-root config from inside a
+    // worktree instead of creating (or reporting) one where the user stands.
+    if (command === "init") {
+        return { dir: resolve(process.cwd(), ".ttt"), commandArgs };
+    }
+    const found = findAncestorWithTtt(process.cwd());
+    return {
+        dir: found.dir !== null ? join(found.dir, ".ttt") : null,
+        commandArgs,
+    };
 }
 async function main() {
     const args = process.argv.slice(2);
@@ -118,17 +140,23 @@ async function main() {
     const command = args[0];
     const restArgs = args.slice(1);
     const { dir, commandArgs } = parseGlobalArgs(command, restArgs);
-    // Set TOON_DIR for scripts to use
-    process.env.TOON_DIR = dir;
+    // Set TOON_DIR for scripts to use. When no explicit override applies and
+    // the upward search found nothing, leave it unset so the invoked script's
+    // own resolution reports the exact range it searched.
+    if (dir !== null) {
+        process.env.TOON_DIR = dir;
+    }
     // Load .ttt/.env (if present) and resolve configured Linear API key env
     // var into LINEAR_API_KEY so downstream code is workspace-aware.
     // Skip the resolver for `init` so the workspace picker sees the raw
     // env — otherwise we'd mirror the previously-saved key over LINEAR_API_KEY
     // and the user's shell-level key would appear to point to the saved
     // workspace.
-    await loadDotEnv(join(dir, ".env"));
-    if (command !== "init") {
-        await resolveLinearApiKey(join(dir, "local.toon"));
+    if (dir !== null) {
+        await loadDotEnv(join(dir, ".env"));
+        if (command !== "init") {
+            await resolveLinearApiKey(join(dir, "local.toon"));
+        }
     }
     if (!COMMANDS.includes(command)) {
         console.error(`Unknown command: ${command}`);

package/dist/scripts/init.js

@@ -14,7 +14,9 @@ async function init() {
         process.exit(0);
     }
     const options = parseArgs(args);
-    const paths = getPaths();
+    // `init` always targets cwd/.ttt, never a discovered ancestor - see
+    // getPaths' doc comment.
+    const paths = getPaths({ search: false });
     // Convert paths to InitPaths format
     const initPaths = {
         baseDir: paths.baseDir,

package/dist/scripts/lib/done/linear-handler.js

@@ -4,9 +4,12 @@
 import { buildCompletionComment } from "../git.js";
 import { addComment, getStatusTransitions, updateIssueStatus, } from "../linear.js";
 import { updateParentStatus, updateParentToTesting } from "./parent-issue.js";
+function logParentUnchanged(parentIssueId, unfinishedChildren) {
+    console.log(`Linear: Parent ${parentIssueId} unchanged (unfinished sub-issues: ${unfinishedChildren.join(", ")})`);
+}
 /**
  * Handle simple completion mode
- * Mark task as done, also mark parent as done if exists
+ * Mark task as done, also mark parent as done once all its sub-issues are finished
  */
 async function handleSimpleCompletion(context) {
     const { task, config, localConfig } = context;
@@ -25,10 +28,13 @@ async function handleSimpleCompletion(context) {
     }
     // Also mark parent as done if exists
     if (task.parentIssueId) {
-        const result = await updateParentStatus(task.parentIssueId, transitions.done, localConfig.qa_pm_teams, config);
+        const result = await updateParentStatus(task.parentIssueId, task.id, transitions.done, localConfig.qa_pm_teams, config);
         if (result.success) {
             console.log(`Linear: Parent ${task.parentIssueId} → ${transitions.done}`);
         }
+        else if (result.unfinishedChildren?.length) {
+            logParentUnchanged(task.parentIssueId, result.unfinishedChildren);
+        }
     }
     return { success: true, status: transitions.done };
 }
@@ -55,10 +61,13 @@ async function handleStrictReview(context) {
         }
         // Also mark parent to testing if exists
         if (task.parentIssueId && localConfig.qa_pm_teams?.length) {
-            const result = await updateParentToTesting(task.parentIssueId, localConfig.qa_pm_teams, config);
+            const result = await updateParentToTesting(task.parentIssueId, task.id, localConfig.qa_pm_teams, config, devTestingStatus);
             if (result.success) {
                 console.log(`Linear: Parent ${task.parentIssueId} → ${result.testingStatus}`);
             }
+            else if (result.unfinishedChildren?.length) {
+                logParentUnchanged(task.parentIssueId, result.unfinishedChildren);
+            }
         }
         return { success: true, status: devTestingStatus };
     }
@@ -94,16 +103,25 @@ async function handleUpstreamCompletion(context, isStrict) {
     // Try to update parent to testing
     let parentUpdateSuccess = false;
     let parentTestingStatus;
+    // Parent is valid but waits for its other sub-issues; it moves when the last one completes
+    let parentAwaitingSiblings = false;
     if (task.parentIssueId && localConfig.qa_pm_teams?.length) {
-        const result = await updateParentToTesting(task.parentIssueId, localConfig.qa_pm_teams, config);
+        const result = await updateParentToTesting(task.parentIssueId, task.id, localConfig.qa_pm_teams, config, devTestingStatus);
         parentUpdateSuccess = result.success;
         parentTestingStatus = result.testingStatus;
         if (parentUpdateSuccess) {
             console.log(`Linear: Parent ${task.parentIssueId} → ${parentTestingStatus}`);
         }
+        else if (result.unfinishedChildren?.length) {
+            parentAwaitingSiblings = true;
+            logParentUnchanged(task.parentIssueId, result.unfinishedChildren);
+        }
     }
     // Fallback logic for upstream_strict
-    if (isStrict && !parentUpdateSuccess && devTestingStatus) {
+    if (isStrict &&
+        !parentUpdateSuccess &&
+        !parentAwaitingSiblings &&
+        devTestingStatus) {
         // No parent or parent update failed, fallback to testing
         const fallbackSuccess = await updateIssueStatus(task.linearId, devTestingStatus, config, localConfig.team);
         if (fallbackSuccess) {

package/dist/scripts/lib/done/parent-issue.d.ts

@@ -1,13 +1,29 @@
 /**
  * Parent issue update logic for Linear
  */
+import type { LinearClient } from "@linear/sdk";
 import type { Config, QaPmTeamConfig } from "../../utils.js";
 import type { ParentUpdateResult } from "./types.js";
+export interface ChildIssueState {
+    identifier: string;
+    state?: {
+        name: string;
+        type: string;
+    };
+}
 /**
- * Update parent issue to a specific status
+ * Sub-issues other than the completing one that are still unfinished.
+ * A sub-issue is finished once its state is completed/canceled, or once it
+ * sits in one of the hand-off statuses (e.g. Testing).
  */
-export declare function updateParentStatus(parentIssueId: string, targetStatus: string, _qaPmTeams: QaPmTeamConfig[] | undefined, config: Config): Promise<ParentUpdateResult>;
+export declare function listUnfinishedSiblings(children: ChildIssueState[], childIssueId: string, handoffStatuses: readonly string[]): string[];
+export declare function findUnfinishedSiblings(client: LinearClient, parentId: string, childIssueId: string, handoffStatuses: readonly string[]): Promise<string[]>;
 /**
- * Update parent issue to testing status (uses QA team config)
+ * Update parent issue to a specific status once all its sub-issues are finished
  */
-export declare function updateParentToTesting(parentIssueId: string, qaPmTeams: QaPmTeamConfig[], config: Config): Promise<ParentUpdateResult>;
+export declare function updateParentStatus(parentIssueId: string, childIssueId: string, targetStatus: string, _qaPmTeams: QaPmTeamConfig[] | undefined, config: Config): Promise<ParentUpdateResult>;
+/**
+ * Update parent issue to testing status (uses QA team config) once all its
+ * sub-issues are finished or handed off to testing
+ */
+export declare function updateParentToTesting(parentIssueId: string, childIssueId: string, qaPmTeams: QaPmTeamConfig[], config: Config, devTestingStatus: string | undefined): Promise<ParentUpdateResult>;

package/dist/scripts/lib/done/parent-issue.js

@@ -3,10 +3,38 @@
  */
 import { getLinearClient } from "../../utils.js";
 import { getWorkflowStates } from "../linear.js";
+const FINISHED_STATE_TYPES = new Set(["completed", "canceled"]);
 /**
- * Update parent issue to a specific status
+ * Sub-issues other than the completing one that are still unfinished.
+ * A sub-issue is finished once its state is completed/canceled, or once it
+ * sits in one of the hand-off statuses (e.g. Testing).
  */
-export async function updateParentStatus(parentIssueId, targetStatus, _qaPmTeams, config) {
+export function listUnfinishedSiblings(children, childIssueId, handoffStatuses) {
+    return children
+        .filter((child) => child.identifier !== childIssueId)
+        .filter((child) => !child.state ||
+        !(FINISHED_STATE_TYPES.has(child.state.type) ||
+            handoffStatuses.includes(child.state.name)))
+        .map((child) => child.identifier);
+}
+export async function findUnfinishedSiblings(client, parentId, childIssueId, handoffStatuses) {
+    const children = await client.issues({
+        filter: { parent: { id: { eq: parentId } } },
+        first: 250,
+    });
+    const childStates = await Promise.all(children.nodes.map(async (child) => {
+        const state = await child.state;
+        return {
+            identifier: child.identifier,
+            state: state ? { name: state.name, type: state.type } : undefined,
+        };
+    }));
+    return listUnfinishedSiblings(childStates, childIssueId, handoffStatuses);
+}
+/**
+ * Update parent issue to a specific status once all its sub-issues are finished
+ */
+export async function updateParentStatus(parentIssueId, childIssueId, targetStatus, _qaPmTeams, config) {
     try {
         const client = getLinearClient();
         const searchResult = await client.searchIssues(parentIssueId);
@@ -31,6 +59,10 @@ export async function updateParentStatus(parentIssueId, targetStatus, _qaPmTeams
         if (!targetState) {
             return { success: false };
         }
+        const unfinishedChildren = await findUnfinishedSiblings(client, parentIssue.id, childIssueId, []);
+        if (unfinishedChildren.length > 0) {
+            return { success: false, unfinishedChildren };
+        }
         // Update the parent issue
         await client.updateIssue(parentIssue.id, {
             stateId: targetState.id,
@@ -43,9 +75,10 @@ export async function updateParentStatus(parentIssueId, targetStatus, _qaPmTeams
     }
 }
 /**
- * Update parent issue to testing status (uses QA team config)
+ * Update parent issue to testing status (uses QA team config) once all its
+ * sub-issues are finished or handed off to testing
  */
-export async function updateParentToTesting(parentIssueId, qaPmTeams, config) {
+export async function updateParentToTesting(parentIssueId, childIssueId, qaPmTeams, config, devTestingStatus) {
     try {
         const client = getLinearClient();
         const searchResult = await client.searchIssues(parentIssueId);
@@ -76,6 +109,14 @@ export async function updateParentToTesting(parentIssueId, qaPmTeams, config) {
         if (!testingState) {
             return { success: false };
         }
+        const handoffStatuses = qaPmTeams.map((qp) => qp.testing_status);
+        if (devTestingStatus) {
+            handoffStatuses.push(devTestingStatus);
+        }
+        const unfinishedChildren = await findUnfinishedSiblings(client, parentIssue.id, childIssueId, handoffStatuses);
+        if (unfinishedChildren.length > 0) {
+            return { success: false, unfinishedChildren };
+        }
         // Update the parent issue
         await client.updateIssue(parentIssue.id, {
             stateId: testingState.id,

package/dist/scripts/lib/done/types.d.ts

@@ -24,4 +24,6 @@ export interface ParentUpdateResult {
     success: boolean;
     status?: string;
     testingStatus?: string;
+    /** Other sub-issues still open; the parent was left unchanged */
+    unfinishedChildren?: string[];
 }

package/dist/scripts/utils.d.ts

@@ -1,17 +1,43 @@
 import { LinearClient } from "@linear/sdk";
 import type { SourceIssue } from "./lib/adapters/types.js";
+export interface AncestorSearch {
+    /** Directory the search started from (the process cwd). */
+    from: string;
+    /** Last directory checked before the search gave up ($HOME or the filesystem root). */
+    to: string;
+}
+/**
+ * Walk up from `startDir` looking for a `.ttt` directory, stopping at $HOME
+ * or the filesystem root, whichever comes first, so the search never escapes
+ * the user's home tree. Returns the directory that holds `.ttt` (not the
+ * `.ttt` path itself), or `null` with the searched range when none is found.
+ */
+export declare function findAncestorWithTtt(startDir: string): {
+    dir: string;
+} | {
+    dir: null;
+    search: AncestorSearch;
+};
 /**
  * Resolved on every call, so a TOON_DIR set after this module loads still
  * applies. Caching it at module load made the base directory depend on import
  * order.
+ *
+ * Pass `{ search: false }` to opt out of the upward ancestor search (used by
+ * `init`, which must always target cwd/.ttt regardless of what a parent
+ * directory holds).
  */
-export declare function getPaths(): {
+export declare function getPaths(opts?: {
+    search?: boolean;
+}): {
     baseDir: string;
     configPath: string;
     cyclePath: string;
     localPath: string;
     outputPath: string;
     envPath: string;
+    /** Set only when no ancestor `.ttt` was found, for error messages. */
+    search: AncestorSearch | null;
 };
 export interface TeamConfig {
     id: string;

package/dist/scripts/utils.js

@@ -1,29 +1,73 @@
+import { existsSync } from "node:fs";
 import fs from "node:fs/promises";
+import os from "node:os";
 import path from "node:path";
 import { LinearClient } from "@linear/sdk";
 // decode uses { strict: false } because encode() produces inline arrays
 // that strict mode rejects (RangeError: Expected 0 inline array items).
 import { decode, encode } from "@toon-format/toon";
+/**
+ * Walk up from `startDir` looking for a `.ttt` directory, stopping at $HOME
+ * or the filesystem root, whichever comes first, so the search never escapes
+ * the user's home tree. Returns the directory that holds `.ttt` (not the
+ * `.ttt` path itself), or `null` with the searched range when none is found.
+ */
+export function findAncestorWithTtt(startDir) {
+    const home = process.env.HOME || os.homedir();
+    let dir = startDir;
+    for (;;) {
+        if (existsSync(path.join(dir, ".ttt"))) {
+            return { dir };
+        }
+        if (dir === home)
+            break;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break; // filesystem root
+        dir = parent;
+    }
+    return { dir: null, search: { from: startDir, to: dir } };
+}
 // Resolve base directory - supports multiple configuration methods
-function getBaseDir() {
-    // 1. Check for TOON_DIR environment variable (set by CLI or user)
+function resolveBaseDir(searchAncestors) {
+    // 1. Check for TOON_DIR environment variable (set by CLI or user) - wins
+    // over the upward search, same as an explicit --dir.
     if (process.env.TOON_DIR) {
-        return path.resolve(process.env.TOON_DIR);
+        return { baseDir: path.resolve(process.env.TOON_DIR), search: null };
     }
     // 2. Check for legacy LINEAR_TOON_DIR environment variable
     if (process.env.LINEAR_TOON_DIR) {
-        return path.resolve(process.env.LINEAR_TOON_DIR);
+        return { baseDir: path.resolve(process.env.LINEAR_TOON_DIR), search: null };
     }
-    // 3. Default: .ttt directory in current working directory
-    return path.join(process.cwd(), ".ttt");
+    const cwd = process.cwd();
+    // 3. `init` (and anything else that opts out) always targets cwd/.ttt:
+    // reusing a discovered ancestor would let it silently rewrite a shared
+    // monorepo-root config from inside a worktree.
+    if (!searchAncestors) {
+        return { baseDir: path.join(cwd, ".ttt"), search: null };
+    }
+    // 4. Walk up from cwd to the nearest ancestor holding `.ttt` (monorepo
+    // root, typically), so commands work from nested submodules/worktrees.
+    const found = findAncestorWithTtt(cwd);
+    if (found.dir !== null) {
+        return { baseDir: path.join(found.dir, ".ttt"), search: null };
+    }
+    // 5. Nothing found anywhere up the chain - fall back to cwd/.ttt so the
+    // caller's error message can report the exact directory it tried, plus
+    // the range it searched.
+    return { baseDir: path.join(cwd, ".ttt"), search: found.search };
 }
 /**
  * Resolved on every call, so a TOON_DIR set after this module loads still
  * applies. Caching it at module load made the base directory depend on import
  * order.
+ *
+ * Pass `{ search: false }` to opt out of the upward ancestor search (used by
+ * `init`, which must always target cwd/.ttt regardless of what a parent
+ * directory holds).
  */
-export function getPaths() {
-    const baseDir = getBaseDir();
+export function getPaths(opts = {}) {
+    const { baseDir, search } = resolveBaseDir(opts.search ?? true);
     return {
         baseDir,
         configPath: path.join(baseDir, "config.toon"),
@@ -31,6 +75,8 @@ export function getPaths() {
         localPath: path.join(baseDir, "local.toon"),
         outputPath: path.join(baseDir, "output"),
         envPath: path.join(baseDir, ".env"),
+        /** Set only when no ancestor `.ttt` was found, for error messages. */
+        search,
     };
 }
 // Linear priority value to name mapping (fixed by Linear API)
@@ -63,26 +109,33 @@ export async function fileExists(filePath) {
         return false;
     }
 }
+function reportSearchRange(search) {
+    if (search) {
+        console.error(`No .ttt directory found from ${search.from} up to ${search.to}.`);
+    }
+}
 export async function loadConfig() {
-    const { configPath } = getPaths();
+    const { configPath, search } = getPaths();
     try {
         const fileContent = await fs.readFile(configPath, "utf-8");
         return decode(fileContent, { strict: false });
     }
     catch (error) {
         console.error(`Error loading config from ${configPath}:`, error);
+        reportSearchRange(search);
         console.error("Run `bun run init` to create configuration files.");
         process.exit(1);
     }
 }
 export async function loadLocalConfig() {
-    const { localPath } = getPaths();
+    const { localPath, search } = getPaths();
     try {
         const fileContent = await fs.readFile(localPath, "utf-8");
         return decode(fileContent, { strict: false });
     }
     catch {
         console.error(`Error: ${localPath} not found.`);
+        reportSearchRange(search);
         console.error("Run `bun run init` to create local configuration.");
         process.exit(1);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "team-toon-tack",
-	"version": "3.10.0",
+	"version": "3.10.2",
 	"description": "Linear & Trello task sync & management CLI with TOON format",
 	"type": "module",
 	"bin": {

package/dist/scripts/get-issue.d.ts

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

package/dist/scripts/get-issue.js

@@ -1,61 +0,0 @@
-import { displayTaskFull } from "./lib/display.js";
-import { fetchIssueDetail } from "./lib/sync.js";
-import { loadCycleData } from "./utils.js";
-async function getIssue() {
-    const args = process.argv.slice(2);
-    if (args.includes("--help") || args.includes("-h")) {
-        console.log(`Usage: ttt get-issue <issue-id> [--local]
-
-Fetch and display issue details from Linear.
-
-Arguments:
-  issue-id    Issue ID (e.g., MP-624). Required.
-
-Options:
-  --local     Only show from local cycle data, don't fetch from Linear
-
-Examples:
-  ttt get-issue MP-624         # Fetch from Linear and display
-  ttt get-issue MP-624 --local # Show from local data only`);
-        process.exit(0);
-    }
-    const localOnly = args.includes("--local");
-    const issueId = args.find((arg) => !arg.startsWith("-"));
-    if (!issueId) {
-        console.error("Issue ID is required.");
-        console.error("Usage: ttt get-issue <issue-id>");
-        process.exit(1);
-    }
-    // If local only, get from cycle data
-    if (localOnly) {
-        const data = await loadCycleData();
-        if (!data) {
-            console.error("No cycle data found. Run ttt sync first.");
-            process.exit(1);
-        }
-        const 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);
-        }
-        displayTaskFull(task, "📋");
-        return;
-    }
-    // Fetch from Linear
-    console.log(`Fetching ${issueId} from Linear...`);
-    const task = await fetchIssueDetail(issueId);
-    if (!task) {
-        console.error(`Issue ${issueId} not found in Linear.`);
-        process.exit(1);
-    }
-    // Check local data for local status
-    const data = await loadCycleData();
-    if (data) {
-        const localTask = data.tasks.find((t) => t.id === issueId);
-        if (localTask) {
-            task.localStatus = localTask.localStatus;
-        }
-    }
-    displayTaskFull(task, "📋");
-}
-getIssue().catch(console.error);

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

@@ -1,9 +0,0 @@
-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

@@ -1,136 +0,0 @@
-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 = pattern.exec(text);
-        while (match) {
-            const url = match[1];
-            if (isLinearImageUrl(url) && !urls.includes(url)) {
-                urls.push(url);
-            }
-            match = pattern.exec(text);
-        }
-    }
-    return urls;
-}
-// MIME type to extension mapping
-const MIME_TO_EXT = {
-    // Images
-    "image/jpeg": "jpg",
-    "image/png": "png",
-    "image/gif": "gif",
-    "image/webp": "webp",
-    "image/svg+xml": "svg",
-    // Videos
-    "video/mp4": "mp4",
-    "video/webm": "webm",
-    "video/quicktime": "mov",
-    "video/x-msvideo": "avi",
-    // Documents
-    "application/json": "json",
-    "application/pdf": "pdf",
-    "text/plain": "txt",
-    "text/html": "html",
-    "text/css": "css",
-    "text/javascript": "js",
-    "application/javascript": "js",
-    // Archives
-    "application/zip": "zip",
-    "application/gzip": "gz",
-    "application/x-tar": "tar",
-};
-function getFileExtension(url, contentType) {
-    // Try to get extension from content-type header
-    if (contentType) {
-        // Extract base MIME type (ignore charset and other params)
-        const baseMime = contentType.split(";")[0].trim().toLowerCase();
-        // Check our mapping
-        const mappedExt = MIME_TO_EXT[baseMime];
-        if (mappedExt) {
-            const isImage = baseMime.startsWith("image/");
-            return { ext: mappedExt, isImage };
-        }
-        // Fallback: extract from MIME type pattern
-        const match = baseMime.match(/^(\w+)\/(\w+)/);
-        if (match) {
-            const [, type, subtype] = match;
-            const isImage = type === "image";
-            return { ext: subtype, isImage };
-        }
-    }
-    // Fallback: try to get from URL path
-    const urlPath = new URL(url).pathname;
-    const ext = path.extname(urlPath).slice(1).toLowerCase();
-    if (ext) {
-        const isImage = ["jpg", "jpeg", "png", "gif", "webp", "svg"].includes(ext);
-        return { ext: ext === "jpeg" ? "jpg" : ext, isImage };
-    }
-    // Last resort: unknown binary
-    return { ext: "bin", isImage: false };
-}
-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 });
-}