task-o-matic 0.0.21 → 0.0.22

package/dist/commands/tasks/split.js

@@ -12,8 +12,12 @@ const task_1 = require("../../cli/display/task");
 const progress_tracking_1 = require("../../utils/progress-tracking");
 const cli_validators_1 = require("../../utils/cli-validators");
 const bulk_operations_1 = require("../../utils/bulk-operations");
-const confirmation_1 = require("../../utils/confirmation");
 const command_error_handler_1 = require("../../utils/command-error-handler");
+const ai_parallel_1 = require("../utils/ai-parallel");
+const prd_1 = require("../prd");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const config_1 = require("../../lib/config");
 exports.splitCommand = new commander_1.Command("split")
     .description("Split a task into smaller subtasks using AI")
     .option("--task-id <id>", "Task ID to split")
@@ -24,9 +28,10 @@ exports.splitCommand = new commander_1.Command("split")
     .option("--force", "Skip confirmation prompt for bulk operations")
     .option("--stream", "Show streaming AI output during breakdown")
     .option("--ai-provider <provider>", "AI provider override")
-    .option("--ai-model <model>", "AI model override")
     .option("--ai-key <key>", "AI API key override")
     .option("--ai-provider-url <url>", "AI provider URL override")
+    .option("--ai <models...>", "AI model(s) to use. Format: [provider:]model[;reasoning[=budget]]")
+    .option("--combine-ai <provider:model>", "AI model to combine multiple split results")
     .option("--reasoning <tokens>", "Enable reasoning for OpenRouter models (max reasoning tokens)")
     .option("--tools", "Enable filesystem tools for project analysis")
     .action((0, command_error_handler_1.wrapCommandHandler)("Task splitting", async (options) => {
@@ -42,27 +47,120 @@ exports.splitCommand = new commander_1.Command("split")
         }
         const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Task breakdown");
         try {
-            const result = await (0, progress_tracking_1.withProgressTracking)(async () => {
-                return await tasks_1.taskService.splitTask(taskId, {
-                    aiProvider: options.aiProvider,
-                    aiModel: options.aiModel,
-                    aiKey: options.aiKey,
-                    aiProviderUrl: options.aiProviderUrl,
-                    aiReasoning: options.reasoning,
-                }, undefined, undefined, streamingOptions, options.tools);
-            });
-            (0, task_1.displaySubtaskCreation)(result.subtasks);
-            // Display AI metadata
-            console.log(chalk_1.default.gray(`\n📊 AI Splitting Details:`));
-            console.log(chalk_1.default.gray(`   Provider: ${result.metadata.aiProvider}`));
-            console.log(chalk_1.default.gray(`   Model: ${result.metadata.aiModel}`));
-            console.log(chalk_1.default.gray(`   Subtasks created: ${result.subtasks.length}`));
-            console.log(chalk_1.default.gray(`   Confidence: ${result.metadata.confidence
-                ? (result.metadata.confidence * 100).toFixed(1)
-                : "N/A"}%`));
+            // Check for parallel/multi-model usage
+            const cliModels = Array.isArray(options.ai)
+                ? options.ai
+                : options.ai
+                    ? [options.ai]
+                    : [];
+            if (cliModels.length > 0 || options.combineAi) {
+                const modelsToUse = cliModels.length > 0
+                    ? cliModels
+                    : [
+                        `${options.aiProvider || "openai"}:${options.aiModel || "gpt-4o"}`,
+                    ];
+                const task = await tasks_1.taskService.getTask(taskId);
+                if (!task)
+                    throw new Error(`Task ${taskId} not found`);
+                const taskOMaticDir = config_1.configManager.getTaskOMaticDir();
+                const tasksJsonPath = (0, path_1.join)(taskOMaticDir, "tasks.json");
+                const aiMetadataPath = (0, path_1.join)(taskOMaticDir, "ai-metadata.json");
+                const tasksBackupPath = (0, path_1.join)(taskOMaticDir, "tasks.json.bak");
+                const aiMetadataBackupPath = (0, path_1.join)(taskOMaticDir, "ai-metadata.json.bak");
+                // 1. Backup Phase
+                if ((0, fs_1.existsSync)(tasksJsonPath)) {
+                    (0, fs_1.copyFileSync)(tasksJsonPath, tasksBackupPath);
+                }
+                if ((0, fs_1.existsSync)(aiMetadataPath)) {
+                    (0, fs_1.copyFileSync)(aiMetadataPath, aiMetadataBackupPath);
+                }
+                let results = [];
+                try {
+                    // 2. Parallel Generation (Service-Based)
+                    // We let the service write to the file. It will be corrupted/racy, but we don't care.
+                    results = await (0, ai_parallel_1.runAIParallel)(modelsToUse, async (modelConfig, streamingOptions) => {
+                        const result = await tasks_1.taskService.splitTask(taskId, {
+                            aiProvider: modelConfig.provider,
+                            aiModel: modelConfig.model,
+                            aiKey: options.aiKey,
+                            aiProviderUrl: options.aiProviderUrl,
+                            aiReasoning: options.reasoning || modelConfig.reasoning,
+                        }, undefined, undefined, streamingOptions, options.tools);
+                        return {
+                            data: result.subtasks, // We only care about the returned data
+                            stats: result.stats,
+                        };
+                    }, {
+                        description: "Splitting Task",
+                        showSummary: true,
+                    });
+                }
+                finally {
+                    // 3. Restore Phase
+                    // Restore the original clean state
+                    if ((0, fs_1.existsSync)(tasksBackupPath)) {
+                        (0, fs_1.renameSync)(tasksBackupPath, tasksJsonPath);
+                    }
+                    if ((0, fs_1.existsSync)(aiMetadataBackupPath)) {
+                        (0, fs_1.renameSync)(aiMetadataBackupPath, aiMetadataPath);
+                    }
+                }
+                if (options.combineAi && results.length > 0) {
+                    const taskLists = results.map((r) => r.data);
+                    const combineModelConfig = (0, prd_1.parseModelString)(options.combineAi);
+                    console.log(chalk_1.default.blue(`\nCombining ${taskLists.length} subtask lists with ${combineModelConfig.model}...`));
+                    // Construct the message with drafts
+                    let draftsMessage = "Here are draft subtask lists generated by multiple models. Please combine them into the best possible single list ensuring strict schema compliance:\n\n";
+                    results.forEach((r, idx) => {
+                        draftsMessage += `--- Model ${idx + 1} Draft ---\n${JSON.stringify(r.data, null, 2)}\n\n`;
+                    });
+                    // 4. Service-Based Combination
+                    const result = await tasks_1.taskService.splitTask(taskId, {
+                        aiProvider: combineModelConfig.provider,
+                        aiModel: combineModelConfig.model,
+                        aiReasoning: options.reasoning || combineModelConfig.reasoning,
+                    }, undefined, draftsMessage, // Inject drafts
+                    (0, streaming_options_1.createStreamingOptions)(options.stream, "Combining"), options.tools);
+                    (0, task_1.displaySubtaskCreation)(result.subtasks);
+                }
+                else if (results.length > 0) {
+                    // Single select fallback (using service to save cleanly)
+                    const bestResult = results[0].data;
+                    console.log(chalk_1.default.yellow("\n⚠️  Multiple models used without --combine-ai. Saving result from first model."));
+                    const draftsMessage = `Here is the pre-generated subtask list. Please validate and save it exactly as is:\n\n${JSON.stringify(bestResult, null, 2)}`;
+                    const result = await tasks_1.taskService.splitTask(taskId, {
+                        aiProvider: options.aiProvider,
+                        aiModel: options.aiModel,
+                        aiReasoning: options.reasoning,
+                    }, undefined, draftsMessage, (0, streaming_options_1.createStreamingOptions)(options.stream, "Saving"), options.tools);
+                    (0, task_1.displaySubtaskCreation)(result.subtasks);
+                }
+            }
+            else {
+                // Standard single model execution
+                const result = await (0, progress_tracking_1.withProgressTracking)(async () => {
+                    return await tasks_1.taskService.splitTask(taskId, {
+                        aiProvider: options.aiProvider,
+                        aiModel: options.aiModel,
+                        aiKey: options.aiKey,
+                        aiProviderUrl: options.aiProviderUrl,
+                        aiReasoning: options.reasoning,
+                    }, undefined, undefined, streamingOptions, options.tools);
+                });
+                (0, task_1.displaySubtaskCreation)(result.subtasks);
+                // Display AI metadata
+                console.log(chalk_1.default.gray(`\n📊 AI Splitting Details:`));
+                console.log(chalk_1.default.gray(`   Provider: ${result.metadata.aiProvider}`));
+                console.log(chalk_1.default.gray(`   Model: ${result.metadata.aiModel}`));
+                console.log(chalk_1.default.gray(`   Subtasks created: ${result.subtasks.length}`));
+                console.log(chalk_1.default.gray(`   Confidence: ${result.metadata.confidence
+                    ? (result.metadata.confidence * 100).toFixed(1)
+                    : "N/A"}%`));
+            }
         }
         catch (error) {
-            if (error instanceof Error && error.message.includes("already has")) {
+            if (error instanceof Error &&
+                error.message.includes("already has")) {
                 console.log(chalk_1.default.yellow(`⚠️ ${error.message}`));
                 return;
             }
@@ -85,12 +183,16 @@ exports.splitCommand = new commander_1.Command("split")
             console.log(chalk_1.default.yellow("No tasks found matching the filters"));
             return;
         }
-        // Confirm bulk operation
-        const confirmed = await (0, confirmation_1.confirmBulkOperation)("split", tasks.length, options.force);
-        if (!confirmed) {
-            console.log(chalk_1.default.yellow("Operation cancelled"));
-            return;
-        }
+        // // Confirm bulk operation
+        // const confirmed = await confirmBulkOperation(
+        //   "split",
+        //   tasks.length,
+        //   options.force
+        // );
+        // if (!confirmed) {
+        //   console.log(chalk.yellow("Operation cancelled"));
+        //   return;
+        // }
         await (0, bulk_operations_1.executeBulkOperation)((taskId) => splitSingleTask(taskId), {
             operationName: "Splitting",
             operationEmoji: "🔧",

package/dist/commands/utils/ai-parallel.d.ts

@@ -0,0 +1,20 @@
+export interface AIParallelResult<T> {
+    modelId: string;
+    data: T;
+    stats: any;
+}
+/**
+ * Run AI operations in parallel with progress tracking
+ */
+export declare function runAIParallel<T>(models: string[], operation: (modelConfig: any, streamingOptions: any) => Promise<{
+    data: T;
+    stats: any;
+}>, options: {
+    description: string;
+    showSummary?: boolean;
+}): Promise<AIParallelResult<T>[]>;
+/**
+ * Combine multiple PRDs into a single master PRD
+ */
+export declare function combinePRDs(prds: string[], description: string, modelStr: string, stream: boolean, reasoningOverride?: string): Promise<string>;
+//# sourceMappingURL=ai-parallel.d.ts.map

package/dist/commands/utils/ai-parallel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-parallel.d.ts","sourceRoot":"","sources":["../../../src/commands/utils/ai-parallel.ts"],"names":[],"mappings":"AAYA,MAAM,WAAW,gBAAgB,CAAC,CAAC;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,CAAC,CAAC;IACR,KAAK,EAAE,GAAG,CAAC;CACZ;AAED;;GAEG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACnC,MAAM,EAAE,MAAM,EAAE,EAChB,SAAS,EAAE,CACT,WAAW,EAAE,GAAG,EAChB,gBAAgB,EAAE,GAAG,KAClB,OAAO,CAAC;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,KAAK,EAAE,GAAG,CAAA;CAAE,CAAC,EACrC,OAAO,EAAE;IACP,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,GACA,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CA6HhC;AAED;;GAEG;AACH,wBAAsB,WAAW,CAC/B,IAAI,EAAE,MAAM,EAAE,EACd,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,iBAAiB,CAAC,EAAE,MAAM,GACzB,OAAO,CAAC,MAAM,CAAC,CA2BjB"}

package/dist/commands/utils/ai-parallel.js

@@ -0,0 +1,115 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAIParallel = runAIParallel;
+exports.combinePRDs = combinePRDs;
+const chalk_1 = __importDefault(require("chalk"));
+const ai_service_factory_1 = require("../../utils/ai-service-factory");
+const prd_1 = require("../prd");
+const streaming_options_1 = require("../../utils/streaming-options");
+const config_1 = require("../../lib/config");
+/**
+ * Run AI operations in parallel with progress tracking
+ */
+async function runAIParallel(models, operation, options) {
+    console.log(chalk_1.default.blue(`\n${options.description} with ${models.length} models concurrently...\n`));
+    const modelMap = new Map();
+    const modelStatus = new Map();
+    const results = [];
+    // Print initial lines
+    models.forEach((m, i) => {
+        modelMap.set(m, i);
+        modelStatus.set(m, "Waiting...");
+        console.log(chalk_1.default.dim(`- ${m}: Waiting...`));
+    });
+    const totalModels = models.length;
+    // Generate concurrently
+    const promises = models.map(async (modelStr) => {
+        const modelConfig = (0, prd_1.parseModelString)(modelStr);
+        const index = modelMap.get(modelStr);
+        // Update status: Starting
+        const up = totalModels - index;
+        process.stdout.write(`\x1B[${up}A`);
+        process.stdout.write(`\x1B[2K`);
+        process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.yellow("Starting...")}\r`);
+        process.stdout.write(`\x1B[${up}B`);
+        try {
+            const streamingOptions = {
+                onReasoning: (text) => {
+                    const up = totalModels - index;
+                    process.stdout.write(`\x1B[${up}A`);
+                    process.stdout.write(`\x1B[2K`);
+                    process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.magenta("Reasoning...")}\r`);
+                    process.stdout.write(`\x1B[${up}B`);
+                },
+                onChunk: (chunk) => {
+                    const up = totalModels - index;
+                    process.stdout.write(`\x1B[${up}A`);
+                    process.stdout.write(`\x1B[2K`);
+                    process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.blue("Generating...")}\r`);
+                    process.stdout.write(`\x1B[${up}B`);
+                },
+            };
+            const result = await operation(modelConfig, streamingOptions);
+            // Update status: Completed
+            const up2 = totalModels - index;
+            process.stdout.write(`\x1B[${up2}A`);
+            process.stdout.write(`\x1B[2K`);
+            process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.green(`Completed (${result.stats.duration}ms)`)}\r`);
+            process.stdout.write(`\x1B[${up2}B`);
+            results.push({
+                modelId: modelStr,
+                data: result.data,
+                stats: result.stats,
+            });
+            return result;
+        }
+        catch (error) {
+            const up2 = totalModels - index;
+            process.stdout.write(`\x1B[${up2}A`);
+            process.stdout.write(`\x1B[2K`);
+            process.stdout.write(`- ${chalk_1.default.bold(modelStr)}: ${chalk_1.default.red(`Failed: ${error instanceof Error ? error.message : String(error)}`)}\r`);
+            process.stdout.write(`\x1B[${up2}B`);
+            throw error;
+        }
+    });
+    await Promise.allSettled(promises);
+    if (options.showSummary) {
+        // Display summary
+        console.log(chalk_1.default.green(`\n✓ ${options.description} completed (${results.length}/${models.length} success)\n`));
+        console.log(chalk_1.default.bold(`${"Model".padEnd(40)} | ${"Duration".padEnd(10)} | ${"TTFT".padEnd(10)} | ${"Tokens".padEnd(10)}`));
+        console.log("-".repeat(80));
+        results.forEach((r) => {
+            const duration = `${r.stats.duration}ms`;
+            const ttft = r.stats.timeToFirstToken
+                ? `${r.stats.timeToFirstToken}ms`
+                : "N/A";
+            const tokens = r.stats.tokenUsage
+                ? r.stats.tokenUsage.total.toString()
+                : "N/A";
+            console.log(`${r.modelId.padEnd(40)} | ${duration.padEnd(10)} | ${ttft.padEnd(10)} | ${tokens.padEnd(10)}`);
+        });
+    }
+    return results;
+}
+/**
+ * Combine multiple PRDs into a single master PRD
+ */
+async function combinePRDs(prds, description, modelStr, stream, reasoningOverride) {
+    console.log(chalk_1.default.blue("\nCombining PRDs into master PRD..."));
+    const aiOperations = (0, ai_service_factory_1.getAIOperations)();
+    const combineModelConfig = (0, prd_1.parseModelString)(modelStr);
+    const streamingOptions = (0, streaming_options_1.createStreamingOptions)(stream, "Combining PRDs");
+    return await aiOperations.combinePRDs(prds, description, {
+        provider: (combineModelConfig.provider ||
+            config_1.configManager.getAIConfig().provider),
+        model: combineModelConfig.model,
+        reasoning: reasoningOverride || combineModelConfig.reasoning
+            ? {
+                maxTokens: parseInt(reasoningOverride || combineModelConfig.reasoning || "0"),
+            }
+            : undefined,
+    }, undefined, undefined, streamingOptions);
+}

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAYpC,QAAA,MAAM,OAAO,SAAgB,CAAC;AA+C9B;;;GAGG;AACH,eAAO,MAAM,MAAM,qBAgBlB,CAAC;AAEF;;GAEG;AACH,OAAO,EAAE,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,QAAA,MAAM,OAAO,SAAgB,CAAC;AAgD9B;;;GAGG;AACH,eAAO,MAAM,MAAM,qBAgBlB,CAAC;AAEF;;GAEG;AACH,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/index.js

@@ -19,6 +19,7 @@ const init_1 = require("./commands/init");
 const prompt_1 = require("./commands/prompt");
 const workflow_1 = require("./commands/workflow");
 const benchmark_1 = require("./commands/benchmark");
+const install_1 = require("./commands/install");
 const config_2 = require("./lib/config");
 const logger_1 = require("./lib/hooks/logger");
 const program = new commander_1.Command();
@@ -36,6 +37,7 @@ program.addCommand(prompt_1.promptCommand);
 program.addCommand(init_1.initCommand);
 program.addCommand(workflow_1.workflowCommand);
 program.addCommand(benchmark_1.benchmarkCommand);
+program.addCommand(install_1.installCommand);
 // Default action - show help
 program.action(() => {
     console.log(chalk_1.default.blue("🚀 AI-Powered Task Management CLI"));
@@ -52,7 +54,7 @@ program.action(() => {
 // Error handling
 program.on("command:*", (operands) => {
     console.error(chalk_1.default.red(`Unknown command: ${operands[0]}`));
-    console.log(chalk_1.default.blue("Available commands: config, tasks, prd, prompt, init, workflow"));
+    console.log(chalk_1.default.blue("Available commands: config, tasks, prd, prompt, init, workflow, benchmark, install"));
     console.log(chalk_1.default.blue("Use --help for available commands"));
     process.exit(1);
 });

package/dist/lib/ai-service/gemini-proxy.d.ts

@@ -0,0 +1,15 @@
+import { LanguageModelV2 } from "@ai-sdk/provider";
+export declare class GeminiProviderProxy implements LanguageModelV2 {
+    readonly specificationVersion = "v2";
+    readonly provider = "gemini";
+    readonly modelId: string;
+    readonly defaultObjectGenerationMode = "json";
+    readonly supportedUrls: Record<string, RegExp[]>;
+    private readonly config;
+    private realModel;
+    constructor(modelId: string, config: any);
+    private getRealModel;
+    doGenerate(options: any): Promise<any>;
+    doStream(options: any): Promise<any>;
+}
+//# sourceMappingURL=gemini-proxy.d.ts.map

package/dist/lib/ai-service/gemini-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gemini-proxy.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/gemini-proxy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAInD,qBAAa,mBAAoB,YAAW,eAAe;IACzD,QAAQ,CAAC,oBAAoB,QAAQ;IACrC,QAAQ,CAAC,QAAQ,YAAY;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,2BAA2B,UAAU;IAC9C,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAM;IACtD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAM;IAC7B,OAAO,CAAC,SAAS,CAAgC;gBAErC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,GAAG;YAK1B,YAAY;IAsDpB,UAAU,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAKtC,QAAQ,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;CAI3C"}

package/dist/lib/ai-service/gemini-proxy.js

@@ -0,0 +1,90 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiProviderProxy = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class GeminiProviderProxy {
+    specificationVersion = "v2";
+    provider = "gemini";
+    modelId;
+    defaultObjectGenerationMode = "json";
+    supportedUrls = {}; // Explicitly typed to match interface
+    config;
+    realModel = null;
+    constructor(modelId, config) {
+        this.modelId = modelId;
+        this.config = config;
+    }
+    async getRealModel() {
+        if (!this.realModel) {
+            // The dependency 'ai-sdk-provider-gemini-cli' is misconfigured:
+            // it claims to be ESM ("type": "module") but its "main" points to CJS.
+            // This crashes Node.js with "module is not defined".
+            // We must load the ESM entry point ("index.mjs") explicitly.
+            const projectRoot = process.cwd();
+            // Attempt to resolve the path explicitly to dist/index.mjs
+            let modulePath = path.join(projectRoot, "node_modules", "ai-sdk-provider-gemini-cli", "dist", "index.mjs");
+            if (!fs.existsSync(modulePath)) {
+                // Fallback for nested dep or monorepo structures (common in workspaces)
+                modulePath = path.join(projectRoot, "..", "..", "node_modules", "ai-sdk-provider-gemini-cli", "dist", "index.mjs");
+                if (!fs.existsSync(modulePath)) {
+                    console.warn("GeminiProxy: Could not locate index.mjs manually. Falling back to default resolution.");
+                    // Last ditch: try to rely on standard resolution.
+                    // This will likely crash if the package isn't fixed, but it's the only remaining option.
+                    const { createGeminiProvider } = await Promise.resolve().then(() => __importStar(require("ai-sdk-provider-gemini-cli")));
+                    const provider = createGeminiProvider(this.config);
+                    this.realModel = provider(this.modelId);
+                    return this.realModel;
+                }
+            }
+            // Dynamic import of the absolute path bypasses 'exports' restrictions
+            // and forces Node to load the correct ESM file.
+            const { createGeminiProvider } = await Promise.resolve(`${modulePath}`).then(s => __importStar(require(s)));
+            const provider = createGeminiProvider(this.config);
+            this.realModel = provider(this.modelId);
+        }
+        return this.realModel;
+    }
+    async doGenerate(options) {
+        const model = await this.getRealModel();
+        return model.doGenerate(options);
+    }
+    async doStream(options) {
+        const model = await this.getRealModel();
+        return model.doStream(options);
+    }
+}
+exports.GeminiProviderProxy = GeminiProviderProxy;

package/dist/lib/ai-service/json-parser.d.ts

@@ -3,7 +3,20 @@ export declare class JSONParser {
     /**
      * Extracts JSON from text that may contain markdown codeblocks or other formatting
      */
+    /**
+     * Extracts the first valid JSON object or array from text using a stack-based approach
+     * This is much more robust than regex for nested structures or text with multiple brace pairs
+     */
     private extractJSONString;
+    /**
+     * Extracts a balanced string starting from a specific index
+     */
+    private extractBalancedString;
+    /**
+     * Cleans JSON string by removing comments and trailing commas
+     * This handles "valid JS object" format that LLMs often output
+     */
+    private cleanJSON;
     /**
      * Normalizes object keys to handle case variations (e.g., "Tasks" -> "tasks")
      */
@@ -12,10 +25,9 @@ export declare class JSONParser {
      * Parses JSON from AI text response with improved error handling
      * Now supports:
      * - Extracting from markdown codeblocks (```json, ```JSON, or ```)
-     * - Case-insensitive property names (Tasks -> tasks, Summary -> summary)
-     * - Multiple extraction strategies
-     *
-     * @deprecated Use generateObject instead for structured output
+     * - Stack-based extraction for robustness against surrounding text
+     * - Comment and trailing comma removal
+     * - Case-insensitive property names
      */
     parseJSONFromResponse<T>(text: string): JSONParseResult<T>;
 }

package/dist/lib/ai-service/json-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"json-parser.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/json-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,qBAAa,UAAU;IACrB;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAmCzB;;OAEG;IACH,OAAO,CAAC,aAAa;IAsBrB;;;;;;;;OAQG;IACH,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC;CAgC3D"}
+{"version":3,"file":"json-parser.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/json-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAE9C,qBAAa,UAAU;IACrB;;OAEG;IACH;;;OAGG;IACH,OAAO,CAAC,iBAAiB;IA8DzB;;OAEG;IACH,OAAO,CAAC,qBAAqB;IA2C7B;;;OAGG;IACH,OAAO,CAAC,SAAS;IAOjB;;OAEG;IACH,OAAO,CAAC,aAAa;IAsBrB;;;;;;;OAOG;IACH,qBAAqB,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC;CAwC3D"}