maoda-commander-tt 0.0.23 → 0.0.26

package/dist/main.js

@@ -2609,9 +2609,72 @@ import { spawn as spawn3 } from "child_process";
 import * as fs5 from "fs/promises";
 import { homedir as homedir7 } from "os";
 import * as path6 from "path";
-var GENERATED_IMAGES_DIR = path6.join(homedir7(), ".codex", "generated_images");
+
+// src/bedrock/uuid/uuid.ts
+var generateUuid = (() => {
+  if (typeof crypto === "object" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID.bind(crypto);
+  }
+  let getRandomValues;
+  if (typeof crypto === "object" && typeof crypto.getRandomValues === "function") {
+    getRandomValues = crypto.getRandomValues.bind(crypto);
+  } else {
+    getRandomValues = function(bucket) {
+      for (let i = 0; i < bucket.length; i++) {
+        bucket[i] = Math.floor(Math.random() * 256);
+      }
+      return bucket;
+    };
+  }
+  const data = new Uint8Array(16);
+  const hex = [];
+  for (let i = 0; i < 256; i++) {
+    hex.push(i.toString(16).padStart(2, "0"));
+  }
+  return () => {
+    getRandomValues(data);
+    data[6] = data[6] & 15 | 64;
+    data[8] = data[8] & 63 | 128;
+    let i = 0;
+    let result = "";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += "-";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += "-";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += "-";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += "-";
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    result += hex[data[i++]];
+    return result;
+  };
+})();
+
+// src/commands/ai/ai-image-command-v2.ts
+var GENERATED_IMAGES_SUBDIR = "generated_imgs";
+var GENERATED_IMAGES_DIR = path6.join(
+  homedir7(),
+  ".codex",
+  GENERATED_IMAGES_SUBDIR
+);
+var GENERATED_IMAGES_PROMPT_DIR = `~/.codex/${GENERATED_IMAGES_SUBDIR}`;
+var LEGACY_GENERATED_IMAGES_DIR = path6.join(
+  homedir7(),
+  ".codex",
+  "generated_images"
+);
 var CODEX_EMPTY_WORKDIR = path6.join(homedir7(), ".codex-empty");
