@jixo/cli 0.13.0 → 0.20.0

package/dist/commands/tasks/ai-tools.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-tools.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/ai-tools.ts"],"names":[],"mappings":"AACA,OAAO,EAAwD,KAAK,OAAO,EAAC,MAAM,IAAI,CAAC;AAEvF,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,kCAAkC,CAAC;AAE7D,eAAO,MAAM,KAAK;sBAGD,MAAM;8BAeM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAmDjB,MAAM;oBAkBH,MAAM;;;;;;;;;;;;CAgD1B,CAAC"}

package/dist/commands/tasks/ai-tools.js

@@ -1,140 +0,0 @@
-import { func_lazy, func_remember, map_get_or_put_async } from "@gaubee/util";
-import { experimental_createMCPClient as createMCPClient, tool } from "ai";
-import { Experimental_StdioMCPTransport } from "ai/mcp-stdio";
-import z from "zod";
-import { getAllPromptConfigs, getAllSkillMap } from "../../helper/prompts-loader.js";
-export const tools = {
-    fileSystem: func_lazy(() => {
-        const map = new Map();
-        return (cwd) => {
-            return map_get_or_put_async(map, cwd, async () => {
-                const mcpClient = await createMCPClient({
-                    transport: new Experimental_StdioMCPTransport({
-                        command: "pnpm",
-                        args: ["mcp-fs", cwd],
-                    }),
-                });
-                const tools = await mcpClient.tools();
-                return tools;
-            });
-        };
-    }),
-    memory: func_lazy(() => {
-        const map = new Map();
-        return (memory_filepath) => {
-            return map_get_or_put_async(map, memory_filepath, async () => {
-                const mcpClient = await createMCPClient({
-                    transport: new Experimental_StdioMCPTransport({
-                        command: "pnpx",
-                        args: ["@modelcontextprotocol/server-memory"],
-                        env: {
-                            MEMORY_FILE_PATH: memory_filepath,
-                        },
-                    }),
-                });
-                const tools = await mcpClient.tools();
-                return tools;
-            });
-        };
-    }),
-    pnpm: func_remember(async () => {
-        const mcpClient = await createMCPClient({
-            transport: new Experimental_StdioMCPTransport({
-                // command: "pnpx",
-                // args: ["@jixo/mcp-pnpm"],
-                command: "pnpm",
-                args: ["mcp-pnpm"],
-            }),
-        });
-        const tools = await mcpClient.tools();
-        return tools;
-    }),
-    sequentialThinking: func_remember(async () => {
-        const mcpClient = await createMCPClient({
-            transport: new Experimental_StdioMCPTransport({
-                command: "pnpx",
-                args: ["@modelcontextprotocol/server-sequential-thinking"],
-            }),
-        });
-        const tools = await mcpClient.tools();
-        return tools;
-    }),
-    fetch: func_remember(async () => {
-        const mcpClient = await createMCPClient({
-            transport: new Experimental_StdioMCPTransport({
-                command: "uvx",
-                args: ["mcp-server-fetch"],
-            }),
-        });
-        const tools = await mcpClient.tools();
-        return tools;
-    }),
-    git: func_lazy(() => {
-        const map = new Map();
-        return (repo) => {
-            return map_get_or_put_async(map, repo, async () => {
-                const mcpClient = await createMCPClient({
-                    transport: new Experimental_StdioMCPTransport({
-                        command: "uvx",
-                        args: ["mcp-server-git", "--repository", repo],
-                    }),
-                });
-                const tools = await mcpClient.tools();
-                return tools;
-            });
-        };
-    }),
-    jixo: func_lazy(() => {
-        // const map = new Map<string, ToolSet>();
-        const configs = getAllPromptConfigs();
-        const allSkillMap = getAllSkillMap();
-        return (ai_task) => {
-            return {
-                get_jixo_skill: tool({
-                    description: "Get the JIXO skill prompt by name",
-                    parameters: z.object({
-                        name: z.string().describe("The name to get the skill for"),
-                    }),
-                    execute: async ({ name }) => {
-                        if (name in allSkillMap) {
-                            return Reflect.get(configs, name);
-                        }
-                        return { type: "error", message: "Skill not found" };
-                    },
-                }),
-                ...(() => {
-                    // TODO:  use process shared lock-manager
-                    return {
-                        jixo_log_lock: tool({
-                            description: "Lock the log file for writing, will return log file content",
-                            parameters: z.object({}),
-                            execute: async () => {
-                                ai_task.reloadLog();
-                                return { type: "success", filepath: ai_task.log.filepath, content: ai_task.log.content };
-                            },
-                        }),
-                        jixo_log_unlock: tool({
-                            description: "Unlock the log file, for other locker can read the log file and then write.",
-                            parameters: z.object({}),
-                            execute: async () => {
-                                return { type: "success" };
-                            },
-                        }),
-                        jixo_tasks_exit: tool({
-                            description: "Exit the tasks.",
-                            parameters: z.object({
-                                code: z.number({ description: "Exit code: 0 is Success; 1 is Error; 2 is No Tasks" }),
-                                reason: z.string({ description: "Exit reasons that provide human-readable information" }),
-                            }),
-                            execute: async ({ code, reason }) => {
-                                ai_task.exit(code, reason);
-                                return { type: "success" };
-                            },
-                        }),
-                    };
-                })(),
-            };
-        };
-    }),
-};
-//# sourceMappingURL=ai-tools.js.map

