npm - @wangjs-jacky/ticktick-cli - Versions diffs - 0.1.0 - Mend

@wangjs-jacky/ticktick-cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (40) hide show

package/.github/workflows/npm-publish.yml +26 -0
package/CLAUDE.md +34 -0
package/README.md +62 -0
package/README_CN.md +62 -0
package/bin/cli.ts +2 -0
package/dist/index.d.ts +2 -0
package/dist/index.js +1490 -0
package/dist/index.js.map +1 -0
package/docs/oauth-credential-pre-validation.md +253 -0
package/docs/reference/cli-usage-guide.md +587 -0
package/docs/reference/dida365-open-api-zh.md +999 -0
package/docs/reference/dida365-open-api.md +999 -0
package/docs/reference/project-guide.md +63 -0
package/docs/superpowers/plans/2026-04-03-tt-cli-auth.md +1110 -0
package/docs/superpowers/specs/2026-04-03-tt-cli-design.md +142 -0
package/package.json +45 -0
package/skills/tt-cli-guide/SKILL.md +152 -0
package/skills/tt-cli-guide/references/intent-mapping.md +169 -0
package/src/api/client.ts +61 -0
package/src/api/oauth.ts +146 -0
package/src/api/resources.ts +291 -0
package/src/commands/auth.ts +218 -0
package/src/commands/project.ts +303 -0
package/src/commands/task.ts +806 -0
package/src/commands/user.ts +43 -0
package/src/index.ts +46 -0
package/src/types.ts +211 -0
package/src/utils/config.ts +88 -0
package/src/utils/endpoints.ts +22 -0
package/src/utils/format.ts +71 -0
package/src/utils/server.ts +81 -0
package/tests/config.test.ts +87 -0
package/tests/format.test.ts +56 -0
package/tests/oauth.test.ts +42 -0
package/tests/parity-fields.test.ts +89 -0
package/tests/parity-map.ts +184 -0
package/tests/parity.test.ts +101 -0
package/tsconfig.json +22 -0
package/tsup.config.ts +12 -0
package/vitest.config.ts +7 -0

package/dist/index.js ADDED Viewed