-var CREATED_AT_TOLERANCE_MS = 1e3;
 var AiImageCommandV2 = class extends AiBaseCommand {
   _meta() {
     return {
@@ -2631,13 +2694,14 @@ var AiImageCommandV2 = class extends AiBaseCommand {
       this._outputJsonError(1, "\u8BF7\u8F93\u5165\u751F\u56FE\u63D0\u793A\u8BCD");
       return this._makeOk();
     }
-    const startedAt = Date.now();
-    const runResult = await this._runCodexImagePrompt(prompt);
+    const uuid = generateUuid();
+    const imagePath = getGeneratedImagePath(uuid);
+    const runResult = await this._runCodexImagePrompt(prompt, uuid);
     if (!runResult.ok) {
       this._outputJsonError(runResult.code, runResult.msg);
       return this._makeOk();
     }
-    const imagePathResult = await findLatestGeneratedImageFile(startedAt);
+    const imagePathResult = await findGeneratedImageFile(imagePath);
     if (!imagePathResult.ok) {
       this._outputJsonError(imagePathResult.code, imagePathResult.msg);
       return this._makeOk();
@@ -2647,7 +2711,7 @@ var AiImageCommandV2 = class extends AiBaseCommand {
     });
     return this._makeOk();
   }
-  async _runCodexImagePrompt(prompt) {
+  async _runCodexImagePrompt(prompt, uuid) {
     try {
       await fs5.mkdir(CODEX_EMPTY_WORKDIR, { recursive: true });
     } catch (error) {
@@ -2657,8 +2721,19 @@ var AiImageCommandV2 = class extends AiBaseCommand {
         `\u521B\u5EFA codex \u7A7A\u5DE5\u4F5C\u76EE\u5F55\u5931\u8D25: ${CODEX_EMPTY_WORKDIR}: ${message}`
       );
     }
+    try {
+      await fs5.mkdir(GENERATED_IMAGES_DIR, { recursive: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      return this._makeError(
+        1,
+        `\u521B\u5EFA codex \u751F\u56FE\u8F93\u51FA\u76EE\u5F55\u5931\u8D25: ${GENERATED_IMAGES_DIR}: ${message}`
+      );
+    }
     const codexPrompt = `\u751F\u6210\u56FE\u7247(\u4F7F\u7528\u975ECLI\u6A21\u5F0F\u6765\u751F\u6210\uFF0C\u4F7F\u7528\u53EF\u652F\u6301\u7684\u9AD8\u753B\u8D28)\uFF0C\u5177\u4F53\u8981\u6C42\u5982\u4E0B: 
-  ${prompt}`;
+  ${prompt}
+
+<system-reminder>\u751F\u6210\u7ED3\u675F\u540E\u5C06\u751F\u6210\u7684\u56FE\u7247\u62F7\u8D1D\u5230\u6307\u5B9A\u8DEF\u5F84: \`${getGeneratedImagePromptPath(uuid)}\`\u3002</system-reminder>`;
     const args = [
       "exec",
       "-C",
@@ -2697,88 +2772,27 @@ var AiImageCommandV2 = class extends AiBaseCommand {
     });
   }
 };
-async function findLatestGeneratedImageFile(minCreatedAt) {
-  const latestDirectoryResult = await findLatestCreatedDirectory(
-    GENERATED_IMAGES_DIR,
-    minCreatedAt
-  );
-  if (!latestDirectoryResult.ok) {
-    return latestDirectoryResult;
-  }
-  return findLatestCreatedFile(latestDirectoryResult.value);
+function getGeneratedImagePath(uuid) {
+  return path6.join(GENERATED_IMAGES_DIR, `${uuid}.png`);
 }
-async function findLatestCreatedDirectory(directoryPath, minCreatedAt) {
-  const entriesResult = await readDirectoryEntries(directoryPath);
-  if (!entriesResult.ok) {
-    return entriesResult;
-  }
-  const directories = await collectCreatedEntries(
-    directoryPath,
-    entriesResult.value.filter((entry) => entry.isDirectory()).map((entry) => entry.name)
-  );
-  if (!directories.ok) {
-    return directories;
-  }
-  const latest = directories.value.filter(
-    (entry) => entry.createdAt >= minCreatedAt - CREATED_AT_TOLERANCE_MS
-  ).sort(compareCreatedEntryDesc)[0];
-  if (!latest) {
-    return makeErrorForPath(
-      1,
-      "\u672A\u627E\u5230\u672C\u6B21 codex \u751F\u56FE\u8F93\u51FA\u5B50\u76EE\u5F55",
-      directoryPath
-    );
-  }
-  return makeOkWith(latest.filePath);
+function getGeneratedImagePromptPath(uuid) {
+  return `${GENERATED_IMAGES_PROMPT_DIR}/${uuid}.png`;
 }
-async function findLatestCreatedFile(directoryPath) {
-  const entriesResult = await readDirectoryEntries(directoryPath);
-  if (!entriesResult.ok) {
-    return entriesResult;
-  }
-  const files = await collectCreatedEntries(
-    directoryPath,
-    entriesResult.value.filter((entry) => entry.isFile()).map((entry) => entry.name)
-  );
-  if (!files.ok) {
-    return files;
-  }
-  const latest = files.value.sort(compareCreatedEntryDesc)[0];
-  if (!latest) {
-    return makeErrorForPath(1, "\u6700\u65B0\u751F\u56FE\u8F93\u51FA\u76EE\u5F55\u4E2D\u672A\u627E\u5230\u6587\u4EF6", directoryPath);
-  }
-  return makeOkWith(path6.resolve(latest.filePath));
-}
-async function readDirectoryEntries(directoryPath) {
+async function findGeneratedImageFile(filePath) {
   try {
-    return makeOkWith(await fs5.readdir(directoryPath, { withFileTypes: true }));
+    const stats = await fs5.stat(filePath);
+    if (!stats.isFile()) {
+      return makeErrorForPath(1, "\u672C\u6B21 codex \u751F\u56FE\u8F93\u51FA\u8DEF\u5F84\u4E0D\u662F\u6587\u4EF6", filePath);
+    }
+    return makeOkWith(path6.resolve(filePath));
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    return makeErrorForPath(1, `\u8BFB\u53D6\u76EE\u5F55\u5931\u8D25: ${message}`, directoryPath);
-  }
-}
-async function collectCreatedEntries(parentPath, names) {
-  const entries = [];
-  for (const name of names) {
-    const filePath = path6.join(parentPath, name);
-    try {
-      const stats = await fs5.stat(filePath);
-      entries.push({
-        filePath,
-        createdAt: getCreatedAt(stats)
-      });
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      return makeErrorForPath(1, `\u8BFB\u53D6\u8DEF\u5F84\u72B6\u6001\u5931\u8D25: ${message}`, filePath);
-    }
+    return makeErrorForPath(
+      1,
+      `\u672A\u627E\u5230\u672C\u6B21 codex \u751F\u56FE\u8F93\u51FA\u6587\u4EF6: ${message}`,
+      filePath
+    );
   }
-  return makeOkWith(entries);
-}
-function getCreatedAt(stats) {
-  return stats.birthtimeMs || stats.ctimeMs || stats.mtimeMs;
-}
-function compareCreatedEntryDesc(a, b) {
-  return b.createdAt - a.createdAt || b.filePath.localeCompare(a.filePath);
 }
 function makeErrorForPath(code, message, filePath) {
   return makeError(code, `${message}: ${filePath}`);
@@ -2788,57 +2802,6 @@ function makeErrorForPath(code, message, filePath) {
 import * as path7 from "path";
 import { Option as Option8 } from "commander";
 
-// src/bedrock/uuid/uuid.ts
-var generateUuid = (() => {
-  if (typeof crypto === "object" && typeof crypto.randomUUID === "function") {
-    return crypto.randomUUID.bind(crypto);
-  }
-  let getRandomValues;
-  if (typeof crypto === "object" && typeof crypto.getRandomValues === "function") {
-    getRandomValues = crypto.getRandomValues.bind(crypto);
-  } else {
-    getRandomValues = function(bucket) {
-      for (let i = 0; i < bucket.length; i++) {
-        bucket[i] = Math.floor(Math.random() * 256);
-      }
-      return bucket;
-    };
-  }
-  const data = new Uint8Array(16);
-  const hex = [];
-  for (let i = 0; i < 256; i++) {
-    hex.push(i.toString(16).padStart(2, "0"));
-  }
-  return () => {
-    getRandomValues(data);
-    data[6] = data[6] & 15 | 64;
-    data[8] = data[8] & 63 | 128;
-    let i = 0;
-    let result = "";
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += "-";
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += "-";
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += "-";
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += "-";
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    result += hex[data[i++]];
-    return result;
-  };
-})();
-
 // src/commands/pippit/modules/submit-direct/submit-direct-cn.ts
 var SUBMIT_DIRECT_URL = "https://xyq.jianying.com/api/biz/v1/agent/submit_run";
 function normalizeToken5(token) {
@@ -4096,6 +4059,213 @@ function compareCanvasMatches(a, b) {
   return a.nodeIndex - b.nodeIndex;
 }
 
+// src/commands/tool/tool-draw-command.ts
+var ToolDrawCommand = class extends BaseCommand {
+  _meta() {
+    return {
+      name: "draw",
+      description: "\u6309\u6982\u7387\u5206\u5E03\u62BD\u7B7E"
+    };
+  }
+  _configureArguments(cmd) {
+    cmd.argument("<count>", "\u8981\u62BD\u53D6\u7684\u4E2A\u6570");
+    cmd.argument("<distribution...>", "\u6982\u7387\u5206\u5E03\uFF0C\u652F\u6301\u7B80\u5199\u6216 JSON \u6570\u7EC4");
+    cmd.addHelpText(
+      "after",
+      [
+        "",
+        "\u8F93\u5165\u6848\u4F8B:",
+        '  tt tool draw 3 "A A:50,B B:30,C C:20"',
+        `  tt tool draw 3 '[{"name":"\u4E2D\u56FD \u6210\u90FD","weight":50},{"name":"Los Angeles","weight":50}]'`
+      ].join("\n")
+    );
+  }
+  async _execute(ctx) {
+    const countResult = parseCount(ctx.args[0]);
+    if (!countResult.ok) {
+      return this._makeError(1, countResult.msg);
+    }
+    const distributionText = stringifyDistributionArg(ctx.args[1]);
+    if (!distributionText) {
+      return this._makeError(1, "\u6982\u7387\u5206\u5E03\u4E0D\u80FD\u4E3A\u7A7A");
+    }
+    const distributionResult = parseDistribution(distributionText);
+    if (!distributionResult.ok) {
+      return this._makeError(1, distributionResult.msg);
+    }
+    this._outputJson({
+      items: drawWeightedItems(countResult.value, distributionResult.value)
+    });
+    return this._makeOk();
+  }
+  _outputJson(data) {
+    this._output(JSON.stringify(data, null, 2));
+  }
+};
+function parseCount(value) {
+  const count = Number(String(value ?? "").trim());
+  if (!Number.isInteger(count) || count <= 0) {
+    return { ok: false, msg: "\u62BD\u53D6\u4E2A\u6570\u5FC5\u987B\u662F\u6B63\u6574\u6570" };
+  }
+  return { ok: true, value: count };
+}
+function stringifyDistributionArg(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => String(item)).join(" ").trim();
+  }
+  return String(value ?? "").trim();
+}
+function parseDistribution(value) {
+  if (value.trimStart().startsWith("[")) {
+    return parseJsonDistribution(value);
+  }
+  return parseShorthandDistribution(value);
+}
+function parseJsonDistribution(value) {
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { ok: false, msg: `JSON \u6982\u7387\u5206\u5E03\u89E3\u6790\u5931\u8D25: ${msg}` };
+  }
+  if (!Array.isArray(parsed)) {
+    return { ok: false, msg: "JSON \u6982\u7387\u5206\u5E03\u5FC5\u987B\u662F\u6570\u7EC4" };
+  }
+  const entries = [];
+  for (let index = 0; index < parsed.length; index += 1) {
+    const entryResult = parseJsonDistributionEntry(parsed[index], index);
+    if (!entryResult.ok) {
+      return entryResult;
+    }
+    entries.push(entryResult.value);
+  }
+  return validateDistribution(entries);
+}
+function parseJsonDistributionEntry(value, index) {
+  const record = asRecord2(value);
+  if (!record) {
+    return { ok: false, msg: `\u7B2C ${index + 1} \u9879\u5FC5\u987B\u662F\u5BF9\u8C61` };
+  }
+  const nameResult = parseEntryName(record.name, `\u7B2C ${index + 1} \u9879`);
+  if (!nameResult.ok) {
+    return nameResult;
+  }
+  const weightResult = parseWeight(
+    getJsonWeightValue(record),
+    `\u7B2C ${index + 1} \u9879`
+  );
+  if (!weightResult.ok) {
+    return weightResult;
+  }
+  return {
+    ok: true,
+    value: {
+      name: nameResult.value,
+      weight: weightResult.value
+    }
+  };
+}
+function getJsonWeightValue(record) {
+  if ("weight" in record) {
+    return record.weight;
+  }
+  if ("probability" in record) {
+    return record.probability;
+  }
+  if ("prob" in record) {
+    return record.prob;
+  }
+  return record.p;
+}
+function parseShorthandDistribution(value) {
+  const parts = value.split(/[,，]/);
+  const entries = [];
+  for (let index = 0; index < parts.length; index += 1) {
+    const part = parts[index].trim();
+    if (!part) {
+      return { ok: false, msg: `\u7B2C ${index + 1} \u9879\u4E3A\u7A7A` };
+    }
+    const separatorIndex = findLastWeightSeparator(part);
+    if (separatorIndex < 0) {
+      return {
+        ok: false,
+        msg: `\u7B2C ${index + 1} \u9879\u7F3A\u5C11\u6982\u7387\u5206\u9694\u7B26 ":"`
+      };
+    }
+    const nameResult = parseEntryName(
+      part.slice(0, separatorIndex),
+      `\u7B2C ${index + 1} \u9879`
+    );
+    if (!nameResult.ok) {
+      return nameResult;
+    }
+    const weightResult = parseWeight(
+      part.slice(separatorIndex + 1),
+      `\u7B2C ${index + 1} \u9879`
+    );
+    if (!weightResult.ok) {
+      return weightResult;
+    }
+    entries.push({
+      name: nameResult.value,
+      weight: weightResult.value
+    });
+  }
+  return validateDistribution(entries);
+}
+function findLastWeightSeparator(value) {
+  return Math.max(value.lastIndexOf(":"), value.lastIndexOf("\uFF1A"));
+}
+function parseEntryName(value, label) {
+  if (typeof value !== "string") {
+    return { ok: false, msg: `${label}\u7684\u540D\u79F0\u5FC5\u987B\u662F\u5B57\u7B26\u4E32` };
+  }
+  const name = value.trim();
+  if (!name) {
+    return { ok: false, msg: `${label}\u7684\u540D\u79F0\u4E0D\u80FD\u4E3A\u7A7A` };
+  }
+  return { ok: true, value: name };
+}
+function parseWeight(value, label) {
+  const rawValue = typeof value === "string" ? value.trim().replace(/[％%]$/, "") : value;
+  const weight = Number(rawValue);
+  if (!Number.isFinite(weight) || weight <= 0) {
+    return { ok: false, msg: `${label}\u7684\u6982\u7387\u5FC5\u987B\u662F\u5927\u4E8E 0 \u7684\u6570\u5B57` };
+  }
+  return { ok: true, value: weight };
+}
+function validateDistribution(entries) {
+  if (entries.length === 0) {
+    return { ok: false, msg: "\u6982\u7387\u5206\u5E03\u81F3\u5C11\u9700\u8981 1 \u9879" };
+  }
+  return { ok: true, value: entries };
+}
+function drawWeightedItems(count, entries) {
+  const totalWeight = entries.reduce((sum, entry) => sum + entry.weight, 0);
+  const items = [];
+  for (let index = 0; index < count; index += 1) {
+    items.push(drawWeightedItem(entries, totalWeight));
+  }
+  return items;
+}
+function drawWeightedItem(entries, totalWeight) {
+  let cursor = Math.random() * totalWeight;
+  for (const entry of entries) {
+    cursor -= entry.weight;
+    if (cursor < 0) {
+      return entry.name;
+    }
+  }
+  return entries[entries.length - 1].name;
+}
+function asRecord2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+
 // src/commands/tool/tool-command.ts
 var ToolCommand = class extends BaseSubcommandHost {
   _meta() {
@@ -4106,6 +4276,7 @@ var ToolCommand = class extends BaseSubcommandHost {
   }
   _registerSubcommands() {
     this._addSubcommand(new ToolCanvasCommand());
+    this._addSubcommand(new ToolDrawCommand());
   }
 };