@jixo/cli 0.3.0

package/dist/commands/run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run.js","sourceRoot":"","sources":["../../src/commands/run.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,MAAM,EAAE,iBAAiB,EAAC,MAAM,iBAAiB,CAAC;AACrE,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,2BAA2B,EAAC,MAAM,2BAA2B,CAAC;AACtE,OAAO,EAAC,cAAc,EAAc,MAAM,+BAA+B,CAAC;AAE1E,MAAM,CAAC,MAAM,GAAG,GAAG,KAAK,EAAE,IAAY,EAAE,OAAoD,EAAE,EAAE;IAC9F,MAAM,GAAG,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAC;IACpC,MAAM,MAAM,GAAG,MAAM,UAAU,CAAC,GAAG,CAAC,CAAC;IACrC,MAAM,QAAQ,GAAG,cAAc,CAAC,GAAG,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC;IACnD,MAAM,WAAW,GAAG,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,EAAC,CAAC;IAC5G,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC,CAAC,CAAC,EAAC,OAAO,EAAE,GAAG,EAAE,CAAC,IAAI,EAAC,CAAC;IAEzG,MAAM,YAAY,GAAG,MAAM,2BAA2B,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;IACrE,uCAAuC;IACvC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,EAAC,GAAG,EAAE,QAAQ,EAAC,GAAG,OAAO,CAAC;QAChC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;YAClC,SAAS;QACX,CAAC;QACD,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACvC,SAAS;QACX,CAAC;QACD,IAAI,iBAAiB,GAAG,YAAY,CAAC;QACrC,IAAI,QAAQ,KAAK,GAAG,EAAE,CAAC;YACrB,iBAAiB,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC;QAC/F,CAAC;QACD,+DAA+D;QAC/D,MAAM,SAAS,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;IAC9C,CAAC;IAED,uBAAuB;IACvB,yDAAyD;IACzD,kDAAkD;IAClD,OAAO;AACT,CAAC,CAAC;AAEF,MAAM,SAAS,GAAG,KAAK,EAAE,OAAe,EAAE,YAAyB,EAAE,EAAE;IACnE,OAAO,CAAC,GAAG,CAAC,aAAa,CAAC,CAAA;AAC9B,CAAC,CAAC","sourcesContent":["import {FileEntry, Ignore, normalizeFilePath} from \"@gaubee/nodekit\";\nimport {loadConfig} from \"../config.js\";\nimport {findChangedFilesSinceCommit} from \"../helper/find-changes.js\";\nimport {resolveAiTasks, type AiTask} from \"../helper/resolve-ai-tasks.js\";\n\nexport const run = async (_cwd: string, options: {nameFilter: string[]; dirFilter: string[]}) => {\n  const cwd = normalizeFilePath(_cwd);\n  const config = await loadConfig(cwd);\n  const ai_tasks = resolveAiTasks(cwd, config.tasks);\n  const nameMatcher = options.nameFilter.length ? new Ignore(options.nameFilter, cwd) : {isMatch: () => true};\n  const dirMatcher = options.dirFilter.length ? new Ignore(options.dirFilter, cwd) : {isMatch: () => true};\n\n  const changedFiles = await findChangedFilesSinceCommit(\"@jixo\", cwd);\n  //   const run_tasks: Array<Func> = [];\n  for (const ai_task of ai_tasks) {\n    const {dir: task_dir} = ai_task;\n    if (!dirMatcher.isMatch(task_dir)) {\n      continue;\n    }\n    if (!nameMatcher.isMatch(ai_task.name)) {\n      continue;\n    }\n    let task_changedFiles = changedFiles;\n    if (task_dir !== cwd) {\n      task_changedFiles = task_changedFiles.filter((file) => file.path.startsWith(task_dir + \"/\"));\n    }\n    // run_tasks.push(() => runAiTask(ai_task, task_changedFiles));\n    await runAiTask(ai_task, task_changedFiles);\n  }\n\n  //   let done_tasks = 0\n  //   const running = spinner.default(\"running tasks...\");\n  //   func_parallel_limit(run_tasks, 5).watch(()=>{\n  //   })\n};\n\nconst runAiTask = async (ai_task: AiTask, changedFiles: FileEntry[]) => {\n    console.log(\"run ai task\")\n};\n"]}

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

