team-toon-tack 1.0.12 → 1.6.1

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

@@ -0,0 +1,116 @@
+export function buildTeamsConfig(teams) {
+    const config = {};
+    for (const team of teams) {
+        const key = team.name.toLowerCase().replace(/[^a-z0-9]/g, "_");
+        config[key] = {
+            id: team.id,
+            name: team.name,
+            icon: team.icon || undefined,
+        };
+    }
+    return config;
+}
+export function buildUsersConfig(users) {
+    const config = {};
+    for (const user of users) {
+        const key = (user.displayName ||
+            user.name ||
+            user.email?.split("@")[0] ||
+            "user")
+            .toLowerCase()
+            .replace(/[^a-z0-9]/g, "_");
+        config[key] = {
+            id: user.id,
+            email: user.email || "",
+            displayName: user.displayName || user.name || "",
+        };
+    }
+    return config;
+}
+export function buildLabelsConfig(labels) {
+    const config = {};
+    for (const label of labels) {
+        const key = label.name.toLowerCase().replace(/[^a-z0-9]/g, "_");
+        config[key] = {
+            id: label.id,
+            name: label.name,
+            color: label.color || undefined,
+        };
+    }
+    return config;
+}
+export function buildStatusesConfig(states) {
+    const config = {};
+    for (const state of states) {
+        const key = state.name.toLowerCase().replace(/[^a-z0-9]/g, "_");
+        config[key] = {
+            name: state.name,
+            type: state.type,
+        };
+    }
+    return config;
+}
+export function getDefaultStatusTransitions(states) {
+    const defaultTodo = states.find((s) => s.type === "unstarted")?.name ||
+        states.find((s) => s.name === "Todo")?.name ||
+        states[0]?.name ||
+        "Todo";
+    const defaultInProgress = states.find((s) => s.type === "started")?.name ||
+        states.find((s) => s.name === "In Progress")?.name ||
+        "In Progress";
+    const defaultDone = states.find((s) => s.type === "completed")?.name ||
+        states.find((s) => s.name === "Done")?.name ||
+        "Done";
+    const defaultTesting = states.find((s) => s.name === "Testing")?.name ||
+        states.find((s) => s.name === "In Review")?.name;
+    return {
+        todo: defaultTodo,
+        in_progress: defaultInProgress,
+        done: defaultDone,
+        testing: defaultTesting,
+    };
+}
+export function buildConfig(teams, users, labels, states, statusTransitions, currentCycle) {
+    return {
+        teams: buildTeamsConfig(teams),
+        users: buildUsersConfig(users),
+        labels: buildLabelsConfig(labels),
+        priorities: {
+            urgent: { value: 1, name: "Urgent" },
+            high: { value: 2, name: "High" },
+            medium: { value: 3, name: "Medium" },
+            low: { value: 4, name: "Low" },
+        },
+        statuses: buildStatusesConfig(states),
+        status_transitions: statusTransitions,
+        priority_order: ["urgent", "high", "medium", "low", "none"],
+        current_cycle: currentCycle
+            ? {
+                id: currentCycle.id,
+                name: currentCycle.name || `Cycle #${currentCycle.number}`,
+                start_date: currentCycle.startsAt?.toISOString().split("T")[0] || "",
+                end_date: currentCycle.endsAt?.toISOString().split("T")[0] || "",
+            }
+            : undefined,
+        cycle_history: [],
+    };
+}
+export function findUserKey(usersConfig, userId) {
+    return (Object.entries(usersConfig).find(([_, u]) => u.id === userId)?.[0] || "user");
+}
+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, excludeAssignees) {
+    return {
+        current_user: currentUserKey,
+        team: primaryTeamKey,
+        teams: selectedTeamKeys.length > 1 ? selectedTeamKeys : undefined,
+        label: defaultLabel,
+        exclude_labels: excludeLabels && excludeLabels.length > 0 ? excludeLabels : undefined,
+        exclude_assignees: excludeAssignees && excludeAssignees.length > 0
+            ? excludeAssignees
+            : undefined,
+    };
+}

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

