team-toon-tack 3.10.1 → 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.1"
+			"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.1",
+	"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.1",
+	"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/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.1",
+	"version": "3.10.2",
 	"description": "Linear & Trello task sync & management CLI with TOON format",
 	"type": "module",
 	"bin": {