team-toon-tack 1.7.0 → 2.0.0

package/dist/scripts/status.js

@@ -6,7 +6,7 @@ const LOCAL_STATUS_ORDER = [
     "pending",
     "in-progress",
     "completed",
-    "blocked-backend",
+    "blocked",
 ];
 function parseArgs(args) {
     let issueId;
@@ -41,7 +41,7 @@ Options:
                         pending  Set to pending
                         in-progress  Set to in-progress
                         completed    Set to completed
-                        blocked      Set to blocked-backend
+                        blocked      Set to blocked (syncs to Linear if configured)
                         todo     Set Linear to Todo status
                         done     Set Linear to Done status
 
@@ -105,17 +105,8 @@ Examples:
             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 (["pending", "in-progress", "completed", "blocked"].includes(setStatus)) {
+            newLocalStatus = setStatus;
         }
         else if (["todo", "in_progress", "done", "testing"].includes(setStatus)) {
             const transitions = getStatusTransitions(config);
@@ -143,8 +134,9 @@ Examples:
             task.localStatus = newLocalStatus;
             needsSave = true;
         }
-        // Update Linear status
-        if (newLinearStatus || newLocalStatus) {
+        // Update Linear status (only if status_source is 'remote' or not set)
+        const statusSource = localConfig.status_source || "remote";
+        if (statusSource === "remote" && (newLinearStatus || newLocalStatus)) {
             let targetStateName = newLinearStatus;
             if (!targetStateName && newLocalStatus) {
                 targetStateName = mapLocalStatusToLinear(newLocalStatus, config);
@@ -158,12 +150,20 @@ Examples:
                 }
             }
         }
+        else if (statusSource === "local" &&
+            (newLinearStatus || newLocalStatus)) {
+            // Local mode: just note that Linear wasn't updated
+            needsSave = true;
+        }
         // Save if anything changed
         if (needsSave) {
             await saveCycleData(data);
             if (newLocalStatus && newLocalStatus !== oldLocalStatus) {
                 console.log(`Local: ${task.id} ${oldLocalStatus} → ${newLocalStatus}`);
             }
+            if (statusSource === "local") {
+                console.log(`(Linear status not updated - use 'sync --update' to push)`);
+            }
         }
         else if (newLocalStatus) {
             console.log(`Local: ${task.id} already ${newLocalStatus}`);

package/dist/scripts/sync.js

@@ -1,15 +1,20 @@
-import { getLinearClient, getPrioritySortIndex, getTeamId, loadConfig, loadCycleData, loadLocalConfig, saveConfig, saveCycleData, } from "./utils.js";
+import { getLinearClient, getPaths, getPrioritySortIndex, getTeamId, loadConfig, loadCycleData, loadLocalConfig, saveConfig, saveCycleData, } from "./utils.js";
+import { clearIssueImages, downloadLinearImage, ensureOutputDir, extractLinearImageUrls, isLinearImageUrl, } from "./lib/images.js";
 async function sync() {
     const args = process.argv.slice(2);
     // Handle help flag
     if (args.includes("--help") || args.includes("-h")) {
-        console.log(`Usage: ttt sync [issue-id]
+        console.log(`Usage: ttt sync [issue-id] [--update]
 
 Sync issues from Linear to local cycle.ttt file.
 
 Arguments:
   issue-id    Optional. Sync only this specific issue (e.g., MP-624)
 
+Options:
+  --update    Push local status changes to Linear (for local mode users)
+              This updates Linear with your local in-progress/completed statuses
+
 What it does:
   - Fetches active cycle from Linear
   - Downloads all issues matching configured filters
@@ -19,15 +24,21 @@ What it does:
 Examples:
   ttt sync              # Sync all matching issues
   ttt sync MP-624       # Sync only this specific issue
+  ttt sync --update     # Push local changes to Linear, then sync
   ttt sync -d .ttt     # Sync using .ttt directory`);
         process.exit(0);
     }
+    // Check for --update flag
+    const shouldUpdate = args.includes("--update");
     // Parse issue ID argument (if provided)
     const singleIssueId = args.find((arg) => !arg.startsWith("-") && arg.match(/^[A-Z]+-\d+$/i));
     const config = await loadConfig();
     const localConfig = await loadLocalConfig();
     const client = getLinearClient();
     const teamId = getTeamId(config, localConfig.team);
+    const { outputPath } = getPaths();
+    // Ensure output directory exists
+    await ensureOutputDir(outputPath);
     // Build excluded labels set
     const excludedLabels = new Set(localConfig.exclude_labels ?? []);
     // Phase 1: Fetch active cycle directly from team
@@ -91,6 +102,50 @@ Examples:
     const testingStateId = statusTransitions.testing
         ? stateMap.get(statusTransitions.testing)
         : undefined;
+    const inProgressStateId = stateMap.get(statusTransitions.in_progress);
+    // Phase 2.5: Push local status changes to Linear (if --update flag)
+    if (shouldUpdate && existingData) {
+        console.log("Pushing local status changes to Linear...");
+        let pushCount = 0;
+        for (const task of existingData.tasks) {
+            // Map local status to Linear status
+            let targetStateId;
+            if (task.localStatus === "in-progress" && inProgressStateId) {
+                // Check if Linear status is not already in-progress
+                if (task.status !== statusTransitions.in_progress) {
+                    targetStateId = inProgressStateId;
+                }
+            }
+            else if (task.localStatus === "completed" && testingStateId) {
+                // Check if Linear status is not already testing/done
+                const terminalStatuses = [statusTransitions.done];
+                if (statusTransitions.testing)
+                    terminalStatuses.push(statusTransitions.testing);
+                if (!terminalStatuses.includes(task.status)) {
+                    targetStateId = testingStateId;
+                }
+            }
+            if (targetStateId) {
+                try {
+                    await client.updateIssue(task.linearId, { stateId: targetStateId });
+                    const targetName = targetStateId === inProgressStateId
+                        ? statusTransitions.in_progress
+                        : statusTransitions.testing;
+                    console.log(`  ${task.id} → ${targetName}`);
+                    pushCount++;
+                }
+                catch (e) {
+                    console.error(`  Failed to update ${task.id}:`, e);
+                }
+            }
+        }
+        if (pushCount > 0) {
+            console.log(`Pushed ${pushCount} status updates to Linear.`);
+        }
+        else {
+            console.log("No local changes to push.");
+        }
+    }
     // Phase 3: Build existing tasks map for preserving local status
     const existingTasksMap = new Map(existingData?.tasks.map((t) => [t.id, t]));
     // Phase 4: Fetch current issues with full content
@@ -145,13 +200,49 @@ Examples:
         const parent = await issue.parent;
         const attachmentsData = await issue.attachments();
         const commentsData = await issue.comments();
-        // Build attachments list
-        const attachments = attachmentsData.nodes.map((a) => ({
-            id: a.id,
-            title: a.title,
-            url: a.url,
-            sourceType: a.sourceType ?? undefined,
-        }));
+        // Clear old images for this issue before downloading new ones
+        await clearIssueImages(outputPath, issue.identifier);
+        // Build attachments list and download Linear images
+        const attachments = [];
+        for (const a of attachmentsData.nodes) {
+            const attachment = {
+                id: a.id,
+                title: a.title,
+                url: a.url,
+                sourceType: a.sourceType ?? undefined,
+            };
+            // Download Linear domain images
+            if (isLinearImageUrl(a.url)) {
+                const localPath = await downloadLinearImage(a.url, issue.identifier, a.id, outputPath);
+                if (localPath) {
+                    attachment.localPath = localPath;
+                }
+            }
+            attachments.push(attachment);
+        }
+        // Extract and download images from description
+        if (issue.description) {
+            const descriptionImageUrls = extractLinearImageUrls(issue.description);
+            for (const url of descriptionImageUrls) {
+                // Generate a short ID from URL (last segment of path)
+                const urlPath = new URL(url).pathname;
+                const segments = urlPath.split("/").filter(Boolean);
+                const imageId = segments[segments.length - 1] || `desc_${Date.now()}`;
+                // Skip if already in attachments
+                if (attachments.some((a) => a.url === url))
+                    continue;
+                const localPath = await downloadLinearImage(url, issue.identifier, imageId, outputPath);
+                if (localPath) {
+                    attachments.push({
+                        id: imageId,
+                        title: `Description Image`,
+                        url: url,
+                        sourceType: "description",
+                        localPath: localPath,
+                    });
+                }
+            }
+        }
         // Build comments list
         const comments = await Promise.all(commentsData.nodes.map(async (c) => {
             const user = await c.user;

package/dist/scripts/utils.d.ts

@@ -4,6 +4,7 @@ export declare function getPaths(): {
     configPath: string;
     cyclePath: string;
     localPath: string;
+    outputPath: string;
 };
 export interface TeamConfig {
     id: string;
@@ -32,6 +33,7 @@ export interface StatusTransitions {
     in_progress: string;
     done: string;
     testing?: string;
+    blocked?: string;
 }
 export interface Config {
     teams: Record<string, TeamConfig>;
@@ -58,6 +60,7 @@ export interface Attachment {
     title: string;
     url: string;
     sourceType?: string;
+    localPath?: string;
 }
 export interface Comment {
     id: string;
@@ -70,7 +73,7 @@ export interface Task {
     linearId: string;
     title: string;
     status: string;
-    localStatus: "pending" | "in-progress" | "completed" | "blocked-backend";
+    localStatus: "pending" | "in-progress" | "completed" | "blocked";
     assignee?: string;
     priority: number;
     labels: string[];
@@ -92,8 +95,10 @@ export interface LocalConfig {
     current_user: string;
     team: string;
     teams?: string[];
+    qa_pm_team?: string;
     exclude_labels?: string[];
     label?: string;
+    status_source?: "remote" | "local";
 }
 export declare function fileExists(filePath: string): Promise<boolean>;
 export declare function loadConfig(): Promise<Config>;

package/dist/scripts/utils.js

@@ -19,12 +19,14 @@ const BASE_DIR = getBaseDir();
 const CONFIG_PATH = path.join(BASE_DIR, "config.toon");
 const CYCLE_PATH = path.join(BASE_DIR, "cycle.toon");
 const LOCAL_PATH = path.join(BASE_DIR, "local.toon");
+const OUTPUT_PATH = path.join(BASE_DIR, "output");
 export function getPaths() {
     return {
         baseDir: BASE_DIR,
         configPath: CONFIG_PATH,
         cyclePath: CYCLE_PATH,
         localPath: LOCAL_PATH,
+        outputPath: OUTPUT_PATH,
     };
 }
 // Linear priority value to name mapping (fixed by Linear API)

package/dist/scripts/work-on.js

@@ -83,8 +83,11 @@ Examples:
     // Mark as In Progress
     if (task.localStatus === "pending") {
         task.localStatus = "in-progress";
-        // Update Linear
-        if (task.linearId && process.env.LINEAR_API_KEY) {
+        // Update Linear (only if status_source is 'remote' or not set)
+        const statusSource = localConfig.status_source || "remote";
+        if (statusSource === "remote" &&
+            task.linearId &&
+            process.env.LINEAR_API_KEY) {
             const transitions = getStatusTransitions(config);
             const success = await updateIssueStatus(task.linearId, transitions.in_progress, config, localConfig.team);
             if (success) {
@@ -94,6 +97,9 @@ Examples:
         }
         await saveCycleData(data);
         console.log(`Local: ${task.id} → in-progress`);
+        if (statusSource === "local") {
+            console.log(`(Linear status not updated - use 'sync --update' to push)`);
+        }
     }
     // Display task info
     displayTaskFull(task, "👷");

package/package.json

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

package/templates/claude-code-commands/work-on.md

@@ -30,7 +30,17 @@ Script displays title, description, priority, labels, and attachments.
 3. Implement the fix/feature
 4. Commit with conventional format
 
-### 4. Verify
+### 4. Handle Blockers (if any)
+
+If you encounter a blocker (waiting for backend, design, external dependency):
+
+```bash
+ttt status --set blocked
+```
+
+Add a comment explaining the blocker, then move to another task.
+
+### 5. Verify
 
 Run project-required verification before completing:
 
@@ -39,7 +49,7 @@ Run project-required verification before completing:
 # (e.g., type-check, lint, test, build)
 ```
 
-### 5. Complete
+### 6. Complete
 
 Use `/done-job` to mark task as completed