@@ -0,0 +1,12 @@
+import type { Task } from "../utils.js";
+export declare const PRIORITY_LABELS: Record<number, string>;
+export declare function getStatusIcon(localStatus: Task["localStatus"]): string;
+export declare function displayTaskHeader(task: Task, icon?: string): void;
+export declare function displayTaskInfo(task: Task): void;
+export declare function displayTaskStatus(task: Task): void;
+export declare function displayTaskDescription(task: Task): void;
+export declare function displayTaskAttachments(task: Task): void;
+export declare function displayTaskComments(task: Task): void;
+export declare function displayTaskFooter(): void;
+export declare function displayTaskFull(task: Task, icon?: string): void;
+export declare function displayTaskWithStatus(task: Task): void;

package/dist/scripts/lib/display.js

@@ -0,0 +1,91 @@
+export const PRIORITY_LABELS = {
+    0: "⚪ None",
+    1: "🔴 Urgent",
+    2: "🟠 High",
+    3: "🟡 Medium",
+    4: "🟢 Low",
+};
+export function getStatusIcon(localStatus) {
+    switch (localStatus) {
+        case "completed":
+            return "✅";
+        case "in-progress":
+            return "🔄";
+        case "blocked-backend":
+            return "🚫";
+        default:
+            return "📋";
+    }
+}
+export function displayTaskHeader(task, icon) {
+    const separator = "═".repeat(50);
+    console.log(`\n${separator}`);
+    console.log(`${icon || getStatusIcon(task.localStatus)} ${task.id}: ${task.title}`);
+    console.log(separator);
+}
+export function displayTaskInfo(task) {
+    console.log(`Priority: ${PRIORITY_LABELS[task.priority] || "None"}`);
+    console.log(`Labels: ${task.labels.join(", ")}`);
+    if (task.assignee)
+        console.log(`Assignee: ${task.assignee}`);
+    console.log(`Branch: ${task.branch || "N/A"}`);
+    if (task.url)
+        console.log(`URL: ${task.url}`);
+}
+export function displayTaskStatus(task) {
+    console.log(`\nStatus:`);
+    console.log(`  Local: ${task.localStatus}`);
+    console.log(`  Linear: ${task.status}`);
+}
+export function displayTaskDescription(task) {
+    if (task.description) {
+        console.log(`\n📝 Description:\n${task.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}`);
+        }
+    }
+}
+export function displayTaskComments(task) {
+    if (task.comments && task.comments.length > 0) {
+        console.log(`\n💬 Comments (${task.comments.length}):`);
+        for (const comment of task.comments) {
+            const date = new Date(comment.createdAt).toLocaleDateString();
+            console.log(`\n   [${comment.user || "Unknown"} - ${date}]`);
+            const lines = comment.body.split("\n");
+            for (const line of lines) {
+                console.log(`   ${line}`);
+            }
+        }
+    }
+}
+export function displayTaskFooter() {
+    console.log(`\n${"─".repeat(50)}`);
+}
+export function displayTaskFull(task, icon) {
+    displayTaskHeader(task, icon);
+    displayTaskInfo(task);
+    displayTaskDescription(task);
+    displayTaskAttachments(task);
+    displayTaskComments(task);
+    displayTaskFooter();
+}
+export function displayTaskWithStatus(task) {
+    displayTaskHeader(task);
+    displayTaskStatus(task);
+    console.log(`\nInfo:`);
+    console.log(`  Priority: ${PRIORITY_LABELS[task.priority] || "None"}`);
+    console.log(`  Labels: ${task.labels.join(", ")}`);
+    console.log(`  Assignee: ${task.assignee || "Unassigned"}`);
+    console.log(`  Branch: ${task.branch || "N/A"}`);
+    if (task.url)
+        console.log(`  URL: ${task.url}`);
+    displayTaskDescription(task);
+    displayTaskAttachments(task);
+    displayTaskComments(task);
+    displayTaskFooter();
+}

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