package/dist/commands/tasks/ai-tools.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ai-tools.js","sourceRoot":"","sources":["../../../src/commands/tasks/ai-tools.ts"],"names":[],"mappings":"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","sourcesContent":["import {func_lazy, func_remember, map_get_or_put_async} from \"@gaubee/util\";\nimport {experimental_createMCPClient as createMCPClient, tool, type ToolSet} from \"ai\";\nimport {Experimental_StdioMCPTransport} from \"ai/mcp-stdio\";\nimport z from \"zod\";\nimport {getAllPromptConfigs, getAllSkillMap} from \"../../helper/prompts-loader.js\";\nimport type {AiTask} from \"../../helper/resolve-ai-tasks.js\";\n\nexport const tools = {\n  fileSystem: func_lazy(() => {\n    const map = new Map<string, ToolSet>();\n    return (cwd: string) => {\n      return map_get_or_put_async(map, cwd, async () => {\n        const mcpClient = await createMCPClient({\n          transport: new Experimental_StdioMCPTransport({\n            command: \"pnpm\",\n            args: [\"mcp-fs\", cwd],\n          }),\n        });\n        const tools = await mcpClient.tools();\n        return tools;\n      });\n    };\n  }),\n  memory: func_lazy(() => {\n    const map = new Map<string, ToolSet>();\n    return (memory_filepath: string) => {\n      return map_get_or_put_async(map, memory_filepath, async () => {\n        const mcpClient = await createMCPClient({\n          transport: new Experimental_StdioMCPTransport({\n            command: \"pnpx\",\n            args: [\"@modelcontextprotocol/server-memory\"],\n            env: {\n              MEMORY_FILE_PATH: memory_filepath,\n            },\n          }),\n        });\n        const tools = await mcpClient.tools();\n        return tools;\n      });\n    };\n  }),\n  pnpm: func_remember(async () => {\n    const mcpClient = await createMCPClient({\n      transport: new Experimental_StdioMCPTransport({\n        // command: \"pnpx\",\n        // args: [\"@jixo/mcp-pnpm\"],\n        command: \"pnpm\",\n        args: [\"mcp-pnpm\"],\n      }),\n    });\n    const tools = await mcpClient.tools();\n    return tools;\n  }),\n  sequentialThinking: func_remember(async () => {\n    const mcpClient = await createMCPClient({\n      transport: new Experimental_StdioMCPTransport({\n        command: \"pnpx\",\n        args: [\"@modelcontextprotocol/server-sequential-thinking\"],\n      }),\n    });\n    const tools = await mcpClient.tools();\n    return tools;\n  }),\n  fetch: func_remember(async () => {\n    const mcpClient = await createMCPClient({\n      transport: new Experimental_StdioMCPTransport({\n        command: \"uvx\",\n        args: [\"mcp-server-fetch\"],\n      }),\n    });\n    const tools = await mcpClient.tools();\n    return tools;\n  }),\n  git: func_lazy(() => {\n    const map = new Map<string, ToolSet>();\n\n    return (repo: string) => {\n      return map_get_or_put_async(map, repo, async () => {\n        const mcpClient = await createMCPClient({\n          transport: new Experimental_StdioMCPTransport({\n            command: \"uvx\",\n            args: [\"mcp-server-git\", \"--repository\", repo],\n          }),\n        });\n        const tools = await mcpClient.tools();\n        return tools;\n      });\n    };\n  }),\n\n  jixo: func_lazy(() => {\n    // const map = new Map<string, ToolSet>();\n    const configs = getAllPromptConfigs();\n    const allSkillMap = getAllSkillMap();\n    return (ai_task: AiTask) => {\n      return {\n        get_jixo_skill: tool({\n          description: \"Get the JIXO skill prompt by name\",\n          parameters: z.object({\n            name: z.string().describe(\"The name to get the skill for\"),\n          }),\n          execute: async ({name}) => {\n            if (name in allSkillMap) {\n              return Reflect.get(configs, name);\n            }\n            return {type: \"error\", message: \"Skill not found\"};\n          },\n        }),\n        ...(() => {\n          // TODO:  use process shared lock-manager\n          return {\n            jixo_log_lock: tool({\n              description: \"Lock the log file for writing, will return log file content\",\n              parameters: z.object({}),\n              execute: async () => {\n                ai_task.reloadLog();\n                return {type: \"success\", filepath: ai_task.log.filepath, content: ai_task.log.content};\n              },\n            }),\n            jixo_log_unlock: tool({\n              description: \"Unlock the log file, for other locker can read the log file and then write.\",\n              parameters: z.object({}),\n              execute: async () => {\n                return {type: \"success\"};\n              },\n            }),\n            jixo_tasks_exit: tool({\n              description: \"Exit the tasks.\",\n              parameters: z.object({\n                code: z.number({description: \"Exit code: 0 is Success; 1 is Error; 2 is No Tasks\"}),\n                reason: z.string({description: \"Exit reasons that provide human-readable information\"}),\n              }),\n              execute: async ({code, reason}) => {\n                ai_task.exit(code, reason);\n                return {type: \"success\"};\n              },\n            }),\n          };\n        })(),\n      };\n    };\n  }),\n};\n"]}