@@ -0,0 +1,1490 @@
+#!/usr/bin/env node
+// src/index.ts
+import { cac } from "cac";
+// src/commands/auth.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+// src/utils/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+function getConfigDir() {
+  return process.env.TT_CLI_CONFIG_DIR ?? path.join(os.homedir(), ".tt-cli");
+}
+var CONFIG_FILE = "config.json";
+function getConfigPath() {
+  return path.join(getConfigDir(), CONFIG_FILE);
+}
+function ensureConfigDir() {
+  const dir = getConfigDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function readConfig() {
+  const configPath = getConfigPath();
+  if (!fs.existsSync(configPath)) return {};
+  return JSON.parse(fs.readFileSync(configPath, "utf-8"));
+}
+function writeConfig(config) {
+  ensureConfigDir();
+  fs.writeFileSync(getConfigPath(), JSON.stringify(config, null, 2));
+}
+function getRegion() {
+  return readConfig().region ?? "cn";
+}
+function setRegion(region) {
+  const config = readConfig();
+  config.region = region;
+  writeConfig(config);
+}
+function getOAuth() {
+  return readConfig().oauth;
+}
+function setOAuth(oauth) {
+  const config = readConfig();
+  config.oauth = { ...oauth, region: getRegion() };
+  writeConfig(config);
+}
+function getToken() {
+  return readConfig().token;
+}
+function setToken(token) {
+  const config = readConfig();
+  config.token = token;
+  writeConfig(config);
+}
+function clearToken() {
+  const config = readConfig();
+  delete config.token;
+  writeConfig(config);
+}
+function isTokenValid() {
+  const token = getToken();
+  if (!token) return false;
+  return Date.now() < token.expiresAt - 5 * 60 * 1e3;
+}
+// src/utils/endpoints.ts
+var ENDPOINTS = {
+  cn: {
+    authUrl: "https://dida365.com/oauth/authorize",
+    tokenUrl: "https://dida365.com/oauth/token",
+    apiBase: "https://api.dida365.com/open/v1/",
+    developerUrl: "https://developer.dida365.com/app"
+  },
+  global: {
+    authUrl: "https://ticktick.com/oauth/authorize",
+    tokenUrl: "https://ticktick.com/oauth/token",
+    apiBase: "https://api.ticktick.com/open/v1/",
+    developerUrl: "https://developer.ticktick.com/app"
+  }
+};
+function getEndpoints(region) {
+  return ENDPOINTS[region];
+}
+// src/api/oauth.ts
+import crypto from "crypto";
+import open from "open";
+// src/utils/server.ts
+import http from "http";
+function createCallbackServer(expectedState, port) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const server = http.createServer((req, res) => {
+      const url = new URL(req.url, `http://localhost:${port}`);
+      if (url.pathname !== "/callback") {
+        res.writeHead(404);
+        res.end("Not found");
+        return;
+      }
+      const code = url.searchParams.get("code");
+      const state = url.searchParams.get("state");
+      if (state !== expectedState) {
+        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+        res.end("<h1>\u6388\u6743\u5931\u8D25\uFF1Astate \u4E0D\u5339\u914D</h1>");
+        if (!settled) {
+          settled = true;
+          reject(new Error("CSRF state \u4E0D\u5339\u914D"));
+        }
+        server.close();
+        return;
+      }
+      if (!code) {
+        res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+        res.end("<h1>\u6388\u6743\u5931\u8D25\uFF1A\u7F3A\u5C11 code \u53C2\u6570</h1>");
+        if (!settled) {
+          settled = true;
+          reject(new Error("\u7F3A\u5C11\u6388\u6743\u7801"));
+        }
+        server.close();
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+      res.end('<html><body style="display:flex;justify-content:center;align-items:center;height:100vh;font-family:sans-serif"><h1>\u2705 \u6388\u6743\u6210\u529F\uFF01\u8BF7\u8FD4\u56DE\u7EC8\u7AEF\u3002</h1></body></html>');
+      if (!settled) {
+        settled = true;
+        resolve({
+          code,
+          close: () => server.close()
+        });
+      }
+    });
+    server.on("error", (err) => {
+      if (!settled) {
+        settled = true;
+        if (err.code === "EADDRINUSE") {
+          reject(new Error(`\u7AEF\u53E3 ${port} \u5DF2\u88AB\u5360\u7528\uFF0C\u8BF7\u5173\u95ED\u5360\u7528\u8BE5\u7AEF\u53E3\u7684\u7A0B\u5E8F\u6216\u7B49\u5F85\u91CD\u8BD5`));
+        } else {
+          reject(err);
+        }
+      }
+    });
+    server.listen(port);
+    setTimeout(() => {
+      if (!settled) {
+        settled = true;
+        server.close();
+        reject(new Error("TIMEOUT"));
+      }
+    }, 12e4);
+  });
+}
+// src/api/oauth.ts
+var SCOPES = "tasks:read tasks:write";
+var DEFAULT_PORT = 3e3;
+function generateState() {
+  return crypto.randomBytes(16).toString("hex");
+}
+function buildAuthUrl(config, state, port, region = "cn") {
+  const endpoints = getEndpoints(region);
+  const redirectUri = `http://localhost:${port}/callback`;
+  const params = new URLSearchParams({
+    client_id: config.clientId,
+    response_type: "code",
+    redirect_uri: redirectUri,
+    scope: SCOPES,
+    state
+  });
+  return `${endpoints.authUrl}?${params.toString()}`;
+}
+async function exchangeCode(config, code, port) {
+  const region = getRegion();
+  const endpoints = getEndpoints(region);
+  const redirectUri = `http://localhost:${port}/callback`;
+  const credentials = Buffer.from(`${config.clientId}:${config.clientSecret}`).toString("base64");
+  const response = await fetch(endpoints.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      "Authorization": `Basic ${credentials}`
+    },
+    body: new URLSearchParams({
+      code,
+      grant_type: "authorization_code",
+      redirect_uri: redirectUri,
+      scope: SCOPES
+    }).toString()
+  });
+  if (!response.ok) {
+    const text4 = await response.text();
+    throw new Error(`Token \u4EA4\u6362\u5931\u8D25: ${response.status} ${text4}`);
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+}
+async function refreshAccessToken() {
+  const oauth = getOAuth();
+  const token = getToken();
+  const region = getRegion();
+  const endpoints = getEndpoints(region);
+  if (!oauth || !token) {
+    throw new Error("\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8FD0\u884C tt login");
+  }
+  const credentials = Buffer.from(`${oauth.clientId}:${oauth.clientSecret}`).toString("base64");
+  const response = await fetch(endpoints.tokenUrl, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded",
+      "Authorization": `Basic ${credentials}`
+    },
+    body: new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: token.refreshToken
+    }).toString()
+  });
+  if (!response.ok) {
+    const text4 = await response.text();
+    throw new Error(`Token \u5237\u65B0\u5931\u8D25: ${response.status} ${text4}`);
+  }
+  const data = await response.json();
+  const newToken = {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1e3
+  };
+  setToken(newToken);
+  return newToken;
+}
+async function loginWithBrowser(config, port = DEFAULT_PORT) {
+  const region = getRegion();
+  const state = generateState();
+  const authUrl = buildAuthUrl(config, state, port, region);
+  const codePromise = createCallbackServer(state, port);
+  await open(authUrl);
+  let callbackResult;
+  try {
+    callbackResult = await codePromise;
+  } catch (err) {
+    if (err.message === "TIMEOUT") {
+      throw new Error(
+        `\u767B\u5F55\u8D85\u65F6\uFF082 \u5206\u949F\u672A\u6536\u5230\u6388\u6743\u56DE\u8C03\uFF09\u3002
+\u53EF\u80FD\u539F\u56E0\uFF1A
+  1. \u6D4F\u89C8\u5668\u6388\u6743\u9875\u9762\u663E\u793A\u4E86\u9519\u8BEF\uFF08\u5982 invalid_client\uFF09
+  2. \u51ED\u8BC1\u4E0E\u5F53\u524D\u533A\u57DF\u4E0D\u5339\u914D
+  \u5F53\u524D\u533A\u57DF\uFF1A${region === "cn" ? "\u56FD\u5185\u7248\uFF08dida365.com\uFF09" : "\u56FD\u9645\u7248\uFF08ticktick.com\uFF09"}
+\u5EFA\u8BAE\uFF1A\u68C0\u67E5\u6D4F\u89C8\u5668\u9875\u9762\u9519\u8BEF\uFF0C\u6216\u5C1D\u8BD5\u5207\u6362\u533A\u57DF/\u91CD\u65B0\u914D\u7F6E\u51ED\u8BC1`
+      );
+    }
+    throw err;
+  }
+  const token = await exchangeCode(config, callbackResult.code, port);
+  setToken(token);
+  callbackResult.close();
+  return token;
+}
+// src/api/client.ts
+async function getValidToken() {
+  const oauth = getOAuth();
+  const token = getToken();
+  if (!oauth || !token) {
+    throw new Error("\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8FD0\u884C tt login");
+  }
+  if (isTokenValid()) {
+    return token.accessToken;
+  }
+  const newToken = await refreshAccessToken();
+  return newToken.accessToken;
+}
+async function apiRequest(path2, options) {
+  const token = await getValidToken();
+  const endpoints = getEndpoints(getRegion());
+  const response = await fetch(`${endpoints.apiBase}${path2}`, {
+    ...options,
+    headers: {
+      "Authorization": `Bearer ${token}`,
+      "Content-Type": "application/json",
+      ...options?.headers
+    }
+  });
+  if (!response.ok) {
+    const text5 = await response.text();
+    throw new Error(`API \u8BF7\u6C42\u5931\u8D25: ${response.status} ${text5}`);
+  }
+  if (response.status === 204) {
+    return void 0;
+  }
+  const text4 = await response.text();
+  if (!text4 || text4.trim() === "") {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text4);
+  } catch {
+    throw new Error(
+      `API \u54CD\u5E94 JSON \u89E3\u6790\u5931\u8D25 (HTTP ${response.status})
+\u8DEF\u5F84: ${path2}
+\u539F\u59CB\u54CD\u5E94: ${text4.substring(0, 500)}
+\u5EFA\u8BAE: \u8BF7\u68C0\u67E5 API \u7AEF\u70B9\u662F\u5426\u6B63\u786E\uFF0C\u6216\u5C1D\u8BD5 tt task-search \u9A8C\u8BC1\u6570\u636E`
+    );
+  }
+}
+// src/commands/auth.ts
+var REGION_LABELS = {
+  cn: "\u56FD\u5185\u7248\uFF08\u6EF4\u7B54\u6E05\u5355\uFF09",
+  global: "\u56FD\u9645\u7248\uFF08TickTick\uFF09"
+};
+async function promptOAuthCredentials(developerUrl) {
+  p.log.info(`\u8BF7\u8BBF\u95EE ${developerUrl} \u83B7\u53D6\u51ED\u8BC1`);
+  p.log.info("Redirect URI \u8BBE\u7F6E\u4E3A: http://localhost:3000/callback\n");
+  const clientId = await p.text({
+    message: "\u8BF7\u8F93\u5165 Client ID",
+    validate: (v) => !v ? "Client ID \u4E0D\u80FD\u4E3A\u7A7A" : void 0
+  });
+  if (p.isCancel(clientId)) return void 0;
+  const clientSecret = await p.text({
+    message: "\u8BF7\u8F93\u5165 Client Secret",
+    validate: (v) => !v ? "Client Secret \u4E0D\u80FD\u4E3A\u7A7A" : void 0
+  });
+  if (p.isCancel(clientSecret)) return void 0;
+  const oauth = { clientId, clientSecret };
+  setOAuth(oauth);
+  p.log.success("\u51ED\u8BC1\u5DF2\u4FDD\u5B58");
+  return oauth;
+}
+async function loginCommand() {
+  const region = getRegion();
+  const endpoints = getEndpoints(region);
+  p.intro(pc.bgCyan(pc.black(` \u6EF4\u7B54\u6E05\u5355 CLI \u767B\u5F55 [${REGION_LABELS[region]}] `)));
+  const token = getToken();
+  if (token && isTokenValid()) {
+    p.outro(pc.green("\u5DF2\u767B\u5F55\uFF0C\u65E0\u9700\u91CD\u590D\u767B\u5F55\u3002\u4F7F\u7528 tt logout \u5148\u767B\u51FA\u3002"));
+    return;
+  }
+  let oauth = getOAuth();
+  if (oauth?.region && oauth.region !== region) {
+    p.log.warn(`\u5F53\u524D\u533A\u57DF\u4E3A ${REGION_LABELS[region]}\uFF0C\u4F46\u4FDD\u5B58\u7684\u51ED\u8BC1\u5C5E\u4E8E ${REGION_LABELS[oauth.region]}`);
+    p.log.warn("\u51ED\u8BC1\u4E0E\u533A\u57DF\u4E0D\u5339\u914D\u4F1A\u5BFC\u81F4\u767B\u5F55\u5931\u8D25\n");
+    const reconfigure = await p.confirm({
+      message: `\u662F\u5426\u4E3A ${REGION_LABELS[region]} \u91CD\u65B0\u914D\u7F6E\u51ED\u8BC1\uFF1F`
+    });
+    if (p.isCancel(reconfigure) || !reconfigure) {
+      p.outro("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    oauth = void 0;
+  }
+  if (oauth && !oauth.region) {
+    p.log.warn("\u4FDD\u5B58\u7684\u51ED\u8BC1\u672A\u6807\u8BB0\u533A\u57DF\uFF0C\u53EF\u80FD\u4E0E\u5F53\u524D\u533A\u57DF\u4E0D\u5339\u914D");
+    const confirmRegion = await p.confirm({
+      message: `\u8FD9\u4E9B\u51ED\u8BC1\u662F\u5426\u7528\u4E8E ${REGION_LABELS[region]}\uFF1F`
+    });
+    if (p.isCancel(confirmRegion)) {
+      p.outro("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    if (confirmRegion) {
+      setOAuth(oauth);
+      p.log.success(`\u5DF2\u5C06\u51ED\u8BC1\u6807\u8BB0\u4E3A ${REGION_LABELS[region]}`);
+    } else {
+      oauth = void 0;
+    }
+  }
+  if (!oauth) {
+    oauth = await promptOAuthCredentials(endpoints.developerUrl);
+    if (!oauth) {
+      p.outro("\u5DF2\u53D6\u6D88");
+      return;
+    }
+  }
+  const s2 = p.spinner();
+  s2.start("\u6B63\u5728\u6253\u5F00\u6D4F\u89C8\u5668\u8FDB\u884C\u6388\u6743...");
+  try {
+    await loginWithBrowser(oauth);
+    s2.stop("\u6388\u6743\u5B8C\u6210");
+    p.outro(pc.green("\u2714 \u767B\u5F55\u6210\u529F\uFF01"));
+  } catch (err) {
+    s2.stop("\u767B\u5F55\u5931\u8D25");
+    const msg = err.message;
+    if (msg.includes("invalid_client") || msg.includes("TIMEOUT")) {
+      p.log.error(pc.red("\u767B\u5F55\u5931\u8D25\uFF1A\u51ED\u8BC1\u65E0\u6548\u6216\u4E0E\u533A\u57DF\u4E0D\u5339\u914D"));
+      p.log.info(`\u5F53\u524D\u533A\u57DF\uFF1A${REGION_LABELS[region]}`);
+      p.log.info(`\u51ED\u8BC1\u6765\u6E90\uFF1A${oauth.region ? REGION_LABELS[oauth.region] : "\u672A\u77E5"}
+`);
+      const action = await p.select({
+        message: "\u8BF7\u9009\u62E9\u4E0B\u4E00\u6B65\u64CD\u4F5C",
+        options: [
+          { value: "switch", label: `\u5207\u6362\u5230${region === "cn" ? "\u56FD\u9645\u7248" : "\u56FD\u5185\u7248"}` },
+          { value: "reconfig", label: "\u91CD\u65B0\u8F93\u5165\u5F53\u524D\u533A\u57DF\u7684\u51ED\u8BC1" },
+          { value: "exit", label: "\u9000\u51FA" }
+        ]
+      });
+      if (p.isCancel(action) || action === "exit") {
+        p.outro("\u5DF2\u9000\u51FA");
+        return;
+      }
+      if (action === "switch") {
+        const newRegion = region === "cn" ? "global" : "cn";
+        setRegion(newRegion);
+        p.log.success(`\u5DF2\u5207\u6362\u5230 ${REGION_LABELS[newRegion]}\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C tt login`);
+        p.outro("\u533A\u57DF\u5DF2\u5207\u6362");
+        return;
+      }
+      if (action === "reconfig") {
+        await promptOAuthCredentials(endpoints.developerUrl);
+        p.outro("\u51ED\u8BC1\u5DF2\u66F4\u65B0\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C tt login");
+        return;
+      }
+    }
+    p.outro(pc.red(`\u2716 ${msg}`));
+    process.exit(1);
+  }
+}
+async function logoutCommand() {
+  p.intro(pc.bgCyan(pc.black(" \u6EF4\u7B54\u6E05\u5355 CLI \u767B\u51FA ")));
+  clearToken();
+  p.outro(pc.green("\u2714 \u5DF2\u767B\u51FA"));
+}
+async function whoamiCommand() {
+  const region = getRegion();
+  p.intro(pc.bgCyan(pc.black(" \u6EF4\u7B54\u6E05\u5355 CLI \u72B6\u6001 ")));
+  const token = getToken();
+  if (!token) {
+    p.outro(pc.yellow("\u672A\u767B\u5F55\uFF0C\u8BF7\u5148\u8FD0\u884C tt login"));
+    return;
+  }
+  const s2 = p.spinner();
+  s2.start("\u6B63\u5728\u9A8C\u8BC1\u767B\u5F55\u72B6\u6001...");
+  try {
+    await apiRequest("project");
+    s2.stop("\u9A8C\u8BC1\u5B8C\u6210");
+    const expiresIn = token.expiresAt - Date.now();
+    if (expiresIn <= 0) {
+      p.outro(pc.yellow("Token \u5DF2\u5931\u6548\uFF0C\u8BF7\u8FD0\u884C tt login \u91CD\u65B0\u767B\u5F55"));
+      return;
+    }
+    const hours = Math.floor(expiresIn / 36e5);
+    const minutes = Math.floor(expiresIn % 36e5 / 6e4);
+    p.log.success(pc.green(`\u5DF2\u767B\u5F55 [${REGION_LABELS[region]}]`));
+    p.log.info(`Token \u6709\u6548\u671F: \u5269\u4F59 ${hours} \u5C0F\u65F6 ${minutes} \u5206\u949F`);
+    p.outro("\u4E00\u5207\u6B63\u5E38");
+  } catch {
+    s2.stop("\u9A8C\u8BC1\u5931\u8D25");
+    p.outro(pc.red("Token \u5DF2\u5931\u6548\uFF0C\u8BF7\u8FD0\u884C tt login \u91CD\u65B0\u767B\u5F55"));
+  }
+}
+async function configCommand(args) {
+  if (args?.region) {
+    const oldRegion = getRegion();
+    setRegion(args.region);
+    clearToken();
+    p.intro(pc.bgCyan(pc.black(" \u6EF4\u7B54\u6E05\u5355 CLI \u914D\u7F6E ")));
+    p.log.success(`\u5DF2\u5207\u6362\u5230 ${REGION_LABELS[args.region]}`);
+    if (oldRegion !== args.region) {
+      p.log.warn("\u533A\u57DF\u5DF2\u53D8\u66F4\uFF0C\u8BF7\u91CD\u65B0\u8FD0\u884C tt login");
+    }
+    p.outro("\u914D\u7F6E\u5DF2\u66F4\u65B0");
+    return;
+  }
+  const region = getRegion();
+  p.intro(pc.bgCyan(pc.black(" \u6EF4\u7B54\u6E05\u5355 CLI \u914D\u7F6E ")));
+  p.log.info(`\u533A\u57DF: ${REGION_LABELS[region]}`);
+  const oauth = getOAuth();
+  if (oauth) {
+    p.log.info(`Client ID: ${oauth.clientId}`);
+    p.log.info(`Client Secret: ${oauth.clientSecret.substring(0, 8)}${"*".repeat(Math.max(0, oauth.clientSecret.length - 8))}`);
+  } else {
+    p.log.warn("\u5C1A\u672A\u914D\u7F6E OAuth \u51ED\u8BC1");
+  }
+  const token = getToken();
+  if (token) {
+    p.log.info(`Token: ${token.accessToken.substring(0, 8)}...`);
+    p.log.info(`\u8FC7\u671F\u65F6\u95F4: ${new Date(token.expiresAt).toLocaleString("zh-CN")}`);
+  } else {
+    p.log.info("Token: \u672A\u767B\u5F55");
+  }
+  p.log.info("\n\u4F7F\u7528 tt config --region cn/global \u5207\u6362\u533A\u57DF");
+  p.outro("\u914D\u7F6E\u4FE1\u606F\u5982\u4E0A");
+}
+// src/commands/project.ts
+import * as p2 from "@clack/prompts";
+import pc2 from "picocolors";
+// src/utils/format.ts
+function normalizeTickTickDate(dateStr) {
+  let result = dateStr;
+  if (!/T\d{2}:\d{2}:\d{2}\.\d{3}/.test(result)) {
+    result = result.replace(/(T\d{2}:\d{2}:\d{2})([+\-Z])/, "$1.000$2");
+  }
+  result = result.replace(/([+\-])(\d{2}):(\d{2})$/, "$1$2$3");
+  if (result.endsWith("Z")) {
+    result = result.slice(0, -1) + "+0000";
+  }
+  return result;
+}
+function extractHM(dateStr) {
+  try {
+    const d = new Date(dateStr);
+    if (isNaN(d.getTime())) return null;
+    const hours = d.getHours().toString().padStart(2, "0");
+    const minutes = d.getMinutes().toString().padStart(2, "0");
+    return `${hours}:${minutes}`;
+  } catch {
+    const match = dateStr.match(/T(\d{2}):(\d{2})/);
+    if (!match) return null;
+    return `${match[1]}:${match[2]}`;
+  }
+}
+function formatTaskTime(task) {
+  if (task.isAllDay && task.startDate) return "\u5168\u5929";
+  if (!task.startDate) return "";
+  const start = extractHM(task.startDate);
+  if (!start) return "";
+  if (task.dueDate) {
+    const end = extractHM(task.dueDate);
+    if (end && end !== start) return `${start}-${end}`;
+  }
+  return start;
+}
+// src/api/resources.ts
+function getProjects() {
+  return apiRequest("project");
+}
+function getProject(projectId) {
+  return apiRequest(`project/${projectId}`);
+}
+function getProjectData(projectId) {
+  return apiRequest(`project/${projectId}/data`);
+}
+function createProject(data) {
+  return apiRequest("project", {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+}
+function updateProject(projectId, data) {
+  return apiRequest(`project/${projectId}`, {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+}
+function deleteProject(projectId) {
+  return apiRequest(`project/${projectId}`, { method: "DELETE" });
+}
+function getTask(projectId, taskId) {
+  return apiRequest(`project/${projectId}/task/${taskId}`);
+}
+function createTask(data) {
+  return apiRequest("task", {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+}
+function updateTask(taskId, data) {
+  return apiRequest(`task/${taskId}`, {
+    method: "POST",
+    body: JSON.stringify(data)
+  });
+}
+function completeTask(projectId, taskId) {
+  return apiRequest(`project/${projectId}/task/${taskId}/complete`, {
+    method: "POST"
+  });
+}
+function deleteTask(projectId, taskId) {
+  return apiRequest(`project/${projectId}/task/${taskId}`, {
+    method: "DELETE"
+  });
+}
+function moveTasks(moves) {
+  return apiRequest("task/move", {
+    method: "POST",
+    body: JSON.stringify(moves)
+  });
+}
+function getCompletedTasks(params) {
+  return apiRequest("task/completed", {
+    method: "POST",
+    body: JSON.stringify(params)
+  });
+}
+function filterTasks(params) {
+  return apiRequest("task/filter", {
+    method: "POST",
+    body: JSON.stringify(params)
+  });
+}
+async function batchAddTasks(tasks) {
+  const res = await apiRequest("task/batch", {
+    method: "POST",
+    body: JSON.stringify({ add: tasks })
+  });
+  return {
+    count: tasks.length,
+    id2etag: res?.id2etag ?? res
+  };
+}
+function batchUpdateTasks(tasks) {
+  return apiRequest("task/batch", {
+    method: "POST",
+    body: JSON.stringify({ update: tasks })
+  });
+}
+async function completeTasksInProject(projectId, taskIds) {
+  const completed = [];
+  const failed = [];
+  for (const taskId of taskIds) {
+    try {
+      await completeTask(projectId, taskId);
+      completed.push(taskId);
+    } catch {
+      failed.push(taskId);
+    }
+  }
+  return { completed, failed };
+}
+async function getTaskById(taskId) {
+  const [undoneTasks, completedTasks] = await Promise.all([
+    listUndoneTasksByDate({}),
+    getCompletedTasks({})
+  ]);
+  const allTasks = [...undoneTasks, ...completedTasks];
+  const task = allTasks.find((t) => t.id === taskId);
+  if (!task) throw new Error(`\u4EFB\u52A1 ${taskId} \u4E0D\u5B58\u5728`);
+  return task;
+}
+function getUserPreference() {
+  return apiRequest("user/info");
+}
+function listUndoneTasksByDate(params) {
+  const filterParams = { status: [0] };
+  if (params.projectIds) filterParams.projectIds = params.projectIds;
+  if (params.startDate) filterParams.startDate = params.startDate;
+  if (params.endDate) filterParams.endDate = params.endDate;
+  return filterTasks(filterParams);
+}
+function listUndoneTasksByTimeQuery(query) {
+  const now = /* @__PURE__ */ new Date();
+  let startDate;
+  let endDate;
+  const toISO = (d) => d.toISOString();
+  switch (query) {
+    case "today": {
+      const start = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      startDate = toISO(start);
+      endDate = toISO(end);
+      break;
+    }
+    case "tomorrow": {
+      const start = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1);
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      startDate = toISO(start);
+      endDate = toISO(end);
+      break;
+    }
+    case "last24hour": {
+      const start = new Date(now.getTime() - 24 * 60 * 60 * 1e3);
+      startDate = toISO(start);
+      endDate = toISO(now);
+      break;
+    }
+    case "next24hour": {
+      const end = new Date(now.getTime() + 24 * 60 * 60 * 1e3);
+      startDate = toISO(now);
+      endDate = toISO(end);
+      break;
+    }
+    case "last7day": {
+      const start = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1e3);
+      startDate = toISO(start);
+      endDate = toISO(now);
+      break;
+    }
+    case "next7day": {
+      const end = new Date(now.getTime() + 7 * 24 * 60 * 60 * 1e3);
+      startDate = toISO(now);
+      endDate = toISO(end);
+      break;
+    }
+    default:
+      throw new Error(
+        `\u4E0D\u652F\u6301\u7684\u67E5\u8BE2\u9884\u8BBE: ${query}\uFF0C\u652F\u6301: today, tomorrow, last24hour, next24hour, last7day, next7day`
+      );
+  }
+  return listUndoneTasksByDate({ startDate, endDate });
+}
+async function searchTask(keyword) {
+  const [undoneTasks, completedTasks] = await Promise.all([
+    listUndoneTasksByDate({}),
+    getCompletedTasks({})
+  ]);
+  const taskMap = /* @__PURE__ */ new Map();
+  for (const t of [...undoneTasks, ...completedTasks]) {
+    taskMap.set(t.id, t);
+  }
+  const allTasks = Array.from(taskMap.values());
+  const lower = keyword.toLowerCase();
+  return allTasks.filter(
+    (t) => t.title.toLowerCase().includes(lower) || t.content && t.content.toLowerCase().includes(lower)
+  );
+}
+// src/commands/project.ts
+function priorityText(priority) {
+  const v = priority ?? 0;
+  switch (v) {
+    case 5:
+      return pc2.red("\u9AD8");
+    case 3:
+      return pc2.yellow("\u4E2D");
+    case 1:
+      return pc2.blue("\u4F4E");
+    default:
+      return pc2.dim("\u65E0");
+  }
+}
+function statusIcon(status) {
+  return status === 2 ? pc2.green("\u2713") : "\u25CB";
+}
+function displayTaskList(tasks) {
+  if (tasks.length === 0) {
+    p2.log.info(pc2.dim("  \uFF08\u65E0\u4EFB\u52A1\uFF09"));
+    return;
+  }
+  for (const task of tasks) {
+    const icon = statusIcon(task.status);
+    const title = task.title.length > 30 ? task.title.slice(0, 30) + "\u2026" : task.title;
+    const time = formatTaskTime(task);
+    const timeStr = time ? pc2.cyan(time) : "";
+    console.log(
+      `  ${icon} ${title}  ${timeStr}  ${priorityText(task.priority)}`
+    );
+    if (task.content) {
+      const content = task.content.length > 50 ? task.content.slice(0, 50) + "\u2026" : task.content;
+      console.log(`    ${pc2.dim(content)}`);
+    }
+  }
+}
+async function projectListCommand() {
+  const s2 = p2.spinner();
+  s2.start("\u6B63\u5728\u83B7\u53D6\u9879\u76EE\u5217\u8868...");
+  try {
+    const projects = await getProjects();
+    s2.stop(`\u627E\u5230 ${projects.length} \u4E2A\u9879\u76EE`);
+    if (projects.length === 0) {
+      p2.outro(pc2.yellow("\u6CA1\u6709\u627E\u5230\u4EFB\u4F55\u9879\u76EE"));
+      return;
+    }
+    console.log("");
+    for (const project of projects) {
+      const status = project.closed ? pc2.dim("\u5DF2\u5173\u95ED") : pc2.green("\u6D3B\u8DC3");
+      console.log(
+        `  ${pc2.bold(project.name)}  ${pc2.dim(project.id)}`
+      );
+      console.log(
+        `    \u7C7B\u578B: ${project.kind || "-"}  \u89C6\u56FE: ${project.viewMode || "-"}  ${status}`
+      );
+    }
+    console.log("");
+    p2.outro(`\u5171 ${projects.length} \u4E2A\u9879\u76EE`);
+  } catch (err) {
+    s2.stop("\u83B7\u53D6\u5931\u8D25");
+    p2.outro(pc2.red(err.message));
+  }
+}
+async function projectGetCommand(id) {
+  const s2 = p2.spinner();
+  s2.start("\u6B63\u5728\u83B7\u53D6\u9879\u76EE\u8BE6\u60C5...");
+  try {
+    const project = await getProject(id);
+    s2.stop("\u83B7\u53D6\u6210\u529F");
+    console.log("");
+    console.log(`  ${pc2.bold("\u540D\u79F0")}: ${project.name}`);
+    console.log(`  ${pc2.bold("ID")}:   ${project.id}`);
+    console.log(`  ${pc2.bold("\u989C\u8272")}: ${project.color || "-"}`);
+    console.log(`  ${pc2.bold("\u7C7B\u578B")}: ${project.kind || "-"}`);
+    console.log(`  ${pc2.bold("\u89C6\u56FE")}: ${project.viewMode || "-"}`);
+    console.log(
+      `  ${pc2.bold("\u72B6\u6001")}: ${project.closed ? "\u5DF2\u5173\u95ED" : "\u6D3B\u8DC3"}`
+    );
+    if (project.groupId)
+      console.log(`  ${pc2.bold("\u5206\u7EC4")}: ${project.groupId}`);
+    if (project.permission)
+      console.log(`  ${pc2.bold("\u6743\u9650")}: ${project.permission}`);
+    console.log("");
+  } catch (err) {
+    s2.stop("\u83B7\u53D6\u5931\u8D25");
+    p2.outro(pc2.red(err.message));
+  }
+}
+async function projectTasksCommand(id, options) {
+  try {
+    const data = await getProjectData(id);
+    if (options.json) {
+      console.log(JSON.stringify(data.tasks, null, 2));
+      return;
+    }
+    const s2 = p2.spinner();
+    s2.start("\u6B63\u5728\u83B7\u53D6\u9879\u76EE\u4EFB\u52A1...");
+    s2.stop(
+      `\u9879\u76EE\u300C${data.project.name}\u300D\u4E0B\u6709 ${data.tasks.length} \u4E2A\u4EFB\u52A1`
+    );
+    if (data.tasks.length === 0) {
+      p2.outro(pc2.yellow("\u8BE5\u9879\u76EE\u4E0B\u6CA1\u6709\u4EFB\u52A1"));
+      return;
+    }
+    console.log("");
+    displayTaskList(data.tasks);
+    console.log("");
+    p2.outro(`\u5171 ${data.tasks.length} \u4E2A\u4EFB\u52A1`);
+  } catch (err) {
+    s.stop("\u83B7\u53D6\u5931\u8D25");
+    p2.outro(pc2.red(err.message));
+  }
+}
+async function projectCreateCommand(name, options) {
+  if (!name) {
+    const input = await p2.text({ message: "\u8BF7\u8F93\u5165\u9879\u76EE\u540D\u79F0" });
+    if (p2.isCancel(input)) {
+      p2.outro("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    name = input;
+  }
+  const params = { name };
+  if (options.color) params.color = options.color;
+  if (options.viewMode)
+    params.viewMode = options.viewMode;
+  if (options.kind)
+    params.kind = options.kind;
+  const s2 = p2.spinner();
+  s2.start("\u6B63\u5728\u521B\u5EFA\u9879\u76EE...");
+  try {
+    const project = await createProject(params);
+    s2.stop("\u521B\u5EFA\u6210\u529F");
+    p2.outro(
+      pc2.green(`\u9879\u76EE\u300C${project.name}\u300D\u5DF2\u521B\u5EFA (ID: ${project.id})`)
+    );
+  } catch (err) {
+    s2.stop("\u521B\u5EFA\u5931\u8D25");
+    p2.outro(pc2.red(err.message));
+  }
+}
+async function projectUpdateCommand(id, options) {
+  const params = {};
+  if (options.name) params.name = options.name;
+  if (options.color) params.color = options.color;
+  if (options.viewMode)
+    params.viewMode = options.viewMode;
+  if (options.kind)
+    params.kind = options.kind;
+  if (Object.keys(params).length === 0) {
+    p2.outro(
+      pc2.yellow(
+        "\u672A\u6307\u5B9A\u4EFB\u4F55\u66F4\u65B0\u5185\u5BB9\uFF0C\u4F7F\u7528 --name / --color / --view-mode / --kind \u9009\u9879"
+      )
+    );
+    return;
+  }
+  const s2 = p2.spinner();
+  s2.start("\u6B63\u5728\u66F4\u65B0\u9879\u76EE...");
+  try {
+    const project = await updateProject(id, params);
+    s2.stop("\u66F4\u65B0\u6210\u529F");
+    p2.outro(pc2.green(`\u9879\u76EE\u300C${project.name}\u300D\u5DF2\u66F4\u65B0`));
+  } catch (err) {
+    s2.stop("\u66F4\u65B0\u5931\u8D25");
+    p2.outro(pc2.red(err.message));
+  }
+}
+async function projectDeleteCommand(id) {
+  const confirmed = await p2.confirm({
+    message: `\u786E\u8BA4\u5220\u9664\u9879\u76EE ${pc2.red(id)}\uFF1F\u6B64\u64CD\u4F5C\u4E0D\u53EF\u64A4\u9500`
+  });
+  if (p2.isCancel(confirmed) || !confirmed) {
+    p2.outro("\u5DF2\u53D6\u6D88");
+    return;
+  }
+  const s2 = p2.spinner();
+  s2.start("\u6B63\u5728\u5220\u9664\u9879\u76EE...");
+  try {
+    await deleteProject(id);
+    s2.stop("\u5220\u9664\u6210\u529F");
+    p2.outro(pc2.green("\u9879\u76EE\u5DF2\u5220\u9664"));
+  } catch (err) {
+    s2.stop("\u5220\u9664\u5931\u8D25");
+    p2.outro(pc2.red(err.message));
+  }
+}
+function registerProjectCommands(cli2) {
+  cli2.command("project-list", "\u5217\u51FA\u6240\u6709\u9879\u76EE").action(projectListCommand);
+  cli2.command("project-get <id>", "\u83B7\u53D6\u9879\u76EE\u8BE6\u60C5").action(projectGetCommand);
+  cli2.command("project-tasks <id>", "\u83B7\u53D6\u9879\u76EE\u4E0B\u7684\u4EFB\u52A1").option("--json", "\u8F93\u51FA JSON \u683C\u5F0F").action(projectTasksCommand);
+  cli2.command("project-create [name]", "\u521B\u5EFA\u9879\u76EE").option("--color <color>", "\u9879\u76EE\u989C\u8272\uFF0C\u5982 #F18181").option("--view-mode <mode>", "\u89C6\u56FE\u6A21\u5F0F: list / kanban / timeline").option("--kind <kind>", "\u9879\u76EE\u7C7B\u578B: TASK / NOTE").action(projectCreateCommand);
+  cli2.command("project-update <id>", "\u66F4\u65B0\u9879\u76EE").option("--name <name>", "\u9879\u76EE\u540D\u79F0").option("--color <color>", "\u9879\u76EE\u989C\u8272").option("--view-mode <mode>", "\u89C6\u56FE\u6A21\u5F0F").option("--kind <kind>", "\u9879\u76EE\u7C7B\u578B").action(projectUpdateCommand);
+  cli2.command("project-delete <id>", "\u5220\u9664\u9879\u76EE").action(projectDeleteCommand);
+}
+// src/commands/task.ts
+import * as p3 from "@clack/prompts";
+import pc3 from "picocolors";
+function priorityText2(priority) {
+  const v = priority ?? 0;
+  switch (v) {
+    case 5:
+      return pc3.red("\u9AD8");
+    case 3:
+      return pc3.yellow("\u4E2D");
+    case 1:
+      return pc3.blue("\u4F4E");
+    default:
+      return pc3.dim("\u65E0");
+  }
+}
+function statusIcon2(status) {
+  return status === 2 ? pc3.green("\u2713") : "\u25CB";
+}
+function displayTaskDetail(task) {
+  console.log("");
+  console.log(`  ${pc3.bold(task.title)}`);
+  console.log(`  ${pc3.dim("\u2500".repeat(40))}`);
+  console.log(`  ID:     ${task.id}`);
+  console.log(`  \u9879\u76EE:   ${task.projectId}`);
+  console.log(`  \u4F18\u5148\u7EA7: ${priorityText2(task.priority)}`);
+  console.log(`  \u72B6\u6001:   ${task.status === 2 ? pc3.green("\u5DF2\u5B8C\u6210") : "\u5F85\u529E"}`);
+  if (task.isAllDay !== void 0)
+    console.log(`  \u5168\u5929:   ${task.isAllDay ? "\u662F" : "\u5426"}`);
+  if (task.startDate)
+    console.log(`  \u5F00\u59CB:   ${task.startDate}`);
+  if (task.dueDate)
+    console.log(`  \u622A\u6B62:   ${task.dueDate}`);
+  if (task.timeZone)
+    console.log(`  \u65F6\u533A:   ${task.timeZone}`);
+  if (task.kind)
+    console.log(`  \u7C7B\u578B:   ${task.kind}`);
+  if (task.content) {
+    console.log(`  \u5185\u5BB9:`);
+    console.log(`    ${task.content}`);
+  }
+  if (task.tags && task.tags.length > 0) {
+    console.log(`  \u6807\u7B7E:   ${task.tags.join(", ")}`);
+  }
+  if (task.items && task.items.length > 0) {
+    console.log(`  \u5B50\u4EFB\u52A1:`);
+    for (const item of task.items) {
+      const icon = item.status === 1 ? pc3.green("\u2713") : "\u25CB";
+      console.log(`    ${icon} ${item.title}`);
+    }
+  }
+  console.log("");
+}
+function displayTaskTable(tasks) {
+  if (tasks.length === 0) {
+    p3.log.info(pc3.dim("  \uFF08\u65E0\u4EFB\u52A1\uFF09"));
+    return;
+  }
+  for (const task of tasks) {
+    const icon = statusIcon2(task.status);
+    const title = task.title.length > 30 ? task.title.slice(0, 30) + "\u2026" : task.title;
+    const time = formatTaskTime(task);
+    const timeStr = time ? pc3.cyan(time) : "";
+    console.log(
+      `  ${icon} ${title}  ${timeStr}  ${pc3.dim(task.id)}  ${priorityText2(task.priority)}  ${pc3.dim(task.projectId)}`
+    );
+  }
+}
+async function selectProject() {
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u83B7\u53D6\u9879\u76EE\u5217\u8868...");
+  const projects = await getProjects();
+  s2.stop("");
+  if (projects.length === 0) {
+    p3.log.error("\u6CA1\u6709\u53EF\u7528\u7684\u9879\u76EE\uFF0C\u8BF7\u5148\u521B\u5EFA\u9879\u76EE");
+    return void 0;
+  }
+  const selected = await p3.select({
+    message: "\u9009\u62E9\u9879\u76EE",
+    options: projects.map((proj) => ({
+      value: proj.id,
+      label: proj.name
+    }))
+  });
+  if (p3.isCancel(selected)) return void 0;
+  return selected;
+}
+function parsePriority(value) {
+  if (!value) return void 0;
+  const n = parseInt(value, 10);
+  if ([0, 1, 3, 5].includes(n)) return n;
+  return void 0;
+}
+async function taskAddCommand(title, options) {
+  if (!title) {
+    const input = await p3.text({ message: "\u8BF7\u8F93\u5165\u4EFB\u52A1\u6807\u9898" });
+    if (p3.isCancel(input)) {
+      p3.outro("\u5DF2\u53D6\u6D88");
+      return;
+    }
+    title = input;
+  }
+  let projectId = options.project;
+  if (!projectId) {
+    projectId = await selectProject();
+    if (!projectId) {
+      p3.outro("\u5DF2\u53D6\u6D88");
+      return;
+    }
+  }
+  const params = { title, projectId };
+  if (options.content) params.content = options.content;
+  if (options.priority) {
+    const priority = parsePriority(options.priority);
+    if (priority !== void 0) params.priority = priority;
+  }
+  if (options.startDate) params.startDate = normalizeTickTickDate(options.startDate);
+  if (options.dueDate) params.dueDate = normalizeTickTickDate(options.dueDate);
+  if (options.allDay !== void 0) params.isAllDay = options.allDay;
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u521B\u5EFA\u4EFB\u52A1...");
+  try {
+    const task = await createTask(params);
+    s2.stop("\u521B\u5EFA\u6210\u529F");
+    p3.outro(pc3.green(`\u4EFB\u52A1\u300C${task.title}\u300D\u5DF2\u521B\u5EFA (ID: ${task.id})`));
+  } catch (err) {
+    s2.stop("\u521B\u5EFA\u5931\u8D25");
+    p3.outro(pc3.red(err.message));
+  }
+}
+async function taskGetCommand(projectId, taskId) {
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u83B7\u53D6\u4EFB\u52A1...");
+  try {
+    const task = await getTask(projectId, taskId);
+    s2.stop("\u83B7\u53D6\u6210\u529F");
+    displayTaskDetail(task);
+    p3.outro("\u4EFB\u52A1\u8BE6\u60C5\u5982\u4E0A");
+  } catch (err) {
+    s2.stop("\u83B7\u53D6\u5931\u8D25");
+    const msg = err.message;
+    p3.outro(
+      pc3.red(`\u83B7\u53D6\u4EFB\u52A1\u5931\u8D25 (projectId: ${projectId}, taskId: ${taskId})
+`) + pc3.red(`${msg}
+`) + pc3.yellow("\u6392\u67E5\u5EFA\u8BAE: \u8FD0\u884C tt task-find <taskId> \u6216 tt task-search <\u5173\u952E\u8BCD> \u9A8C\u8BC1\u4EFB\u52A1")
+    );
+  }
+}
+async function taskDoneCommand(projectId, taskId) {
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u5B8C\u6210\u4EFB\u52A1...");
+  try {
+    await completeTask(projectId, taskId);
+    s2.stop("\u5B8C\u6210\u6210\u529F");
+    p3.outro(pc3.green("\u4EFB\u52A1\u5DF2\u5B8C\u6210"));
+  } catch (err) {
+    s2.stop("\u64CD\u4F5C\u5931\u8D25");
+    const msg = err.message;
+    p3.outro(
+      pc3.red(`\u4EFB\u52A1\u5B8C\u6210\u5931\u8D25 (projectId: ${projectId}, taskId: ${taskId})
+`) + pc3.red(`${msg}
+`) + pc3.yellow("\u6392\u67E5\u5EFA\u8BAE: \u8FD0\u884C tt task-search \u68C0\u67E5\u4EFB\u52A1\u662F\u5426\u5B58\u5728\u6216\u5DF2\u5B8C\u6210")
+    );
+  }
+}
+async function taskDeleteCommand(projectId, taskId) {
+  const confirmed = await p3.confirm({
+    message: `\u786E\u8BA4\u5220\u9664\u4EFB\u52A1 ${pc3.red(taskId)}\uFF1F`
+  });
+  if (p3.isCancel(confirmed) || !confirmed) {
+    p3.outro("\u5DF2\u53D6\u6D88");
+    return;
+  }
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u5220\u9664\u4EFB\u52A1...");
+  try {
+    await deleteTask(projectId, taskId);
+    s2.stop("\u5220\u9664\u6210\u529F");
+    p3.outro(pc3.green("\u4EFB\u52A1\u5DF2\u5220\u9664"));
+  } catch (err) {
+    s2.stop("\u5220\u9664\u5931\u8D25");
+    const msg = err.message;
+    p3.outro(
+      pc3.red(`\u5220\u9664\u4EFB\u52A1\u5931\u8D25 (projectId: ${projectId}, taskId: ${taskId})
+`) + pc3.red(`${msg}
+`) + pc3.yellow("\u6392\u67E5\u5EFA\u8BAE: \u8FD0\u884C tt task-get <projectId> <taskId> \u9A8C\u8BC1\u4EFB\u52A1\u662F\u5426\u5B58\u5728")
+    );
+  }
+}
+async function taskUpdateCommand(taskId, options) {
+  if (!options.project) {
+    p3.outro(pc3.red("\u8BF7\u4F7F\u7528 -p/--project \u6307\u5B9A\u9879\u76EE ID"));
+    return;
+  }
+  const params = {
+    id: taskId,
+    projectId: options.project
+  };
+  if (options.title) params.title = options.title;
+  if (options.content) params.content = options.content;
+  if (options.priority) {
+    const priority = parsePriority(options.priority);
+    if (priority !== void 0) params.priority = priority;
+  }
+  if (options.startDate) params.startDate = normalizeTickTickDate(options.startDate);
+  if (options.dueDate) params.dueDate = normalizeTickTickDate(options.dueDate);
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u66F4\u65B0\u4EFB\u52A1...");
+  try {
+    const task = await updateTask(taskId, params);
+    s2.stop("\u66F4\u65B0\u6210\u529F");
+    p3.outro(pc3.green(`\u4EFB\u52A1\u300C${task.title}\u300D\u5DF2\u66F4\u65B0`));
+  } catch (err) {
+    s2.stop("\u66F4\u65B0\u5931\u8D25");
+    const msg = err.message;
+    p3.outro(
+      pc3.red(`\u66F4\u65B0\u4EFB\u52A1\u5931\u8D25 (taskId: ${taskId}, projectId: ${options.project})
+`) + pc3.red(`${msg}
+`) + pc3.yellow("\u6392\u67E5\u5EFA\u8BAE: \u8FD0\u884C tt task-find <taskId> \u9A8C\u8BC1\u4EFB\u52A1\u662F\u5426\u5B58\u5728")
+    );
+  }
+}
+async function taskMoveCommand(taskId, options) {
+  if (!options.from || !options.to) {
+    p3.outro(
+      pc3.red("\u8BF7\u4F7F\u7528 -f/--from \u548C -t/--to \u6307\u5B9A\u6E90\u548C\u76EE\u6807\u9879\u76EE ID")
+    );
+    return;
+  }
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u79FB\u52A8\u4EFB\u52A1...");
+  try {
+    const result = await moveTasks([
+      {
+        fromProjectId: options.from,
+        toProjectId: options.to,
+        taskId
+      }
+    ]);
+    s2.stop("\u79FB\u52A8\u6210\u529F");
+    p3.outro(
+      pc3.green(
+        `\u4EFB\u52A1\u5DF2\u79FB\u52A8 (etag: ${result[0]?.etag ?? "-"})`
+      )
+    );
+  } catch (err) {
+    s2.stop("\u79FB\u52A8\u5931\u8D25");
+    const msg = err.message;
+    p3.outro(
+      pc3.red(`\u79FB\u52A8\u4EFB\u52A1\u5931\u8D25 (taskId: ${taskId}, from: ${options.from}, to: ${options.to})
+`) + pc3.red(`${msg}
+`) + pc3.yellow("\u6392\u67E5\u5EFA\u8BAE: \u8FD0\u884C tt project-list \u9A8C\u8BC1\u9879\u76EE ID \u662F\u5426\u6709\u6548")
+    );
+  }
+}
+async function taskCompletedCommand(options) {
+  const params = {};
+  if (options.project) params.projectIds = [options.project];
+  if (options.start) params.startDate = options.start;
+  if (options.end) params.endDate = options.end;
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u83B7\u53D6\u5DF2\u5B8C\u6210\u4EFB\u52A1...");
+  try {
+    const tasks = await getCompletedTasks(params);
+    s2.stop(`\u627E\u5230 ${tasks.length} \u4E2A\u5DF2\u5B8C\u6210\u4EFB\u52A1`);
+    if (tasks.length === 0) {
+      p3.outro(pc3.yellow("\u6CA1\u6709\u627E\u5230\u5DF2\u5B8C\u6210\u7684\u4EFB\u52A1"));
+      return;
+    }
+    console.log("");
+    displayTaskTable(tasks);
+    console.log("");
+    p3.outro(`\u5171 ${tasks.length} \u4E2A\u5DF2\u5B8C\u6210\u4EFB\u52A1`);
+  } catch (err) {
+    s2.stop("\u83B7\u53D6\u5931\u8D25");
+    p3.outro(pc3.red(err.message));
+  }
+}
+async function taskListCommand(options) {
+  const params = {};
+  if (options.project) params.projectIds = [options.project];
+  if (options.start) params.startDate = options.start;
+  if (options.end) params.endDate = options.end;
+  if (options.status) {
+    params.status = options.status.split(",").map((s2) => parseInt(s2, 10));
+  }
+  if (options.priority) {
+    params.priority = options.priority.split(",").map((s2) => parseInt(s2, 10));
+  }
+  if (options.tag) {
+    params.tag = options.tag.split(",");
+  }
+  try {
+    const tasks = await filterTasks(params);
+    if (options.json) {
+      console.log(JSON.stringify(tasks, null, 2));
+      return;
+    }
+    const s2 = p3.spinner();
+    s2.start("\u6B63\u5728\u7B5B\u9009\u4EFB\u52A1...");
+    s2.stop(`\u627E\u5230 ${tasks.length} \u4E2A\u4EFB\u52A1`);
+    if (tasks.length === 0) {
+      p3.outro(pc3.yellow("\u6CA1\u6709\u627E\u5230\u5339\u914D\u7684\u4EFB\u52A1"));
+      return;
+    }
+    console.log("");
+    displayTaskTable(tasks);
+    console.log("");
+    p3.outro(`\u5171 ${tasks.length} \u4E2A\u4EFB\u52A1`);
+  } catch (err) {
+    p3.outro(pc3.red(err.message));
+  }
+}
+async function taskBatchAddCommand(jsonFile, options) {
+  let jsonStr;
+  if (options.stdin || !jsonFile) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    jsonStr = Buffer.concat(chunks).toString("utf-8");
+  } else {
+    const fs2 = await import("fs/promises");
+    jsonStr = await fs2.readFile(jsonFile, "utf-8");
+  }
+  let tasks;
+  try {
+    tasks = JSON.parse(jsonStr);
+    if (!Array.isArray(tasks)) {
+      p3.outro(pc3.red("JSON \u5FC5\u987B\u662F\u4EFB\u52A1\u6570\u7EC4"));
+      return;
+    }
+  } catch {
+    p3.outro(pc3.red("JSON \u89E3\u6790\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u683C\u5F0F"));
+    return;
+  }
+  for (const task of tasks) {
+    if (task.startDate) task.startDate = normalizeTickTickDate(task.startDate);
+    if (task.dueDate) task.dueDate = normalizeTickTickDate(task.dueDate);
+  }
+  const s2 = p3.spinner();
+  s2.start(`\u6B63\u5728\u6279\u91CF\u521B\u5EFA ${tasks.length} \u4E2A\u4EFB\u52A1...`);
+  try {
+    const result = await batchAddTasks(tasks);
+    s2.stop(`\u6210\u529F\u521B\u5EFA ${result.count} \u4E2A\u4EFB\u52A1`);
+    console.log("");
+    for (const task of tasks) {
+      console.log(`  ${pc3.green("\u2713")} ${task.title}`);
+    }
+    console.log("");
+    p3.outro(`\u5171\u521B\u5EFA ${result.count} \u4E2A\u4EFB\u52A1`);
+  } catch (err) {
+    s2.stop("\u6279\u91CF\u521B\u5EFA\u5931\u8D25");
+    p3.outro(pc3.red(err.message));
+  }
+}
+async function taskBatchUpdateCommand(jsonFile, options) {
+  let jsonStr;
+  if (options.stdin || !jsonFile) {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+      chunks.push(chunk);
+    }
+    jsonStr = Buffer.concat(chunks).toString("utf-8");
+  } else {
+    const fs2 = await import("fs/promises");
+    jsonStr = await fs2.readFile(jsonFile, "utf-8");
+  }
+  let tasks;
+  try {
+    tasks = JSON.parse(jsonStr);
+    if (!Array.isArray(tasks)) {
+      p3.outro(pc3.red("JSON \u5FC5\u987B\u662F\u4EFB\u52A1\u6570\u7EC4"));
+      return;
+    }
+  } catch {
+    p3.outro(pc3.red("JSON \u89E3\u6790\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u683C\u5F0F"));
+    return;
+  }
+  const s2 = p3.spinner();
+  s2.start(`\u6B63\u5728\u6279\u91CF\u66F4\u65B0 ${tasks.length} \u4E2A\u4EFB\u52A1...`);
+  try {
+    await batchUpdateTasks(tasks);
+    s2.stop(`\u6210\u529F\u66F4\u65B0 ${tasks.length} \u4E2A\u4EFB\u52A1`);
+    p3.outro(pc3.green(`\u5DF2\u66F4\u65B0 ${tasks.length} \u4E2A\u4EFB\u52A1`));
+  } catch (err) {
+    s2.stop("\u6279\u91CF\u66F4\u65B0\u5931\u8D25");
+    p3.outro(pc3.red(err.message));
+  }
+}
+async function taskBatchDoneCommand(projectId, options) {
+  let ids;
+  if (options.all) {
+    const s3 = p3.spinner();
+    s3.start("\u6B63\u5728\u83B7\u53D6\u9879\u76EE\u4EFB\u52A1...");
+    const tasks = await filterTasks({ projectIds: [projectId], status: [0] });
+    s3.stop(`\u627E\u5230 ${tasks.length} \u4E2A\u672A\u5B8C\u6210\u4EFB\u52A1`);
+    ids = tasks.map((t) => t.id);
+  } else if (options.taskIds) {
+    ids = options.taskIds.split(",").map((s3) => s3.trim());
+  } else {
+    p3.outro(pc3.red("\u8BF7\u4F7F\u7528 --task-ids <id1,id2,...> \u6216 --all"));
+    return;
+  }
+  if (ids.length === 0) {
+    p3.outro(pc3.yellow("\u6CA1\u6709\u9700\u8981\u5B8C\u6210\u7684\u4EFB\u52A1"));
+    return;
+  }
+  if (!options.force) {
+    console.log("");
+    console.log(`  \u5C06\u5B8C\u6210 ${ids.length} \u4E2A\u4EFB\u52A1:`);
+    for (const id of ids) {
+      console.log(`  ${pc3.dim(id)}`);
+    }
+    console.log("");
+    const confirmed = await p3.confirm({
+      message: `\u786E\u8BA4\u5B8C\u6210\u8FD9 ${ids.length} \u4E2A\u4EFB\u52A1\uFF1F`
+    });
+    if (p3.isCancel(confirmed) || !confirmed) {
+      p3.outro("\u5DF2\u53D6\u6D88");
+      return;
+    }
+  }
+  const s2 = p3.spinner();
+  s2.start(`\u6B63\u5728\u5B8C\u6210 ${ids.length} \u4E2A\u4EFB\u52A1...`);
+  try {
+    const result = await completeTasksInProject(projectId, ids);
+    s2.stop("\u64CD\u4F5C\u5B8C\u6210");
+    p3.outro(
+      pc3.green(`\u6210\u529F ${result.completed.length} \u4E2A`) + (result.failed.length > 0 ? pc3.red(`\uFF0C\u5931\u8D25 ${result.failed.length} \u4E2A`) : "")
+    );
+  } catch (err) {
+    s2.stop("\u64CD\u4F5C\u5931\u8D25");
+    p3.outro(pc3.red(err.message));
+  }
+}
+async function taskFindCommand(taskId) {
+  const s2 = p3.spinner();
+  s2.start("\u6B63\u5728\u67E5\u627E\u4EFB\u52A1...");
+  try {
+    const task = await getTaskById(taskId);
+    s2.stop("\u67E5\u627E\u6210\u529F");
+    displayTaskDetail(task);
+    p3.outro("\u4EFB\u52A1\u8BE6\u60C5\u5982\u4E0A");
+  } catch (err) {
+    s2.stop("\u67E5\u627E\u5931\u8D25");
+    p3.outro(pc3.red(err.message));
+  }
+}
+async function taskUndoneCommand(options) {
+  let tasks;
+  try {
+    if (options.query) {
+      tasks = await listUndoneTasksByTimeQuery(options.query);
+    } else {
+      const params = {};
+      if (options.start) params.startDate = options.start;
+      if (options.end) params.endDate = options.end;
+      if (options.project) params.projectIds = [options.project];
+      tasks = await listUndoneTasksByDate(params);
+    }
+    if (options.json) {
+      console.log(JSON.stringify(tasks, null, 2));
+      return;
+    }
+    const s2 = p3.spinner();
+    s2.start("\u6B63\u5728\u83B7\u53D6\u672A\u5B8C\u6210\u4EFB\u52A1...");
+    s2.stop(`\u627E\u5230 ${tasks.length} \u4E2A\u672A\u5B8C\u6210\u4EFB\u52A1`);
+    if (tasks.length === 0) {
+      p3.outro(pc3.yellow("\u6CA1\u6709\u627E\u5230\u672A\u5B8C\u6210\u4EFB\u52A1"));
+      return;
+    }
+    console.log("");
+    displayTaskTable(tasks);
+    console.log("");
+    p3.outro(`\u5171 ${tasks.length} \u4E2A\u672A\u5B8C\u6210\u4EFB\u52A1`);
+  } catch (err) {
+    s.stop("\u83B7\u53D6\u5931\u8D25");
+    p3.outro(pc3.red(err.message));
+  }
+}
+async function taskSearchCommand(keyword) {
+  const s2 = p3.spinner();
+  s2.start(`\u6B63\u5728\u641C\u7D22 "${keyword}"...`);
+  try {
+    const tasks = await searchTask(keyword);
+    s2.stop(`\u627E\u5230 ${tasks.length} \u4E2A\u5339\u914D\u4EFB\u52A1`);
+    if (tasks.length === 0) {
+      p3.outro(pc3.yellow(`\u6CA1\u6709\u627E\u5230\u5305\u542B "${keyword}" \u7684\u4EFB\u52A1`));
+      return;
+    }
+    console.log("");
+    for (const task of tasks) {
+      const icon = statusIcon2(task.status);
+      const title = task.title.replace(
+        new RegExp(keyword, "gi"),
+        (m) => pc3.bold(pc3.yellow(m))
+      );
+      console.log(`  ${icon} ${title}  ${pc3.dim(task.id)}  ${pc3.dim(task.projectId)}`);
+    }
+    console.log("");
+    p3.outro(`\u5171 ${tasks.length} \u4E2A\u5339\u914D`);
+  } catch (err) {
+    s2.stop("\u641C\u7D22\u5931\u8D25");
+    p3.outro(pc3.red(err.message));
+  }
+}
+function registerTaskCommands(cli2) {
+  cli2.command("task-add [title]", "\u521B\u5EFA\u4EFB\u52A1").option("-p, --project <id>", "\u9879\u76EE ID").option("--content <text>", "\u4EFB\u52A1\u5185\u5BB9").option("--priority <n>", "\u4F18\u5148\u7EA7: 0(\u65E0) / 1(\u4F4E) / 3(\u4E2D) / 5(\u9AD8)").option("--start-date <date>", "\u5F00\u59CB\u65E5\u671F").option("--due-date <date>", "\u622A\u6B62\u65E5\u671F").option("--all-day", "\u5168\u5929\u4EFB\u52A1").action(taskAddCommand);
+  cli2.command("task-get <projectId> <taskId>", "\u83B7\u53D6\u4EFB\u52A1\u8BE6\u60C5").action(taskGetCommand);
+  cli2.command("task-done <projectId> <taskId>", "\u5B8C\u6210\u4EFB\u52A1").action(taskDoneCommand);
+  cli2.command("task-delete <projectId> <taskId>", "\u5220\u9664\u4EFB\u52A1").action(taskDeleteCommand);
+  cli2.command("task-update <taskId>", "\u66F4\u65B0\u4EFB\u52A1").option("-p, --project <id>", "\u9879\u76EE ID\uFF08\u5FC5\u586B\uFF09").option("--title <title>", "\u4EFB\u52A1\u6807\u9898").option("--content <text>", "\u4EFB\u52A1\u5185\u5BB9").option("--priority <n>", "\u4F18\u5148\u7EA7").option("--start-date <date>", "\u5F00\u59CB\u65E5\u671F").option("--due-date <date>", "\u622A\u6B62\u65E5\u671F").action(taskUpdateCommand);
+  cli2.command("task-move <taskId>", "\u79FB\u52A8\u4EFB\u52A1\u5230\u5176\u4ED6\u9879\u76EE").option("-f, --from <id>", "\u6E90\u9879\u76EE ID").option("-t, --to <id>", "\u76EE\u6807\u9879\u76EE ID").action(taskMoveCommand);
+  cli2.command("task-completed", "\u67E5\u770B\u5DF2\u5B8C\u6210\u4EFB\u52A1").option("-p, --project <id>", "\u6309\u9879\u76EE\u7B5B\u9009").option("--start <date>", "\u5F00\u59CB\u65E5\u671F").option("--end <date>", "\u7ED3\u675F\u65E5\u671F").action(taskCompletedCommand);
+  cli2.command("task-list", "\u7B5B\u9009\u4EFB\u52A1").option("-p, --project <id>", "\u6309\u9879\u76EE\u7B5B\u9009").option("--start <date>", "\u5F00\u59CB\u65E5\u671F").option("--end <date>", "\u7ED3\u675F\u65E5\u671F").option("--status <n>", "\u72B6\u6001\uFF0C\u9017\u53F7\u5206\u9694: 0(\u5F85\u529E),2(\u5DF2\u5B8C\u6210)").option("--priority <n>", "\u4F18\u5148\u7EA7\uFF0C\u9017\u53F7\u5206\u9694: 0,1,3,5").option("--tag <tag>", "\u6807\u7B7E\uFF0C\u9017\u53F7\u5206\u9694").option("--json", "\u8F93\u51FA JSON \u683C\u5F0F").action(taskListCommand);
+  cli2.command("task-batch-add [jsonFile]", "\u6279\u91CF\u521B\u5EFA\u4EFB\u52A1").option("--stdin", "\u4ECE\u6807\u51C6\u8F93\u5165\u8BFB\u53D6 JSON").action(taskBatchAddCommand);
+  cli2.command("task-batch-update [jsonFile]", "\u6279\u91CF\u66F4\u65B0\u4EFB\u52A1").option("--stdin", "\u4ECE\u6807\u51C6\u8F93\u5165\u8BFB\u53D6 JSON").action(taskBatchUpdateCommand);
+  cli2.command("task-batch-done <projectId>", "\u6279\u91CF\u5B8C\u6210\u4EFB\u52A1").option("--task-ids <ids>", "\u4EFB\u52A1 ID \u5217\u8868\uFF0C\u9017\u53F7\u5206\u9694").option("--all", "\u5B8C\u6210\u9879\u76EE\u4E0B\u6240\u6709\u672A\u5B8C\u6210\u4EFB\u52A1").option("--force", "\u8DF3\u8FC7\u786E\u8BA4").action(taskBatchDoneCommand);
+  cli2.command("task-find <taskId>", "\u6309 ID \u67E5\u627E\u4EFB\u52A1\uFF08\u65E0\u9700\u9879\u76EE ID\uFF09").action(taskFindCommand);
+  cli2.command("task-undone", "\u67E5\u770B\u672A\u5B8C\u6210\u4EFB\u52A1").option("--start <date>", "\u5F00\u59CB\u65E5\u671F").option("--end <date>", "\u7ED3\u675F\u65E5\u671F").option("--query <preset>", "\u9884\u8BBE\u67E5\u8BE2: today|tomorrow|last24hour|next24hour|last7day|next7day").option("-p, --project <id>", "\u6309\u9879\u76EE\u7B5B\u9009").option("--json", "\u8F93\u51FA JSON \u683C\u5F0F").action(taskUndoneCommand);
+  cli2.command("task-search <keyword>", "\u641C\u7D22\u4EFB\u52A1").action(taskSearchCommand);
+}
+// src/commands/user.ts
+import * as p4 from "@clack/prompts";
+import pc4 from "picocolors";
+async function userPrefCommand() {
+  const s2 = p4.spinner();
+  s2.start("\u6B63\u5728\u83B7\u53D6\u7528\u6237\u504F\u597D...");
+  try {
+    const pref = await getUserPreference();
+    s2.stop("\u83B7\u53D6\u6210\u529F");
+    console.log("");
+    if (pref.timeZone) console.log(`  \u65F6\u533A: ${pref.timeZone}`);
+    if (pref.dateFormat !== void 0)
+      console.log(`  \u65E5\u671F\u683C\u5F0F: ${pref.dateFormat}`);
+    if (pref.language) console.log(`  \u8BED\u8A00: ${pref.language}`);
+    if (pref.theme) console.log(`  \u4E3B\u9898: ${pref.theme}`);
+    if (!pref.timeZone && pref.dateFormat === void 0 && !pref.language && !pref.theme) {
+      console.log(pc4.dim("  \uFF08\u672A\u83B7\u53D6\u5230\u504F\u597D\u4FE1\u606F\uFF0CAPI \u53EF\u80FD\u4E0D\u652F\u6301\u6B64\u7AEF\u70B9\uFF09"));
+    }
+    console.log("");
+    p4.outro("\u7528\u6237\u504F\u597D\u5982\u4E0A");
+  } catch (err) {
+    s2.stop("\u83B7\u53D6\u5931\u8D25");
+    p4.outro(pc4.red(`\u83B7\u53D6\u7528\u6237\u504F\u597D\u5931\u8D25: ${err.message}`));
+  }
+}
+function registerUserCommands(cli2) {
+  cli2.command("user-pref", "\u67E5\u770B\u7528\u6237\u504F\u597D\u8BBE\u7F6E").action(userPrefCommand);
+}
+// src/index.ts
+var SUBCOMMAND_GROUPS = ["task", "project", "user"];
+var argv = process.argv.slice(2);
+if (argv.length >= 2 && SUBCOMMAND_GROUPS.includes(argv[0]) && !argv[1].startsWith("-")) {
+  argv.splice(0, 2, `${argv[0]}-${argv[1]}`);
+}
+var cli = cac("tt");
+cli.command("login", "\u767B\u5F55\u6EF4\u7B54\u6E05\u5355").action(loginCommand);
+cli.command("logout", "\u767B\u51FA").action(logoutCommand);
+cli.command("whoami", "\u67E5\u770B\u767B\u5F55\u72B6\u6001").action(whoamiCommand);
+cli.command("config", "\u67E5\u770B/\u8BBE\u7F6E\u914D\u7F6E").option("--region <region>", "\u5207\u6362\u533A\u57DF: cn (\u56FD\u5185\u7248) / global (\u56FD\u9645\u7248)").action(async (options) => {
+  if (options.region && options.region !== "cn" && options.region !== "global") {
+    console.error(`\u65E0\u6548\u7684\u533A\u57DF: ${options.region}\uFF0C\u8BF7\u4F7F\u7528 cn \u6216 global`);
+    process.exit(1);
+  }
+  await configCommand({ region: options.region });
+});
+registerProjectCommands(cli);
+registerTaskCommands(cli);
+registerUserCommands(cli);
+cli.help();
+cli.parse(["", "", ...argv]);
+//# sourceMappingURL=index.js.map