@@ -0,0 +1,10 @@
+export interface CommitInfo {
+    shortHash: string;
+    fullHash: string;
+    message: string;
+    diffStat: string;
+    commitUrl: string | null;
+}
+export declare function getLatestCommit(): CommitInfo | null;
+export declare function formatCommitLink(commit: CommitInfo): string;
+export declare function buildCompletionComment(commit: CommitInfo, aiMessage?: string): string;

package/dist/scripts/lib/git.js

@@ -0,0 +1,78 @@
+import { execSync } from "node:child_process";
+function getRemoteUrl() {
+    try {
+        return execSync("git remote get-url origin", {
+            encoding: "utf-8",
+        }).trim();
+    }
+    catch {
+        return null;
+    }
+}
+function buildCommitUrl(remoteUrl, fullHash) {
+    // Handle SSH or HTTPS URLs
+    // git@gitlab.com:org/repo.git -> https://gitlab.com/org/repo/-/commit/hash
+    // https://gitlab.com/org/repo.git -> https://gitlab.com/org/repo/-/commit/hash
+    if (remoteUrl.includes("gitlab")) {
+        const match = remoteUrl.match(/(?:git@|https:\/\/)([^:/]+)[:\\/](.+?)(?:\.git)?$/);
+        if (match) {
+            return `https://${match[1]}/${match[2]}/-/commit/${fullHash}`;
+        }
+    }
+    else if (remoteUrl.includes("github")) {
+        const match = remoteUrl.match(/(?:git@|https:\/\/)([^:/]+)[:\\/](.+?)(?:\.git)?$/);
+        if (match) {
+            return `https://${match[1]}/${match[2]}/commit/${fullHash}`;
+        }
+    }
+    return null;
+}
+export function getLatestCommit() {
+    try {
+        const shortHash = execSync("git rev-parse --short HEAD", {
+            encoding: "utf-8",
+        }).trim();
+        const fullHash = execSync("git rev-parse HEAD", {
+            encoding: "utf-8",
+        }).trim();
+        const message = execSync("git log -1 --format=%s", {
+            encoding: "utf-8",
+        }).trim();
+        const diffStat = execSync("git diff HEAD~1 --stat --stat-width=60", {
+            encoding: "utf-8",
+        }).trim();
+        let commitUrl = null;
+        const remoteUrl = getRemoteUrl();
+        if (remoteUrl) {
+            commitUrl = buildCommitUrl(remoteUrl, fullHash);
+        }
+        return { shortHash, fullHash, message, diffStat, commitUrl };
+    }
+    catch {
+        return null;
+    }
+}
+export function formatCommitLink(commit) {
+    return commit.commitUrl
+        ? `[${commit.shortHash}](${commit.commitUrl})`
+        : `\`${commit.shortHash}\``;
+}
+export function buildCompletionComment(commit, aiMessage) {
+    const commitLink = formatCommitLink(commit);
+    const commentParts = [
+        "## ✅ 開發完成",
+        "",
+        "### 🤖 AI 修復說明",
+        aiMessage || "_No description provided_",
+        "",
+        "### 📝 Commit Info",
+        `**Commit:** ${commitLink}`,
+        `**Message:** ${commit.message}`,
+        "",
+        "### 📊 Changes",
+        "```",
+        commit.diffStat,
+        "```",
+    ];
+    return commentParts.join("\n");
+}

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

@@ -0,0 +1,11 @@
+import { type Config, type StatusTransitions } from "../utils.js";
+export interface WorkflowStateInfo {
+    id: string;
+    name: string;
+    type: string;
+}
+export declare function getWorkflowStates(config: Config, teamKey: string): Promise<WorkflowStateInfo[]>;
+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;

package/dist/scripts/lib/linear.js