package/dist/commands/tasks/model-providers.d.ts

@@ -1,13 +0,0 @@
-import { type OpenAIProvider } from "@ai-sdk/openai";
-export declare const providers: {
-    readonly deepseek: import("@ai-sdk/deepseek").DeepSeekProvider;
-    readonly anthropic: import("@ai-sdk/anthropic").AnthropicProvider;
-    readonly google: import("@ai-sdk/google").GoogleGenerativeAIProvider;
-    readonly openai: OpenAIProvider;
-    readonly xai: import("@ai-sdk/xai").XaiProvider;
-    readonly deepinfra: import("@ai-sdk/deepinfra").DeepInfraProvider;
-};
-type LanguageModelV2 = ReturnType<OpenAIProvider>;
-export declare const getModel: (model?: string) => LanguageModelV2;
-export {};
-//# sourceMappingURL=model-providers.d.ts.map

package/dist/commands/tasks/model-providers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-providers.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/model-providers.ts"],"names":[],"mappings":"AAIA,OAAO,EAAe,KAAK,cAAc,EAAC,MAAM,gBAAgB,CAAC;AAOjE,eAAO,MAAM,SAAS;;;;;;;CA2CpB,CAAC;AAEH,KAAK,eAAe,GAAG,UAAU,CAAC,cAAc,CAAC,CAAC;AAClD,eAAO,MAAM,QAAQ,GAAI,QAAQ,MAAM,KAAG,eA6BzC,CAAC"}

package/dist/commands/tasks/model-providers.js

