maoda-commander-tt 0.0.20 → 0.0.22

package/dist/main.js

@@ -2078,9 +2078,9 @@ var ShortcutBaseCommand = class extends BaseCommand {
       stdio: "inherit",
       shell: true
     });
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       child.on("error", (error) => {
-        resolve8(
+        resolve9(
           this._makeError(
             1,
             `\u6267\u884C ${cmdLine} \u5931\u8D25: ${error.message}`
@@ -2089,11 +2089,11 @@ var ShortcutBaseCommand = class extends BaseCommand {
       });
       child.on("close", (code, signal) => {
         if (code === 0) {
-          resolve8(this._makeOk());
+          resolve9(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve8(
+        resolve9(
           this._makeError(
             code ?? 1,
             `\u6267\u884C ${cmdLine} \u5931\u8D25${signalText}`
@@ -2188,9 +2188,9 @@ var AiBaseCommand = class extends BaseCommand {
       cwd: process.cwd(),
       stdio: "inherit"
     });
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       child.on("error", (error) => {
-        resolve8(
+        resolve9(
           this._makeError(
             1,
             `\u6267\u884C ${command} ${args.join(" ")} \u5931\u8D25: ${error.message}`
@@ -2199,11 +2199,11 @@ var AiBaseCommand = class extends BaseCommand {
       });
       child.on("close", (code, signal) => {
         if (code === 0) {
-          resolve8(this._makeOk());
+          resolve9(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve8(
+        resolve9(
           this._makeError(
             code ?? 1,
             `\u6267\u884C ${command} ${args.join(" ")} \u5931\u8D25${signalText}`
@@ -2508,7 +2508,7 @@ var AiImageCommandV2 = class extends AiBaseCommand {
         `\u521B\u5EFA codex \u7A7A\u5DE5\u4F5C\u76EE\u5F55\u5931\u8D25: ${CODEX_EMPTY_WORKDIR}: ${message}`
       );
     }
-    const codexPrompt = `\u751F\u6210\u56FE\u7247
+    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}`;
     const args = [
       "exec",
@@ -2523,9 +2523,9 @@ var AiImageCommandV2 = class extends AiBaseCommand {
       cwd: process.cwd(),
       stdio: "ignore"
     });
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       child.on("error", (error) => {
-        resolve8(
+        resolve9(
           this._makeError(
             1,
             `\u6267\u884C codex ${args.join(" ")} \u5931\u8D25: ${error.message}`
@@ -2534,11 +2534,11 @@ var AiImageCommandV2 = class extends AiBaseCommand {
       });
       child.on("close", (code, signal) => {
         if (code === 0) {
-          resolve8(this._makeOk());
+          resolve9(this._makeOk());
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
-        resolve8(
+        resolve9(
           this._makeError(
             code ?? 1,
             `\u6267\u884C codex ${args.join(" ")} \u5931\u8D25${signalText}`
@@ -3430,7 +3430,7 @@ function extractErrorText(payload) {
   return void 0;
 }
 function delay(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 async function appendPollingUrl(pollingUrl, generationId) {
   const locationResult = await resolveConfigLocation();
@@ -3631,7 +3631,7 @@ var AiQueryTaskCommand = class extends AiBaseCommand {
       PPE_ENV,
       "--json"
     ];
-    return new Promise((resolve8) => {
+    return new Promise((resolve9) => {
       const child = spawn4(BIN, args, { cwd: process.cwd() });
       let stdout = "";
       let stderr = "";
@@ -3642,7 +3642,7 @@ var AiQueryTaskCommand = class extends AiBaseCommand {
         stderr += chunk.toString();
       });
       child.on("error", (error) => {
-        resolve8(
+        resolve9(
           makeError(
             1,
             `\u6267\u884C ${BIN} ${args.join(" ")} \u5931\u8D25: ${error.message}`
@@ -3651,13 +3651,13 @@ var AiQueryTaskCommand = class extends AiBaseCommand {
       });
       child.on("close", (code, signal) => {
         if (code === 0) {
-          resolve8(makeOkWith({ stdout, stderr }));
+          resolve9(makeOkWith({ stdout, stderr }));
           return;
         }
         const signalText = signal ? `, signal: ${signal}` : "";
         const stderrText = stderr.trim() ? `
 ${stderr.trim()}` : "";
-        resolve8(
+        resolve9(
           makeError(
             code ?? 1,
             `\u6267\u884C ${BIN} ${args.join(" ")} \u5931\u8D25${signalText}${stderrText}`
@@ -3697,7 +3697,7 @@ function tryParseJson(text) {
   }
 }
 function delay2(ms) {
-  return new Promise((resolve8) => setTimeout(resolve8, ms));
+  return new Promise((resolve9) => setTimeout(resolve9, ms));
 }
 
 // src/commands/ai/ai-command.ts
@@ -3720,6 +3720,246 @@ var AiCommand = class extends BaseSubcommandHost {
   }
 };
 
+// src/commands/tool/tool-canvas-command.ts
+import { readdir as readdir2, readFile as readFile4, stat as stat4 } from "fs/promises";
+import { homedir as homedir8 } from "os";
+import { join as join12, resolve as resolve8 } from "path";
+var MINIMAX_DIR_LIST = ["~/Movies/Hub/Projects/"];
+var CANVAS_JSON_RELATIVE_PATH = join12(".hilo", "canvas.json");
+var EMPTY_NODE_ID_PREFIX = "empty";
+var MARKER_PREFIX = "==";
+var ToolCanvasCommand = class extends BaseCommand {
+  _meta() {
+    return {
+      name: "canvas",
+      description: "\u67E5\u627E Minimax canvas \u7A7A\u8349\u7A3F\u8282\u70B9"
+    };
+  }
+  _configureArguments(cmd) {
+    cmd.argument("[keyword]", "\u53EF\u9009\uFF1A\u8FC7\u6EE4 prompt \u4E2D\u7684 == \u540E\u7F00");
+  }
+  async _execute(ctx) {
+    const keyword = String(ctx.args[0] ?? "").trim();
+    const result = await findLatestCanvasDraft(keyword);
+    if (!result) {
+      const marker = keyword ? `${MARKER_PREFIX}${keyword}` : MARKER_PREFIX;
+      return this._makeError(1, `\u672A\u627E\u5230\u5305\u542B ${marker} \u7684\u7A7A\u8349\u7A3F node`);
+    }
+    this._outputJson({
+      basePath: result.basePath,
+      type: result.type,
+      prompt: result.prompt
+    });
+    return this._makeOk();
+  }
+  _outputJson(data) {
+    this._output(JSON.stringify(data, null, 2));
+  }
+};
+async function findLatestCanvasDraft(keyword) {
+  const markerRegExp = createMarkerRegExp(keyword);
+  const matches = [];
+  for (const rawDir of MINIMAX_DIR_LIST) {
+    const rootDir = expandHomeDir(rawDir);
+    const rootStat = await safeStat(rootDir);
+    if (!rootStat?.isDirectory()) {
+      continue;
+    }
+    const projectEntries = await readdir2(rootDir, { withFileTypes: true });
+    for (const projectEntry of projectEntries) {
+      if (!projectEntry.isDirectory()) {
+        continue;
+      }
+      const projectDir = resolve8(rootDir, projectEntry.name);
+      const canvasPath = join12(projectDir, CANVAS_JSON_RELATIVE_PATH);
+      const canvasStat = await safeStat(canvasPath);
+      if (!canvasStat?.isFile()) {
+        continue;
+      }
+      const projectMatches = await collectMatchesFromCanvas({
+        projectDir,
+        canvasPath,
+        canvasStat,
+        markerRegExp
+      });
+      matches.push(...projectMatches);
+    }
+  }
+  matches.sort(compareCanvasMatches);
+  return matches[0];
+}
+async function collectMatchesFromCanvas(options) {
+  const { projectDir, canvasPath, canvasStat, markerRegExp } = options;
+  const canvasJson = await readJsonFile(canvasPath);
+  const canvas = asRecord(canvasJson);
+  const nodes = Array.isArray(canvas?.nodes) ? canvas.nodes : [];
+  const matches = [];
+  nodes.forEach((node, nodeIndex) => {
+    const payload = getDraftPayload(node);
+    if (!payload || !markerRegExp.test(payload.prompt)) {
+      return;
+    }
+    const promptParts = parsePromptJson(payload.promptJson);
+    if (!promptParts) {
+      return;
+    }
+    const prompt = stringifyPromptParts(promptParts);
+    matches.push({
+      basePath: projectDir,
+      type: payload.type,
+      prompt: removeMarkerLine(prompt, markerRegExp),
+      canvasPath,
+      updatedAtMs: canvasStat.mtimeMs,
+      nodeIndex
+    });
+  });
+  return matches;
+}
+function createMarkerRegExp(keyword) {
+  const marker = `${MARKER_PREFIX}${keyword}`;
+  return new RegExp(escapeRegExp(marker));
+}
+function removeMarkerLine(prompt, markerRegExp) {
+  return prompt.split(/\r?\n/).filter((line) => !markerRegExp.test(line)).join("\n");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getDraftPayload(node) {
+  const nodeRecord = asRecord(node);
+  if (!nodeRecord) {
+    return void 0;
+  }
+  const type = nodeRecord.type;
+  if (type !== "image" && type !== "video") {
+    return void 0;
+  }
+  const id = nodeRecord.id;
+  if (typeof id !== "string" || !id.startsWith(EMPTY_NODE_ID_PREFIX)) {
+    return void 0;
+  }
+  const data = asRecord(nodeRecord.data);
+  const popoverDraft = asRecord(data?.popoverDraft);
+  if (!popoverDraft) {
+    return void 0;
+  }
+  const payload = asRecord(
+    type === "image" ? popoverDraft.i2i : popoverDraft.i2v
+  );
+  if (!payload) {
+    return void 0;
+  }
+  const prompt = payload.prompt;
+  if (typeof prompt !== "string") {
+    return void 0;
+  }
+  return {
+    type,
+    prompt,
+    promptJson: payload.promptJson
+  };
+}
+function parsePromptJson(value) {
+  const parsed = parsePromptJsonValue(value);
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  const parsedRecord = asRecord(parsed);
+  const content = parsedRecord?.content;
+  return Array.isArray(content) ? content : void 0;
+}
+function parsePromptJsonValue(value) {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function stringifyPromptParts(parts) {
+  return parts.map((part) => stringifyPromptPart(part)).join("");
+}
+function stringifyPromptPart(part) {
+  const partRecord = asRecord(part);
+  if (!partRecord) {
+    return "";
+  }
+  const type = partRecord.type;
+  if (type === "text") {
+    const text = partRecord.text;
+    return typeof text === "string" ? text : "";
+  }
+  if (type === "hardBreak") {
+    return "\n";
+  }
+  if (type === "canvasFileRef") {
+    const attrs = asRecord(partRecord.attrs);
+    const filename = attrs?.filename;
+    return typeof filename === "string" ? ` ${filename} ` : "";
+  }
+  const content = partRecord.content;
+  if (Array.isArray(content)) {
+    return stringifyPromptParts(content);
+  }
+  return "";
+}
+async function readJsonFile(filePath) {
+  try {
+    const content = await readFile4(filePath, "utf8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+async function safeStat(path10) {
+  try {
+    return await stat4(path10);
+  } catch {
+    return void 0;
+  }
+}
+function expandHomeDir(path10) {
+  if (path10 === "~") {
+    return homedir8();
+  }
+  if (path10.startsWith("~/")) {
+    return join12(homedir8(), path10.slice(2));
+  }
+  return resolve8(path10);
+}
+function asRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function compareCanvasMatches(a, b) {
+  const updatedAtDiff = b.updatedAtMs - a.updatedAtMs;
+  if (updatedAtDiff !== 0) {
+    return updatedAtDiff;
+  }
+  const canvasPathDiff = a.canvasPath.localeCompare(b.canvasPath);
+  if (canvasPathDiff !== 0) {
+    return canvasPathDiff;
+  }
+  return a.nodeIndex - b.nodeIndex;
+}
+
+// src/commands/tool/tool-command.ts
+var ToolCommand = class extends BaseSubcommandHost {
+  _meta() {
+    return {
+      name: "tool",
+      description: "\u5E38\u7528\u5DE5\u5177\u547D\u4EE4"
+    };
+  }
+  _registerSubcommands() {
+    this._addSubcommand(new ToolCanvasCommand());
+  }
+};
+
 // src/main.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
@@ -3735,6 +3975,7 @@ async function bootstrap() {
   app.registerCommand(new GitCommand(), { hidden: true });
   app.registerCommand(new ShortcutCommand(), { hidden: true });
   app.registerCommand(new AiCommand(), { hidden: true });
+  app.registerCommand(new ToolCommand(), { hidden: true });
   const result = await app.run();
   if (!result.ok) {
     process.stderr.write(`Fatal: ${result.msg}