@@ -0,0 +1,61 @@
+import { getLinearClient, getTeamId, } from "../utils.js";
+export async function getWorkflowStates(config, teamKey) {
+    const client = getLinearClient();
+    const teamId = getTeamId(config, teamKey);
+    const statesData = await client.workflowStates({
+        filter: { team: { id: { eq: teamId } } },
+    });
+    return statesData.nodes.map((s) => ({
+        id: s.id,
+        name: s.name,
+        type: s.type,
+    }));
+}
+export function getStatusTransitions(config) {
+    return (config.status_transitions || {
+        todo: "Todo",
+        in_progress: "In Progress",
+        done: "Done",
+        testing: "Testing",
+    });
+}
+export async function updateIssueStatus(linearId, targetStatusName, config, teamKey) {
+    try {
+        const client = getLinearClient();
+        const states = await getWorkflowStates(config, teamKey);
+        const targetState = states.find((s) => s.name === targetStatusName);
+        if (targetState) {
+            await client.updateIssue(linearId, { stateId: targetState.id });
+            return true;
+        }
+        return false;
+    }
+    catch (e) {
+        console.error("Failed to update Linear:", e);
+        return false;
+    }
+}
+export async function addComment(issueId, body) {
+    try {
+        const client = getLinearClient();
+        await client.createComment({ issueId, body });
+        return true;
+    }
+    catch (e) {
+        console.error("Failed to add comment:", e);
+        return false;
+    }
+}
+export function mapLocalStatusToLinear(localStatus, config) {
+    const transitions = getStatusTransitions(config);
+    switch (localStatus) {
+        case "pending":
+            return transitions.todo;
+        case "in-progress":
+            return transitions.in_progress;
+        case "completed":
+            return transitions.done;
+        default:
+            return undefined;
+    }
+}

package/dist/scripts/status.d.ts

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