@@ -1,84 +0,0 @@
-import { createAnthropic } from "@ai-sdk/anthropic";
-import { createDeepInfra } from "@ai-sdk/deepinfra";
-import { createDeepSeek } from "@ai-sdk/deepseek";
-import { createGoogleGenerativeAI } from "@ai-sdk/google";
-import { createOpenAI } from "@ai-sdk/openai";
-import { createXai } from "@ai-sdk/xai";
-import { obj_lazify } from "@gaubee/util";
-import { match, P } from "ts-pattern";
-import { safeEnv } from "../../env.js";
-// const wrapper = (provider:)
-export const providers = obj_lazify({
-    get deepseek() {
-        return createDeepSeek({
-            baseURL: safeEnv.JIXO_DEEPSEEK_BASE_URL || undefined,
-            apiKey: safeEnv.JIXO_DEEPSEEK_API_KEY,
-        });
-    },
-    get anthropic() {
-        // const bashTool = anthropic.tools.bash_20250124({
-        //   execute: async ({command, restart}) => execSync(command).toString(),
-        // });
-        const provider = createAnthropic({
-            baseURL: safeEnv.JIXO_ANTHROPIC_BASE_URL || undefined,
-            apiKey: safeEnv.JIXO_ANTHROPIC_API_KEY,
-        });
-        return provider;
-    },
-    get google() {
-        return createGoogleGenerativeAI({
-            baseURL: safeEnv.JIXO_GOOGLE_BASE_URL || undefined,
-            apiKey: safeEnv.JIXO_GOOGLE_API_KEY,
-        });
-    },
-    get openai() {
-        return createOpenAI({
-            baseURL: safeEnv.JIXO_OPENAI_BASE_URL || undefined,
-            apiKey: safeEnv.JIXO_OPENAI_API_KEY,
-            organization: safeEnv.JIXO_OPENAI_ORGANIZATION || undefined,
-        });
-    },
-    get xai() {
-        return createXai({
-            baseURL: safeEnv.JIXO_XAI_BASE_URL || undefined,
-            apiKey: safeEnv.JIXO_XAI_API_KEY,
-        });
-    },
-    get deepinfra() {
-        return createDeepInfra({
-            baseURL: safeEnv.JIXO_DEEPINFRA_BASE_URL || undefined,
-            apiKey: safeEnv.JIXO_DEEPINFRA_API_KEY,
-        });
-    },
-});
-export const getModel = (model) => {
-    return match(model)
-        .with(P.string.startsWith("deepseek-"), (model) => providers.deepseek(model))
-        .with(P.string.startsWith("gemini-"), (model) => providers.google(model))
-        .with(P.string.startsWith("o3-"), P.string.startsWith("o1-"), P.string.startsWith("gpt-"), (model) => providers.openai(model))
-        .with(P.string.startsWith("claude-"), (model) => providers.anthropic(model))
-        .with(P.string.startsWith("grok-"), (model) => providers.xai(model))
-        .with(P.string.includes("/"), (model) => providers.deepinfra(model))
-        .otherwise(() => {
-        if (safeEnv.JIXO_DEEPSEEK_API_KEY) {
-            return providers.deepseek("deepseek-reasoner");
-        }
-        if (safeEnv.JIXO_GOOGLE_API_KEY) {
-            return providers.google("gemini-2.5-pro-preview-05-06");
-        }
-        if (safeEnv.JIXO_OPENAI_API_KEY) {
-            return providers.openai("o3-mini");
-        }
-        if (safeEnv.JIXO_ANTHROPIC_API_KEY) {
-            return providers.anthropic("claude-4-sonnet-20250514");
-        }
-        if (safeEnv.JIXO_XAI_API_KEY) {
-            return providers.xai("grok-3-beta");
-        }
-        if (safeEnv.JIXO_DEEPINFRA_API_KEY) {
-            return providers.deepinfra("meta-llama/Meta-Llama-3.1-405B-Instruct");
-        }
-        return providers.deepseek("deepseek-reasoner");
-    });
-};
-//# sourceMappingURL=model-providers.js.map

package/dist/commands/tasks/model-providers.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"model-providers.js","sourceRoot":"","sources":["../../../src/commands/tasks/model-providers.ts"],"names":[],"mappings":"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","sourcesContent":["import {createAnthropic} from \"@ai-sdk/anthropic\";\nimport {createDeepInfra} from \"@ai-sdk/deepinfra\";\nimport {createDeepSeek} from \"@ai-sdk/deepseek\";\nimport {createGoogleGenerativeAI} from \"@ai-sdk/google\";\nimport {createOpenAI, type OpenAIProvider} from \"@ai-sdk/openai\";\nimport {createXai} from \"@ai-sdk/xai\";\nimport {obj_lazify} from \"@gaubee/util\";\nimport {match, P} from \"ts-pattern\";\nimport {safeEnv} from \"../../env.js\";\n\n// const wrapper = (provider:)\nexport const providers = obj_lazify({\n  get deepseek() {\n    return createDeepSeek({\n      baseURL: safeEnv.JIXO_DEEPSEEK_BASE_URL || undefined,\n      apiKey: safeEnv.JIXO_DEEPSEEK_API_KEY,\n    });\n  },\n  get anthropic() {\n    // const bashTool = anthropic.tools.bash_20250124({\n    //   execute: async ({command, restart}) => execSync(command).toString(),\n    // });\n\n    const provider = createAnthropic({\n      baseURL: safeEnv.JIXO_ANTHROPIC_BASE_URL || undefined,\n      apiKey: safeEnv.JIXO_ANTHROPIC_API_KEY,\n    });\n    return provider;\n  },\n  get google() {\n    return createGoogleGenerativeAI({\n      baseURL: safeEnv.JIXO_GOOGLE_BASE_URL || undefined,\n      apiKey: safeEnv.JIXO_GOOGLE_API_KEY,\n    });\n  },\n  get openai() {\n    return createOpenAI({\n      baseURL: safeEnv.JIXO_OPENAI_BASE_URL || undefined,\n      apiKey: safeEnv.JIXO_OPENAI_API_KEY,\n      organization: safeEnv.JIXO_OPENAI_ORGANIZATION || undefined,\n    });\n  },\n  get xai() {\n    return createXai({\n      baseURL: safeEnv.JIXO_XAI_BASE_URL || undefined,\n      apiKey: safeEnv.JIXO_XAI_API_KEY,\n    });\n  },\n  get deepinfra() {\n    return createDeepInfra({\n      baseURL: safeEnv.JIXO_DEEPINFRA_BASE_URL || undefined,\n      apiKey: safeEnv.JIXO_DEEPINFRA_API_KEY,\n    });\n  },\n});\n\ntype LanguageModelV2 = ReturnType<OpenAIProvider>;\nexport const getModel = (model?: string): LanguageModelV2 => {\n  return match(model)\n    .with(P.string.startsWith(\"deepseek-\"), (model) => providers.deepseek(model))\n    .with(P.string.startsWith(\"gemini-\"), (model) => providers.google(model))\n    .with(P.string.startsWith(\"o3-\"), P.string.startsWith(\"o1-\"), P.string.startsWith(\"gpt-\"), (model) => providers.openai(model))\n    .with(P.string.startsWith(\"claude-\"), (model) => providers.anthropic(model))\n    .with(P.string.startsWith(\"grok-\"), (model) => providers.xai(model))\n    .with(P.string.includes(\"/\"), (model) => providers.deepinfra(model))\n    .otherwise(() => {\n      if (safeEnv.JIXO_DEEPSEEK_API_KEY) {\n        return providers.deepseek(\"deepseek-reasoner\");\n      }\n      if (safeEnv.JIXO_GOOGLE_API_KEY) {\n        return providers.google(\"gemini-2.5-pro-preview-05-06\");\n      }\n      if (safeEnv.JIXO_OPENAI_API_KEY) {\n        return providers.openai(\"o3-mini\");\n      }\n      if (safeEnv.JIXO_ANTHROPIC_API_KEY) {\n        return providers.anthropic(\"claude-4-sonnet-20250514\");\n      }\n      if (safeEnv.JIXO_XAI_API_KEY) {\n        return providers.xai(\"grok-3-beta\");\n      }\n      if (safeEnv.JIXO_DEEPINFRA_API_KEY) {\n        return providers.deepinfra(\"meta-llama/Meta-Llama-3.1-405B-Instruct\");\n      }\n      return providers.deepseek(\"deepseek-reasoner\");\n    });\n};\n"]}

