team-toon-tack 3.10.0 → 3.10.1

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.1"
 		}
 	]
 }

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.1",
 	"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.1",
 	"description": "透過 ttt CLI 同步與管理 Linear、Trello 任務。",
 	"author": {
 		"name": "wayne930242"

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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "team-toon-tack",
-	"version": "3.10.0",
+	"version": "3.10.1",
 	"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 });
-}