package/dist/scripts/status.js

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+import { displayTaskWithStatus, getStatusIcon } from "./lib/display.js";
+import { getStatusTransitions, mapLocalStatusToLinear, updateIssueStatus, } from "./lib/linear.js";
+import { loadConfig, loadCycleData, loadLocalConfig, saveCycleData, } from "./utils.js";
+const LOCAL_STATUS_ORDER = [
+    "pending",
+    "in-progress",
+    "completed",
+    "blocked-backend",
+];
+function parseArgs(args) {
+    let issueId;
+    let setStatus;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === "--set" || arg === "-s") {
+            setStatus = args[++i];
+        }
+        else if (!arg.startsWith("-")) {
+            issueId = arg;
+        }
+    }
+    return { issueId, setStatus };
+}
+async function status() {
+    const args = process.argv.slice(2);
+    if (args.includes("--help") || args.includes("-h")) {
+        console.log(`Usage: ttt status [issue-id] [--set <status>]
+
+Show or modify the status of an issue.
+
+Arguments:
+  issue-id              Issue ID (e.g., MP-624). If omitted, shows in-progress task.
+
+Options:
+  -s, --set <status>    Set local and Linear status. Values:
+                        +1       Move to next status (pending → in-progress → completed)
+                        -1       Move to previous status
+                        +2       Skip two statuses forward
+                        -2       Skip two statuses backward
+                        pending  Set to pending
+                        in-progress  Set to in-progress
+                        completed    Set to completed
+                        blocked      Set to blocked-backend
+                        todo     Set Linear to Todo status
+                        done     Set Linear to Done status
+
+Examples:
+  ttt status                    # Show current in-progress task
+  ttt status MP-624             # Show status of specific issue
+  ttt status MP-624 --set +1    # Move to next status
+  ttt status --set pending      # Reset current task to pending`);
+        process.exit(0);
+    }
+    const { issueId: argIssueId, setStatus } = parseArgs(args);
+    const config = await loadConfig();
+    const localConfig = await loadLocalConfig();
+    const data = await loadCycleData();
+    if (!data) {
+        console.error("No cycle data found. Run ttt sync first.");
+        process.exit(1);
+    }
+    // Find task
+    let task;
+    let issueId = argIssueId;
+    if (!issueId) {
+        const inProgressTasks = data.tasks.filter((t) => t.localStatus === "in-progress");
+        if (inProgressTasks.length === 0) {
+            console.log("No in-progress task found.");
+            console.log("\nAll tasks:");
+            for (const t of data.tasks) {
+                console.log(`  ${getStatusIcon(t.localStatus)} ${t.id}: ${t.title} [${t.localStatus}]`);
+            }
+            process.exit(0);
+        }
+        task = inProgressTasks[0];
+        issueId = task.id;
+    }
+    else {
+        task = data.tasks.find((t) => t.id === issueId || t.id === `MP-${issueId}`);
+        if (!task) {
+            console.error(`Issue ${issueId} not found in local data.`);
+            process.exit(1);
+        }
+    }
+    // If setting status
+    if (setStatus) {
+        const currentIndex = LOCAL_STATUS_ORDER.indexOf(task.localStatus);
+        let newLocalStatus;
+        let newLinearStatus;
+        // Parse status change
+        if (setStatus === "+1") {
+            const newIndex = Math.min(currentIndex + 1, LOCAL_STATUS_ORDER.length - 1);
+            newLocalStatus = LOCAL_STATUS_ORDER[newIndex];
+        }
+        else if (setStatus === "-1") {
+            const newIndex = Math.max(currentIndex - 1, 0);
+            newLocalStatus = LOCAL_STATUS_ORDER[newIndex];
+        }
+        else if (setStatus === "+2") {
+            const newIndex = Math.min(currentIndex + 2, LOCAL_STATUS_ORDER.length - 1);
+            newLocalStatus = LOCAL_STATUS_ORDER[newIndex];
+        }
+        else if (setStatus === "-2") {
+            const newIndex = Math.max(currentIndex - 2, 0);
+            newLocalStatus = LOCAL_STATUS_ORDER[newIndex];
+        }
+        else if ([
+            "pending",
+            "in-progress",
+            "completed",
+            "blocked-backend",
+            "blocked",
+        ].includes(setStatus)) {
+            newLocalStatus =
+                setStatus === "blocked"
+                    ? "blocked-backend"
+                    : setStatus;
+        }
+        else if (["todo", "in_progress", "done", "testing"].includes(setStatus)) {
+            const transitions = getStatusTransitions(config);
+            newLinearStatus =
+                transitions[setStatus] ?? undefined;
+            if (setStatus === "todo") {
+                newLocalStatus = "pending";
+            }
+            else if (setStatus === "in_progress") {
+                newLocalStatus = "in-progress";
+            }
+            else if (setStatus === "done") {
+                newLocalStatus = "completed";
+            }
+        }
+        else {
+            console.error(`Unknown status: ${setStatus}`);
+            process.exit(1);
+        }
+        // Update local status
+        if (newLocalStatus && newLocalStatus !== task.localStatus) {
+            const oldStatus = task.localStatus;
+            task.localStatus = newLocalStatus;
+            await saveCycleData(data);
+            console.log(`Local: ${task.id} ${oldStatus} → ${newLocalStatus}`);
+        }
+        // Update Linear status
+        if (newLinearStatus || newLocalStatus) {
+            let targetStateName = newLinearStatus;
+            if (!targetStateName && newLocalStatus) {
+                targetStateName = mapLocalStatusToLinear(newLocalStatus, config);
+            }
+            if (targetStateName) {
+                const success = await updateIssueStatus(task.linearId, targetStateName, config, localConfig.team);
+                if (success) {
+                    console.log(`Linear: ${task.id} → ${targetStateName}`);
+                }
+            }
+        }
+    }
+    // Display task info using shared function
+    displayTaskWithStatus(task);
+}
+status().catch(console.error);