package/dist/commands/tasks/run-ai-task.d.ts

@@ -1,4 +0,0 @@
-import { FileEntry } from "@gaubee/nodekit";
-import type { AiTask } from "../../helper/resolve-ai-tasks.js";
-export declare const runAiTask: (ai_task: AiTask, loopTimes: number, allFiles: FileEntry[], changedFilesSet: Record<string, FileEntry[]>) => Promise<void>;
-//# sourceMappingURL=run-ai-task.d.ts.map

package/dist/commands/tasks/run-ai-task.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run-ai-task.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/run-ai-task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAa,SAAS,EAA0C,MAAM,iBAAiB,CAAC;AAW/F,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,kCAAkC,CAAC;AAO7D,eAAO,MAAM,SAAS,GAAU,SAAS,MAAM,EAAE,WAAW,MAAM,EAAE,UAAU,SAAS,EAAE,EAAE,iBAAiB,MAAM,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,kBAwCtI,CAAC"}

package/dist/commands/tasks/run-ai-task.js

@@ -1,348 +0,0 @@
-import { blue, cyan, FileEntry, gray, green, red, spinner, YAML, yellow } from "@gaubee/nodekit";
-import { func_catch, obj_omit } from "@gaubee/util";
-import { streamText } from "ai";
-import ms from "ms";
-import { open } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { match, P } from "ts-pattern";
-import { handleError } from "../../helper/handle-ai-error.js";
-import { createDebug } from "../../helper/logger.js";
-import { getAllPromptConfigs, getAllSkillMap as getAllSkillNavMap } from "../../helper/prompts-loader.js";
-import { AiTaskTui } from "./ai-tasl-tui.js";
-import { tools } from "./ai-tools.js";
-import { getModel } from "./model-providers.js";
-const log = createDebug("jixo:run-ai-task");
-export const runAiTask = async (ai_task, loopTimes, allFiles, changedFilesSet) => {
-    const tool_spinner = spinner({
-        prefixText: "🧰",
-        text: "Preparing AI tools...",
-    });
-    tool_spinner.start();
-    const availableTools = {
-        ...(await tools.fileSystem(ai_task.cwd)),
-        ...(await tools.pnpm()),
-        ...(await tools.jixo(ai_task)),
-        ...(await tools.git(ai_task.cwd)),
-    };
-    tool_spinner.clear();
-    tool_spinner.stop();
-    const json_line_log_file_handle = await open(path.join(ai_task.cwd, ".jixo", `${ai_task.runner}.log.jsonl`), "a");
-    const __writeJsonLineLog = (...lineDatas) => {
-        for (const lineData of lineDatas) {
-            try {
-                const log = typeof lineData === "function" ? lineData() : lineData;
-                json_line_log_file_handle.appendFile(JSON.stringify(log) + "\n");
-            }
-            catch { }
-        }
-    };
-    const tui = new AiTaskTui(ai_task, spinner({ text: `Initializing AI task: ${cyan(ai_task.jobName)}...`, prefixText: "⏳ " }));
-    tui.spinner.start();
-    const updateTuiState = () => {
-        tui.setStatus("loop and time", `${green(`[${loopTimes}]`)} ${cyan(`+${ms(Date.now() - new Date(ai_task.startTime).getTime())}`)}`);
-    };
-    const ti = setInterval(updateTuiState, 1000);
-    updateTuiState();
-    try {
-        await _runAiTask(ai_task, availableTools, allFiles, changedFilesSet, tui, __writeJsonLineLog);
-    }
-    finally {
-        // Fallback spinner stop if loop exits unexpectedly
-        clearInterval(ti);
-        tui.stop();
-        json_line_log_file_handle.close();
-    }
-};
-const _runAiTask = async (ai_task, availableTools, allFiles, changedFilesSet, tui, __writeJsonLineLog) => {
-    const model = getModel(ai_task.model);
-    const initialMessages = [];
-    const maxTurns = 40; // Safeguard against infinite loops
-    const promptConfigs = getAllPromptConfigs();
-    for (const role of ["system", "user"]) {
-        const promptConfig = promptConfigs[role];
-        const promptContent = promptConfig.content //
-            .replace(/\{\{task.([\.\w]+)\}\}/g, (_, key) => {
-            if (key.includes(".")) {
-                const paths = key.split(".");
-                let res = ai_task;
-                for (const p of paths) {
-                    res = Reflect.get(res, p);
-                    if (!res) {
-                        break;
-                    }
-                }
-                return res;
-            }
-            else {
-                return Reflect.get(ai_task, key);
-            }
-        })
-            .replace(/\{\{env.(\w+)\}\}/g, (_, key) => {
-            const envKey = key.toUpperCase();
-            const envValue = Reflect.get(process.env, envKey) ??
-                match(envKey)
-                    .with("USER", () => os.userInfo().username)
-                    .otherwise(() => "");
-            return envValue;
-        })
-            .replaceAll("{{allSkills}}", (_, key) => {
-            return YAML.stringify(getAllSkillNavMap());
-        })
-            .replaceAll("{{allFiles}}", YAML.stringify({
-            [ai_task.cwd]: {
-                count: allFiles.length,
-                file: allFiles.map((e) => e.relativePath),
-            },
-        }))
-            .replaceAll("{{maxTurns}}", () => `${maxTurns}`)
-            .replaceAll("{{changedFiles}}", YAML.stringify(Object.entries(changedFilesSet).reduce((tree, [dir, changedFiles]) => {
-            tree[dir] = {
-                count: changedFiles.length,
-                files: changedFiles.map((e) => e.relativePath),
-            };
-            return tree;
-        }, {})));
-        log(`PROMPT ${role}:`, promptContent);
-        initialMessages.push({
-            role: role,
-            content: promptContent,
-        });
-    }
-    const currentMessages = [...initialMessages];
-    __writeJsonLineLog(...currentMessages);
-    loop: for (let turn = 0; turn < maxTurns; turn++) {
-        if (turn === 0) {
-            tui.setStatus("turns", `Connecting To ${model.provider}...`);
-        }
-        else {
-            tui.setStatus("turns", `Processing step ${turn + 1}/${maxTurns}...`);
-            const userTurnMessage = {
-                role: "user",
-                content: `Turns: ${turn}/${maxTurns}`,
-            };
-            currentMessages.push(userTurnMessage);
-            __writeJsonLineLog(userTurnMessage);
-        }
-        const result = await streamText({
-            model: model,
-            messages: currentMessages,
-            tools: availableTools,
-            toolChoice: "auto", // Changed to auto for more flexibility
-            onError: () => { },
-        });
-        let fullReasoningText = "";
-        let fullText = "";
-        let firstStreamPart = true;
-        const requestedToolCalls = []; // Using any for now, should be ToolCallPart from 'ai'
-        const assistantMessageContent = [];
-        const _currentAssistantMessage = { role: "assistant", content: assistantMessageContent };
-        const LOOP_SIGNALS = {
-            RETURN: "RETURN",
-            BREAK: "BREAK",
-            CONTINUE: "CONTINUE",
-            ERROR: "ERROR",
-        };
-        for await (const part of result.fullStream) {
-            __writeJsonLineLog(() => match(part)
-                .with({ type: "start-step" }, (p) => {
-                obj_omit(p, "request");
-            })
-                .otherwise((p) => p));
-            if (firstStreamPart) {
-                firstStreamPart = false;
-                tui.text = ""; // Clear initial connecting/processing message
-            }
-            const LOOP_SIGNAL = await match(part)
-                .with({ type: "text" }, (textPart) => {
-                tui.prefixText = "🤖 ";
-                let assistantTextPart = assistantMessageContent.findLast((part) => part.type === "text");
-                if (assistantTextPart == null) {
-                    assistantTextPart = { type: "text", text: "" };
-                    assistantMessageContent.push(assistantTextPart);
-                }
-                assistantTextPart.text += textPart.text;
-                if (fullText === "")
-                    tui.text = "";
-                fullText += textPart.text;
-                tui.text = "\n" + fullText.split("\n").slice(-10).join("\n");
-            })
-                .with({ type: "tool-call" }, (callPart) => {
-                tui.prefixText = "🛠️ ";
-                tui.text = "Requesting tool: " + blue(callPart.toolName);
-                log("\nQAQ tool-call: %y", callPart);
-                requestedToolCalls.push(callPart);
-                // Update assistant message to include tool calls
-                assistantMessageContent.push({
-                    type: "tool-call",
-                    toolCallId: callPart.toolCallId,
-                    toolName: callPart.toolName,
-                    args: callPart.args,
-                });
-            })
-                .with({ type: "error" }, async (errorPart) => {
-                tui.prefixText = tui.endInfo.prefixText = "❌ ";
-                tui.text = tui.endInfo.text = red(`${errorPart.error}`);
-                const handled = await handleError(errorPart.error, tui);
-                if (!handled) {
-                    return LOOP_SIGNALS.BREAK; // Stop processing on error
-                }
-            })
-                .with({ type: "reasoning" }, (reasoningPart) => {
-                tui.prefixText = "🤔 ";
-                if (fullReasoningText === "")
-                    tui.text = "";
-                fullReasoningText += reasoningPart.text;
-                tui.text = "\n" + gray(fullReasoningText.split("\n").slice(-3).join("\n"));
-            })
-                // Add other console logs for debugging if needed, but keep them minimal for production
-                .with({ type: "file" }, (p) => {
-                tui.prefixText = "📃 ";
-                tui.text = p.file.mediaType;
-                log("\nQAQ file: %y", p.file);
-            })
-                .with({ type: "source" }, (p) => {
-                tui.prefixText = "🔗 ";
-                if (p.sourceType === "url") {
-                    if (p.title) {
-                        tui.text = `[${p.title}](${p.url})`;
-                    }
-                    else {
-                        tui.text = p.url;
-                    }
-                }
-                else {
-                    if (p.filename) {
-                        tui.text = `[${p.title}](${p.filename})`;
-                    }
-                    else {
-                        tui.text = p.title;
-                    }
-                }
-                log("\nQAQ source: %y", p);
-            })
-                .with({ type: "tool-result" }, (p) => log("\nQAQ tool-result: %y", p))
-                .with({ type: "tool-call-streaming-start" }, (p) => log("\nQAQ tool-call-streaming-start: %y", p))
-                .with({ type: "tool-call-delta" }, (p) => log("\nQAQ tool-call-delta: %y", p))
-                .with({ type: "reasoning-part-finish" }, (p) => log("\nQAQ reasoning-part-finish: %y", p))
-                .with({ type: "start-step" }, (p) => log("\nQAQ start-step: %y", p))
-                .with({ type: "finish-step" }, (p) => {
-                log("\nQAQ finish-step: %y", p);
-                /**
-                 * This event marks the end of an intermediate step, not the entire turn.
-                 * We handle potential issues here, but the main logic for continuing or
-                 * stopping the loop is in the final 'finish' event handler.
-                 */
-                return match(p)
-                    .with({ finishReason: P.union("content-filter", "error") }, (part) => {
-                    // A step finishing due to an error or content filter is a serious issue.
-                    // Update the TUI to reflect this problem immediately.
-                    const reasonText = part.finishReason === "content-filter" ? "Content filter violation" : "Model error";
-                    tui.prefixText = tui.endInfo.prefixText = "⚠️ ";
-                    tui.text = tui.endInfo.text = red(`Step failed due to ${reasonText}. Will be retry.`);
-                    log(red(`Step finished with critical reason: ${part.finishReason}`));
-                    return LOOP_SIGNALS.RETURN;
-                })
-                    .with({ finishReason: P.union("other", "unknown") }, (part) => {
-                    // Log unusual finish reasons for debugging purposes.
-                    log(yellow(`Step finished with an unusual reason: ${part.finishReason}`));
-                })
-                    .otherwise(() => {
-                    // This covers 'stop', 'length', and 'tool-calls'. These are normal
-                    // reasons for a step to finish. The final 'finish' event will
-                    // determine the overall outcome of the turn. No special action is needed here.
-                    log(`Step finished with normal reason: ${p.finishReason}. Awaiting end of turn.`);
-                });
-            })
-                .with({ type: "start" }, (p) => log("\nQAQ start: %y", p))
-                .with({ type: "finish" }, async (finishPart) => {
-                log("\nQAQ finish: %y", finishPart);
-                // Add the assistant's message from this step to the history
-                currentMessages.push(_currentAssistantMessage);
-                __writeJsonLineLog(_currentAssistantMessage);
-                if (finishPart.finishReason === "stop" || finishPart.finishReason === "length") {
-                    tui.prefixText = tui.endInfo.prefixText = "✅ ";
-                    tui.text = tui.endInfo.text = green(`${cyan(`[${ai_task.jobName}]`)} Completed`);
-                    // Task finished without tool calls or after tool calls that didn't lead to more calls.
-                    return LOOP_SIGNALS.RETURN; // Exit the outer loop and function
-                }
-                if (finishPart.finishReason === "tool-calls") {
-                    if (requestedToolCalls.length === 0) {
-                        tui.prefixText = tui.endInfo.prefixText = "🚧 ";
-                        tui.text = tui.endInfo.text = yellow(`${cyan(`[${ai_task.jobName}]`)} finished with 'tool-calls' but no tools were requested.`);
-                        return LOOP_SIGNALS.RETURN; // Exit, something is off
-                    }
-                    const toolResultMessages = [];
-                    for (const toolCall of requestedToolCalls) {
-                        const toolToExecute = availableTools[toolCall.toolName];
-                        if (!toolToExecute || typeof toolToExecute.execute !== "function") {
-                            console.error(`Tool ${toolCall.toolName} not found or not executable.`);
-                            toolResultMessages.push({
-                                role: "tool",
-                                content: [
-                                    {
-                                        type: "tool-result",
-                                        toolCallId: toolCall.toolCallId,
-                                        toolName: toolCall.toolName,
-                                        result: JSON.stringify({ error: `Tool ${toolCall.toolName} not found or not executable.` }),
-                                        isError: true,
-                                    },
-                                ],
-                            });
-                            continue;
-                        }
-                        tui.text = `Executing tool: ${toolCall.toolName}...`;
-                        const executionResult = await func_catch(() => toolToExecute.execute(toolCall.args, {
-                            toolCallId: toolCall.toolCallId,
-                            messages: currentMessages,
-                        }))();
-                        toolResultMessages.push({
-                            role: "tool",
-                            content: [
-                                {
-                                    type: "tool-result",
-                                    toolCallId: toolCall.toolCallId,
-                                    toolName: toolCall.toolName,
-                                    isError: !executionResult.success,
-                                    result: JSON.stringify(executionResult.success ? executionResult.result : executionResult.error),
-                                },
-                            ],
-                        });
-                        if (executionResult.success) {
-                            tui.text = `Tool ${toolCall.toolName} executed.`;
-                        }
-                        else {
-                            tui.text = `Error executing tool ${toolCall.toolName}.`;
-                        }
-                    }
-                    currentMessages.push(...toolResultMessages);
-                    __writeJsonLineLog(...toolResultMessages);
-                    // Loop continues for the next step
-                }
-                else {
-                    // Other finish reasons, potentially an error or unexpected state
-                    tui.prefixText = tui.endInfo.prefixText = "🛑 ";
-                    tui.text = tui.endInfo.text = red(`${cyan(`[${ai_task.jobName}]`)} task finished with unhandled reason: ${finishPart.finishReason}`);
-                    return LOOP_SIGNALS.ERROR;
-                }
-            })
-                .otherwise(() => { }); // Handle any other part types if necessary
-            if (LOOP_SIGNAL === LOOP_SIGNALS.ERROR) {
-                throw LOOP_SIGNAL;
-            }
-            if (LOOP_SIGNAL === LOOP_SIGNALS.RETURN) {
-                break loop;
-            }
-            else if (LOOP_SIGNAL === LOOP_SIGNALS.BREAK) {
-                break;
-            }
-        }
-        // If the stream finishes without a 'finish' part (e.g. error thrown inside), this loop might exit. Ensure spinner stops.
-        if (turn === maxTurns - 1) {
-            tui.prefixText = tui.endInfo.prefixText = "🚧 ";
-            tui.text = tui.endInfo.text = yellow(`${cyan(`[${ai_task.jobName}]`)} Max interaction turns reached.`);
-            break;
-        }
-    }
-};
-//# sourceMappingURL=run-ai-task.js.map