team-toon-tack 2.0.3 → 2.3.0

package/dist/scripts/config/teams.js

@@ -1,4 +1,5 @@
 import prompts from "prompts";
+import { getDefaultStatusTransitions } from "../lib/config-builder.js";
 import { getLinearClient, saveLocalConfig, } from "../utils.js";
 export async function configureTeams(_config, localConfig) {
     console.log("👥 Configure Teams\n");
@@ -9,51 +10,182 @@ export async function configureTeams(_config, localConfig) {
         console.error("No teams found.");
         process.exit(1);
     }
-    // Multi-select teams
-    const teamsResponse = await prompts({
-        type: "multiselect",
-        name: "teamKeys",
-        message: "Select teams to sync (space to select):",
+    // Build team key mapping
+    const teamKeyMap = new Map(); // id -> key
+    for (const team of teams) {
+        const key = team.name.toLowerCase().replace(/[^a-z0-9]/g, "_");
+        teamKeyMap.set(team.id, key);
+    }
+    // Fetch workflow states for all teams
+    const teamStatesMap = new Map();
+    for (const team of teams) {
+        try {
+            const statesData = await client.workflowStates({
+                filter: { team: { id: { eq: team.id } } },
+            });
+            teamStatesMap.set(team.id, statesData.nodes);
+        }
+        catch {
+            teamStatesMap.set(team.id, []);
+        }
+    }
+    // 1. Select dev team (single)
+    console.log("\n👨‍💻 Dev Team:");
+    const devTeamResponse = await prompts({
+        type: "select",
+        name: "teamId",
+        message: "Select your dev team:",
         choices: teams.map((t) => {
-            const key = t.name.toLowerCase().replace(/[^a-z0-9]/g, "_");
-            const currentTeams = localConfig.teams || [localConfig.team];
+            const key = teamKeyMap.get(t.id) || "";
             return {
                 title: t.name,
-                value: key,
-                selected: currentTeams.includes(key),
+                value: t.id,
+                selected: key === localConfig.team,
             };
         }),
-        min: 1,
     });
-    const selectedTeamKeys = teamsResponse.teamKeys || [localConfig.team];
-    // If multiple teams, ask for primary
-    let primaryTeam = localConfig.team;
-    if (selectedTeamKeys.length > 1) {
-        const primaryResponse = await prompts({
-            type: "select",
-            name: "primary",
-            message: "Select primary team:",
-            choices: selectedTeamKeys.map((key) => ({
-                title: key,
-                value: key,
+    const devTeamId = devTeamResponse.teamId;
+    const devTeamKey = teamKeyMap.get(devTeamId) || localConfig.team;
+    const devTeam = teams.find((t) => t.id === devTeamId);
+    // 2. Select dev team testing status
+    const devStates = teamStatesMap.get(devTeamId) || [];
+    const devDefaults = getDefaultStatusTransitions(devStates);
+    console.log("\n🔍 Dev Team Testing/Review Status:");
+    const devTestingResponse = await prompts({
+        type: "select",
+        name: "testingStatus",
+        message: "Select testing/review status for dev team:",
+        choices: [
+            { title: "(Skip - no testing status)", value: undefined },
+            ...devStates.map((s) => ({
+                title: `${s.name} (${s.type})`,
+                value: s.name,
             })),
-            initial: selectedTeamKeys.indexOf(localConfig.team),
+        ],
+        initial: localConfig.dev_testing_status
+            ? devStates.findIndex((s) => s.name === localConfig.dev_testing_status) +
+                1
+            : devDefaults.testing
+                ? devStates.findIndex((s) => s.name === devDefaults.testing) + 1
+                : 0,
+    });
+    const devTestingStatus = devTestingResponse.testingStatus;
+    // 3. Select QA/PM teams (multiple)
+    const otherTeams = teams.filter((t) => t.id !== devTeamId);
+    const qaPmTeams = [];
+    if (otherTeams.length > 0) {
+        console.log("\n🔗 QA/PM Teams:");
+        const qaPmResponse = await prompts({
+            type: "multiselect",
+            name: "teamIds",
+            message: "Select QA/PM teams for cross-team parent updates (space to select):",
+            choices: otherTeams.map((t) => {
+                const key = teamKeyMap.get(t.id) || "";
+                const currentQaPm = localConfig.qa_pm_teams || [];
+                return {
+                    title: t.name,
+                    value: t.id,
+                    selected: currentQaPm.some((qp) => qp.team === key),
+                };
+            }),
+            hint: "- Press space to select, enter to confirm. Leave empty to skip.",
         });
-        primaryTeam = primaryResponse.primary || selectedTeamKeys[0];
+        const selectedQaPmIds = qaPmResponse.teamIds || [];
+        // 4. For each QA/PM team, select testing status
+        for (const teamId of selectedQaPmIds) {
+            const team = teams.find((t) => t.id === teamId);
+            if (!team)
+                continue;
+            const teamKey = teamKeyMap.get(teamId) || "";
+            const teamStates = teamStatesMap.get(teamId) || [];
+            const defaults = getDefaultStatusTransitions(teamStates);
+            // Find existing config for this team
+            const existingConfig = localConfig.qa_pm_teams?.find((qp) => qp.team === teamKey);
+            const stateChoices = teamStates.map((s) => ({
+                title: `${s.name} (${s.type})`,
+                value: s.name,
+            }));
+            const statusResponse = await prompts({
+                type: "select",
+                name: "testingStatus",
+                message: `Select testing status for ${team.name}:`,
+                choices: [
+                    { title: "(Skip this team)", value: undefined },
+                    ...stateChoices,
+                ],
+                initial: existingConfig?.testing_status
+                    ? stateChoices.findIndex((c) => c.value === existingConfig.testing_status) + 1
+                    : defaults.testing
+                        ? stateChoices.findIndex((c) => c.value === defaults.testing) + 1
+                        : 0,
+            });
+            if (statusResponse.testingStatus) {
+                qaPmTeams.push({
+                    team: teamKey,
+                    testing_status: statusResponse.testingStatus,
+                });
+            }
+        }
     }
-    else {
-        primaryTeam = selectedTeamKeys[0];
-    }
-    localConfig.team = primaryTeam;
-    localConfig.teams =
-        selectedTeamKeys.length > 1 ? selectedTeamKeys : undefined;
+    // 5. Select completion mode
+    console.log("\n✅ Completion Mode:");
+    const currentMode = localConfig.completion_mode ||
+        (qaPmTeams.length > 0 ? "upstream_strict" : "simple");
+    const defaultModeIndex = currentMode === "simple"
+        ? 0
+        : currentMode === "strict_review"
+            ? 1
+            : currentMode === "upstream_strict"
+                ? 2
+                : 3;
+    const modeResponse = await prompts({
+        type: "select",
+        name: "mode",
+        message: "How should tasks be completed?",
+        choices: [
+            {
+                title: "Simple",
+                value: "simple",
+                description: "Mark task as done directly",
+            },
+            {
+                title: "Strict Review",
+                value: "strict_review",
+                description: "Mark task to dev team's testing status",
+            },
+            {
+                title: "Upstream Strict (recommended with QA/PM)",
+                value: "upstream_strict",
+                description: "Done + parent to testing, fallback to testing if no parent",
+            },
+            {
+                title: "Upstream Not Strict",
+                value: "upstream_not_strict",
+                description: "Done + parent to testing, no fallback",
+            },
+        ],
+        initial: defaultModeIndex,
+    });
+    const completionMode = modeResponse.mode || (qaPmTeams.length > 0 ? "upstream_strict" : "simple");
+    // Update local config
+    localConfig.team = devTeamKey;
+    localConfig.dev_testing_status = devTestingStatus;
+    localConfig.qa_pm_teams = qaPmTeams.length > 0 ? qaPmTeams : undefined;
+    localConfig.completion_mode = completionMode;
+    // Remove deprecated fields
+    delete localConfig.teams;
+    delete localConfig.qa_pm_team;
     await saveLocalConfig(localConfig);
     console.log("\n✅ Teams updated:");
-    if (localConfig.teams) {
-        console.log(`  Selected: ${localConfig.teams.join(", ")}`);
-        console.log(`  Primary: ${localConfig.team}`);
+    console.log(`  Dev Team: ${devTeam?.name || devTeamKey}`);
+    if (devTestingStatus) {
+        console.log(`  Dev Testing Status: ${devTestingStatus}`);
     }
-    else {
-        console.log(`  Team: ${localConfig.team}`);
+    console.log(`  Completion Mode: ${completionMode}`);
+    if (qaPmTeams.length > 0) {
+        console.log("  QA/PM Teams:");
+        for (const qp of qaPmTeams) {
+            console.log(`    - ${qp.team}: ${qp.testing_status}`);
+        }
     }
 }

package/dist/scripts/done-job.js

@@ -3,6 +3,86 @@ import { buildCompletionComment, getLatestCommit } from "./lib/git.js";
 import { addComment, getStatusTransitions, getWorkflowStates, updateIssueStatus, } from "./lib/linear.js";
 import { syncSingleIssue } from "./lib/sync.js";
 import { getLinearClient, loadConfig, loadCycleData, loadLocalConfig, } from "./utils.js";
+// Helper function to update parent issue to a specific status
+async function updateParentStatus(parentIssueId, targetStatus, _qaPmTeams, config) {
+    try {
+        const client = getLinearClient();
+        const searchResult = await client.searchIssues(parentIssueId);
+        const parentIssue = searchResult.nodes.find((issue) => issue.identifier === parentIssueId);
+        if (!parentIssue) {
+            return { success: false };
+        }
+        const parentTeam = await parentIssue.team;
+        if (!parentTeam) {
+            return { success: false };
+        }
+        // Find the matching team configuration
+        const teamEntries = Object.entries(config.teams);
+        const matchingTeamEntry = teamEntries.find(([_, t]) => t.id === parentTeam.id);
+        if (!matchingTeamEntry) {
+            return { success: false };
+        }
+        const [parentTeamKey] = matchingTeamEntry;
+        // Get workflow states for the parent's team
+        const parentStates = await getWorkflowStates(config, parentTeamKey);
+        const targetState = parentStates.find((s) => s.name === targetStatus);
+        if (!targetState) {
+            return { success: false };
+        }
+        // Update the parent issue
+        await client.updateIssue(parentIssue.id, {
+            stateId: targetState.id,
+        });
+        return { success: true, status: targetStatus };
+    }
+    catch (error) {
+        console.error("Failed to update parent issue:", error);
+        return { success: false };
+    }
+}
+// Helper function to update parent issue to testing status (uses QA team config)
+async function updateParentToTesting(parentIssueId, qaPmTeams, config) {
+    try {
+        const client = getLinearClient();
+        const searchResult = await client.searchIssues(parentIssueId);
+        const parentIssue = searchResult.nodes.find((issue) => issue.identifier === parentIssueId);
+        if (!parentIssue) {
+            return { success: false };
+        }
+        const parentTeam = await parentIssue.team;
+        if (!parentTeam) {
+            return { success: false };
+        }
+        // Find the matching QA/PM team configuration
+        const teamEntries = Object.entries(config.teams);
+        const matchingTeamEntry = teamEntries.find(([_, t]) => t.id === parentTeam.id);
+        if (!matchingTeamEntry) {
+            return { success: false };
+        }
+        const [parentTeamKey] = matchingTeamEntry;
+        // Find the QA/PM team config for this parent's team
+        const qaPmConfig = qaPmTeams.find((qp) => qp.team === parentTeamKey);
+        if (!qaPmConfig) {
+            // Parent's team is not in the configured QA/PM teams
+            return { success: false };
+        }
+        // Get workflow states for the parent's team
+        const parentStates = await getWorkflowStates(config, parentTeamKey);
+        const testingState = parentStates.find((s) => s.name === qaPmConfig.testing_status);
+        if (!testingState) {
+            return { success: false };
+        }
+        // Update the parent issue
+        await client.updateIssue(parentIssue.id, {
+            stateId: testingState.id,
+        });
+        return { success: true, testingStatus: qaPmConfig.testing_status };
+    }
+    catch (error) {
+        console.error("Failed to update parent issue:", error);
+        return { success: false };
+    }
+}
 function parseArgs(args) {
     let issueId;
     let message;
@@ -110,10 +190,84 @@ Examples:
         process.env.LINEAR_API_KEY &&
         statusSource === "remote") {
         const transitions = getStatusTransitions(config);
-        // Update issue to Done
-        const success = await updateIssueStatus(task.linearId, transitions.done, config, localConfig.team);
-        if (success) {
-            console.log(`Linear: ${task.id} → ${transitions.done}`);
+        // Determine completion mode
+        const completionMode = localConfig.completion_mode ||
+            (localConfig.qa_pm_teams && localConfig.qa_pm_teams.length > 0
+                ? "upstream_strict"
+                : "simple");
+        // Get the testing status to use (from dev team)
+        const devTestingStatus = localConfig.dev_testing_status || transitions.testing;
+        // Execute based on completion mode
+        let parentUpdateSuccess = false;
+        let parentTestingStatus;
+        switch (completionMode) {
+            case "simple": {
+                // Mark task as done
+                const success = await updateIssueStatus(task.linearId, transitions.done, config, localConfig.team);
+                if (success) {
+                    console.log(`Linear: ${task.id} → ${transitions.done}`);
+                }
+                // Also mark parent as done if exists
+                if (task.parentIssueId) {
+                    const result = await updateParentStatus(task.parentIssueId, transitions.done, localConfig.qa_pm_teams, config);
+                    if (result.success) {
+                        console.log(`Linear: Parent ${task.parentIssueId} → ${transitions.done}`);
+                    }
+                }
+                break;
+            }
+            case "strict_review": {
+                // Mark task to dev team's testing status
+                if (devTestingStatus) {
+                    const success = await updateIssueStatus(task.linearId, devTestingStatus, config, localConfig.team);
+                    if (success) {
+                        console.log(`Linear: ${task.id} → ${devTestingStatus}`);
+                    }
+                    // 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);
+                        if (result.success) {
+                            console.log(`Linear: Parent ${task.parentIssueId} → ${result.testingStatus}`);
+                        }
+                    }
+                }
+                else {
+                    console.warn("No dev testing status configured, falling back to done");
+                    const success = await updateIssueStatus(task.linearId, transitions.done, config, localConfig.team);
+                    if (success) {
+                        console.log(`Linear: ${task.id} → ${transitions.done}`);
+                    }
+                }
+                break;
+            }
+            case "upstream_strict":
+            case "upstream_not_strict": {
+                // First, mark as done
+                const doneSuccess = await updateIssueStatus(task.linearId, transitions.done, config, localConfig.team);
+                if (doneSuccess) {
+                    console.log(`Linear: ${task.id} → ${transitions.done}`);
+                }
+                // Try to update parent to testing
+                if (task.parentIssueId && localConfig.qa_pm_teams?.length) {
+                    const result = await updateParentToTesting(task.parentIssueId, localConfig.qa_pm_teams, config);
+                    parentUpdateSuccess = result.success;
+                    parentTestingStatus = result.testingStatus;
+                    if (parentUpdateSuccess) {
+                        console.log(`Linear: Parent ${task.parentIssueId} → ${parentTestingStatus}`);
+                    }
+                }
+                // Fallback logic for upstream_strict
+                if (completionMode === "upstream_strict" &&
+                    !parentUpdateSuccess &&
+                    devTestingStatus) {
+                    // No parent or parent update failed, fallback to testing
+                    const fallbackSuccess = await updateIssueStatus(task.linearId, devTestingStatus, config, localConfig.team);
+                    if (fallbackSuccess) {
+                        console.log(`Linear: ${task.id} → ${devTestingStatus} (fallback, no valid parent)`);
+                    }
+                }
+                break;
+            }
         }
         // Add comment with commit info
         if (commit) {
@@ -123,43 +277,6 @@ Examples:
                 console.log(`Linear: 已新增 commit 留言`);
             }
         }
-        // Update parent to Testing if exists
-        if (task.parentIssueId && transitions.testing) {
-            try {
-                const client = getLinearClient();
-                const searchResult = await client.searchIssues(task.parentIssueId);
-                const parentIssue = searchResult.nodes.find((issue) => issue.identifier === task.parentIssueId);
-                if (parentIssue) {
-                    const parentTeam = await parentIssue.team;
-                    if (parentTeam) {
-                        // Determine which team key to use for parent's workflow states
-                        // If qa_pm_team is configured and matches parent's team, use it
-                        // Otherwise, try to find the team key from config
-                        let parentTeamKey = localConfig.team;
-                        const teamEntries = Object.entries(config.teams);
-                        const matchingTeam = teamEntries.find(([_, t]) => t.id === parentTeam.id);
-                        if (matchingTeam) {
-                            parentTeamKey = matchingTeam[0];
-                        }
-                        else if (localConfig.qa_pm_team) {
-                            // Fallback to qa_pm_team if configured
-                            parentTeamKey = localConfig.qa_pm_team;
-                        }
-                        const parentStates = await getWorkflowStates(config, parentTeamKey);
-                        const testingState = parentStates.find((s) => s.name === transitions.testing);
-                        if (testingState) {
-                            await client.updateIssue(parentIssue.id, {
-                                stateId: testingState.id,
-                            });
-                            console.log(`Linear: Parent ${task.parentIssueId} → ${transitions.testing}`);
-                        }
-                    }
-                }
-            }
-            catch (parentError) {
-                console.error("Failed to update parent issue:", parentError);
-            }
-        }
     }
     else if (statusSource === "local") {
         console.log(`Local: ${task.id} marked as completed`);
@@ -187,9 +304,6 @@ Examples:
     if (aiMessage) {
         console.log(`AI: ${aiMessage}`);
     }
-    if (task.parentIssueId && config.status_transitions?.testing) {
-        console.log(`Parent: ${task.parentIssueId} → ${config.status_transitions.testing}`);
-    }
     console.log(`\n🎉 任務完成！`);
 }
 doneJob().catch(console.error);

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

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

package/dist/scripts/get-issue.js

@@ -0,0 +1,61 @@
+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);