@@ -0,0 +1,268 @@
+import { type ToolSet } from "ai";
+export declare const tools: {
+    fileSystem: (cwd: string) => Promise<ToolSet>;
+    memory: (memory_filepath: string) => Promise<ToolSet>;
+    fetch: import("@gaubee/util").FuncRemember<() => Promise<{
+        [x: string]: import("ai").Tool<unknown, import("zod").objectOutputType<{
+            _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+        } & {
+            content: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">>]>, "many">;
+            isError: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodBoolean>>;
+        }, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<{
+            _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+        } & {
+            toolResult: import("zod").ZodUnknown;
+        }, import("zod").ZodTypeAny, "passthrough">> & Required<Pick<import("ai").Tool<unknown, import("zod").objectOutputType<{
+            _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+        } & {
+            content: import("zod").ZodArray<import("zod").ZodUnion<[import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"text">;
+                text: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"image">;
+                data: import("zod").ZodString;
+                mimeType: import("zod").ZodString;
+            }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                type: import("zod").ZodLiteral<"resource">;
+                resource: import("zod").ZodUnion<[import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    text: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>, import("zod").ZodObject<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    uri: import("zod").ZodString;
+                    mimeType: import("zod").ZodOptional<import("zod").ZodString>;
+                } & {
+                    blob: import("zod").ZodString;
+                }, import("zod").ZodTypeAny, "passthrough">>]>;
+            }, import("zod").ZodTypeAny, "passthrough">>]>, "many">;
+            isError: import("zod").ZodOptional<import("zod").ZodDefault<import("zod").ZodBoolean>>;
+        }, import("zod").ZodTypeAny, "passthrough"> | import("zod").objectOutputType<{
+            _meta: import("zod").ZodOptional<import("zod").ZodObject<{}, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{}, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{}, import("zod").ZodTypeAny, "passthrough">>>;
+        } & {
+            toolResult: import("zod").ZodUnknown;
+        }, import("zod").ZodTypeAny, "passthrough">>, "execute">>;
+    }>, void | ((this: unknown) => any)>;
+    git: (repo: string) => Promise<ToolSet>;
+};
+//# sourceMappingURL=ai-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tools.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/ai-tools.ts"],"names":[],"mappings":"AACA,OAAO,EAAkD,KAAK,OAAO,EAAC,MAAM,IAAI,CAAC;AAGjF,eAAO,MAAM,KAAK;sBAGD,MAAM;8BAeM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA6BjB,MAAM;CAavB,CAAC"}

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

@@ -0,0 +1,64 @@
+import { func_lazy, func_remember, map_get_or_put_async } from "@gaubee/util";
+import { experimental_createMCPClient as createMCPClient } from "ai";
+import { Experimental_StdioMCPTransport } from "ai/mcp-stdio";
+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: "pnpx",
+                        args: ["@modelcontextprotocol/server-filesystem", 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;
+            });
+        };
+    }),
+    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;
+            });
+        };
+    }),
+};
+//# sourceMappingURL=ai-tools.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ai-tools.js","sourceRoot":"","sources":["../../../src/commands/tasks/ai-tools.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,aAAa,EAAE,oBAAoB,EAAC,MAAM,cAAc,CAAC;AAC5E,OAAO,EAAC,4BAA4B,IAAI,eAAe,EAAe,MAAM,IAAI,CAAC;AACjF,OAAO,EAAC,8BAA8B,EAAC,MAAM,cAAc,CAAC;AAE5D,MAAM,CAAC,MAAM,KAAK,GAAG;IACnB,UAAU,EAAE,SAAS,CAAC,GAAG,EAAE;QACzB,MAAM,GAAG,GAAG,IAAI,GAAG,EAAmB,CAAC;QACvC,OAAO,CAAC,GAAW,EAAE,EAAE;YACrB,OAAO,oBAAoB,CAAC,GAAG,EAAE,GAAG,EAAE,KAAK,IAAI,EAAE;gBAC/C,MAAM,SAAS,GAAG,MAAM,eAAe,CAAC;oBACtC,SAAS,EAAE,IAAI,8BAA8B,CAAC;wBAC5C,OAAO,EAAE,MAAM;wBACf,IAAI,EAAE,CAAC,yCAAyC,EAAE,GAAG,CAAC;qBACvD,CAAC;iBACH,CAAC,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;gBACtC,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;IACJ,CAAC,CAAC;IACF,MAAM,EAAE,SAAS,CAAC,GAAG,EAAE;QACrB,MAAM,GAAG,GAAG,IAAI,GAAG,EAAmB,CAAC;QACvC,OAAO,CAAC,eAAuB,EAAE,EAAE;YACjC,OAAO,oBAAoB,CAAC,GAAG,EAAE,eAAe,EAAE,KAAK,IAAI,EAAE;gBAC3D,MAAM,SAAS,GAAG,MAAM,eAAe,CAAC;oBACtC,SAAS,EAAE,IAAI,8BAA8B,CAAC;wBAC5C,OAAO,EAAE,MAAM;wBACf,IAAI,EAAE,CAAC,qCAAqC,CAAC;wBAC7C,GAAG,EAAE;4BACH,gBAAgB,EAAE,eAAe;yBAClC;qBACF,CAAC;iBACH,CAAC,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;gBACtC,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;IACJ,CAAC,CAAC;IACF,KAAK,EAAE,aAAa,CAAC,KAAK,IAAI,EAAE;QAC9B,MAAM,SAAS,GAAG,MAAM,eAAe,CAAC;YACtC,SAAS,EAAE,IAAI,8BAA8B,CAAC;gBAC5C,OAAO,EAAE,KAAK;gBACd,IAAI,EAAE,CAAC,kBAAkB,CAAC;aAC3B,CAAC;SACH,CAAC,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QACtC,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IACF,GAAG,EAAE,SAAS,CAAC,GAAG,EAAE;QAClB,MAAM,GAAG,GAAG,IAAI,GAAG,EAAmB,CAAC;QAEvC,OAAO,CAAC,IAAY,EAAE,EAAE;YACtB,OAAO,oBAAoB,CAAC,GAAG,EAAE,IAAI,EAAE,KAAK,IAAI,EAAE;gBAChD,MAAM,SAAS,GAAG,MAAM,eAAe,CAAC;oBACtC,SAAS,EAAE,IAAI,8BAA8B,CAAC;wBAC5C,OAAO,EAAE,KAAK;wBACd,IAAI,EAAE,CAAC,gBAAgB,EAAE,cAAc,EAAE,IAAI,CAAC;qBAC/C,CAAC;iBACH,CAAC,CAAC;gBACH,MAAM,KAAK,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;gBACtC,OAAO,KAAK,CAAC;YACf,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;IACJ,CAAC,CAAC;CACH,CAAC","sourcesContent":["import {func_lazy, func_remember, map_get_or_put_async} from \"@gaubee/util\";\nimport {experimental_createMCPClient as createMCPClient, type ToolSet} from \"ai\";\nimport {Experimental_StdioMCPTransport} from \"ai/mcp-stdio\";\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: \"pnpx\",\n            args: [\"@modelcontextprotocol/server-filesystem\", 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  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"]}

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

@@ -0,0 +1,9 @@
+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: import("@ai-sdk/openai").OpenAIProvider;
+    readonly xai: import("@ai-sdk/xai").XaiProvider;
+    readonly deepinfra: import("@ai-sdk/deepinfra").DeepInfraProvider;
+};
+//# sourceMappingURL=model-providers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-providers.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/model-providers.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,SAAS;;;;;;;CA2CpB,CAAC"}

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

@@ -0,0 +1,53 @@
+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 { 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,
+        });
+    },
+});
+//# sourceMappingURL=model-providers.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-providers.js","sourceRoot":"","sources":["../../../src/commands/tasks/model-providers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAClD,OAAO,EAAC,cAAc,EAAC,MAAM,kBAAkB,CAAC;AAChD,OAAO,EAAC,wBAAwB,EAAC,MAAM,gBAAgB,CAAC;AACxD,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EAAC,SAAS,EAAC,MAAM,aAAa,CAAC;AACtC,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,OAAO,EAAC,MAAM,cAAc,CAAC;AAErC,8BAA8B;AAC9B,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC;IAClC,IAAI,QAAQ;QACV,OAAO,cAAc,CAAC;YACpB,OAAO,EAAE,OAAO,CAAC,sBAAsB,IAAI,SAAS;YACpD,MAAM,EAAE,OAAO,CAAC,qBAAqB;SACtC,CAAC,CAAC;IACL,CAAC;IACD,IAAI,SAAS;QACX,mDAAmD;QACnD,yEAAyE;QACzE,MAAM;QAEN,MAAM,QAAQ,GAAG,eAAe,CAAC;YAC/B,OAAO,EAAE,OAAO,CAAC,uBAAuB,IAAI,SAAS;YACrD,MAAM,EAAE,OAAO,CAAC,sBAAsB;SACvC,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC;IACD,IAAI,MAAM;QACR,OAAO,wBAAwB,CAAC;YAC9B,OAAO,EAAE,OAAO,CAAC,oBAAoB,IAAI,SAAS;YAClD,MAAM,EAAE,OAAO,CAAC,mBAAmB;SACpC,CAAC,CAAC;IACL,CAAC;IACD,IAAI,MAAM;QACR,OAAO,YAAY,CAAC;YAClB,OAAO,EAAE,OAAO,CAAC,oBAAoB,IAAI,SAAS;YAClD,MAAM,EAAE,OAAO,CAAC,mBAAmB;YACnC,YAAY,EAAE,OAAO,CAAC,wBAAwB,IAAI,SAAS;SAC5D,CAAC,CAAC;IACL,CAAC;IACD,IAAI,GAAG;QACL,OAAO,SAAS,CAAC;YACf,OAAO,EAAE,OAAO,CAAC,iBAAiB,IAAI,SAAS;YAC/C,MAAM,EAAE,OAAO,CAAC,gBAAgB;SACjC,CAAC,CAAC;IACL,CAAC;IACD,IAAI,SAAS;QACX,OAAO,eAAe,CAAC;YACrB,OAAO,EAAE,OAAO,CAAC,uBAAuB,IAAI,SAAS;YACrD,MAAM,EAAE,OAAO,CAAC,sBAAsB;SACvC,CAAC,CAAC;IACL,CAAC;CACF,CAAC,CAAC","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} from \"@ai-sdk/openai\";\nimport {createXai} from \"@ai-sdk/xai\";\nimport {obj_lazify} from \"@gaubee/util\";\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"]}

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

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

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

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