task-o-matic 0.0.12 → 0.0.14

package/dist/utils/model-executor-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-executor-parser.d.ts","sourceRoot":"","sources":["../../src/utils/model-executor-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,YAAY,EAKzC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,EAAE,CA2BlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,IAAI,YAAY,CAE3E"}

package/dist/utils/model-executor-parser.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_EXECUTORS = void 0;
+exports.parseTryModels = parseTryModels;
+exports.validateExecutor = validateExecutor;
+/**
+ * Valid executor tools
+ */
+exports.VALID_EXECUTORS = [
+    "opencode",
+    "claude",
+    "gemini",
+    "codex",
+];
+/**
+ * Parse --try-models option into ModelAttemptConfig array
+ * Supports formats:
+ * - "model1,model2,model3" - just models (uses default executor)
+ * - "opencode:gpt-4o,claude:sonnet-4" - executor:model format
+ * - Mixed: "gpt-4o,claude:sonnet-4,gemini:gemini-2.0"
+ *
+ * @param value - Comma-separated model/executor specifications
+ * @returns Array of model attempt configurations
+ * @throws Error if an invalid executor is specified
+ *
+ * @example
+ * ```typescript
+ * parseTryModels("gpt-4o-mini,gpt-4o"); // [{ model: "gpt-4o-mini" }, { model: "gpt-4o" }]
+ * parseTryModels("opencode:gpt-4o,claude:sonnet-4"); // [{ executor: "opencode", model: "gpt-4o" }, ...]
+ * ```
+ */
+function parseTryModels(value) {
+    return value.split(",").map((item) => {
+        const trimmed = item.trim();
+        // Check if it includes executor specification (executor:model format)
+        if (trimmed.includes(":")) {
+            const [executor, model] = trimmed.split(":");
+            if (!exports.VALID_EXECUTORS.includes(executor)) {
+                throw new Error(`Invalid executor "${executor}" in --try-models. Must be one of: ${exports.VALID_EXECUTORS.join(", ")}`);
+            }
+            return {
+                executor: executor,
+                model: model.trim(),
+            };
+        }
+        // Just a model name - use default executor
+        return {
+            model: trimmed,
+        };
+    });
+}
+/**
+ * Validate that an executor name is valid
+ *
+ * @param executor - Executor name to validate
+ * @returns Type guard confirming executor is valid
+ *
+ * @example
+ * ```typescript
+ * if (validateExecutor(options.tool)) {
+ *   // TypeScript knows options.tool is ExecutorTool
+ * }
+ * ```
+ */
+function validateExecutor(executor) {
+    return exports.VALID_EXECUTORS.includes(executor);
+}

package/dist/utils/progress-tracking.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Progress event payload from AI operations
+ */
+export interface ProgressEvent {
+    taskId?: string;
+    operation?: string;
+    step?: string;
+    progress?: number;
+    message?: string;
+    phase?: string;
+    [key: string]: any;
+}
+/**
+ * Execute an async function with automatic progress tracking
+ * Registers a progress handler, executes the function, and cleans up
+ *
+ * @param fn - The async function to execute with progress tracking
+ * @returns The result of the function
+ *
+ * @example
+ * ```typescript
+ * const result = await withProgressTracking(async () => {
+ *   return await taskService.enhanceTask(taskId);
+ * });
+ * ```
+ */
+export declare function withProgressTracking<T>(fn: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=progress-tracking.d.ts.map

package/dist/utils/progress-tracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"progress-tracking.d.ts","sourceRoot":"","sources":["../../src/utils/progress-tracking.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAiBD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,oBAAoB,CAAC,CAAC,EAC1C,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CASZ"}

package/dist/utils/progress-tracking.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withProgressTracking = withProgressTracking;
+const hooks_1 = require("../lib/hooks");
+/**
+ * Display progress information to the console
+ */
+function displayProgress(payload) {
+    const { operation, step, message, phase } = payload;
+    if (phase) {
+        console.log(`[${phase}]`, message || step || operation || "");
+    }
+    else if (operation && step) {
+        console.log(`${operation}: ${step}`);
+    }
+    else if (message) {
+        console.log(message);
+    }
+}
+/**
+ * Execute an async function with automatic progress tracking
+ * Registers a progress handler, executes the function, and cleans up
+ *
+ * @param fn - The async function to execute with progress tracking
+ * @returns The result of the function
+ *
+ * @example
+ * ```typescript
+ * const result = await withProgressTracking(async () => {
+ *   return await taskService.enhanceTask(taskId);
+ * });
+ * ```
+ */
+async function withProgressTracking(fn) {
+    const progressHandler = (payload) => displayProgress(payload);
+    hooks_1.hooks.on("task:progress", progressHandler);
+    try {
+        return await fn();
+    }
+    finally {
+        hooks_1.hooks.off("task:progress", progressHandler);
+    }
+}

package/dist/utils/stack-formatter.d.ts

@@ -1,5 +1,6 @@
+import type { BTSFrontend } from "../types/index.js";
 export interface StackInfo {
-    frontend: string;
+    frontend: BTSFrontend | BTSFrontend[];
     backend: string;
     database: string;
     orm: string;

package/dist/utils/stack-formatter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stack-formatter.d.ts","sourceRoot":"","sources":["../../src/utils/stack-formatter.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAyB3E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAMjF"}
+{"version":3,"file":"stack-formatter.d.ts","sourceRoot":"","sources":["../../src/utils/stack-formatter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,WAAW,GAAG,WAAW,EAAE,CAAC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CA6B3E;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAUjF"}

package/dist/utils/stack-formatter.js

@@ -6,8 +6,11 @@ function formatStackInfo(stack) {
     if (!stack) {
         return "Not detected";
     }
+    const frontendStr = Array.isArray(stack.frontend)
+        ? stack.frontend.join(", ")
+        : stack.frontend;
     const parts = [
-        `Frontend: ${stack.frontend}`,
+        `Frontend: ${frontendStr}`,
         `Backend: ${stack.backend}`
     ];
     if (stack.database !== 'none') {
@@ -26,5 +29,8 @@ function formatStackForContext(stack) {
     if (!stack) {
         return "";
     }
-    return `Technology Stack: ${stack.frontend} + ${stack.backend} + ${stack.database}`;
+    const frontendStr = Array.isArray(stack.frontend)
+        ? stack.frontend.join(" + ")
+        : stack.frontend;
+    return `Technology Stack: ${frontendStr} + ${stack.backend} + ${stack.database}`;
 }

package/dist/utils/storage-utils.d.ts

@@ -0,0 +1,49 @@
+import { Task } from "../types/index.js";
+/**
+ * Ensures a task is not null, throwing an error if it is.
+ * Useful for enforcing null checks after storage operations.
+ *
+ * @param task - Task that may be null
+ * @param taskId - ID of the task for error message
+ * @returns The task if not null
+ * @throws Error if task is null
+ *
+ * @example
+ * ```typescript
+ * const task = await storage.getTask(taskId);
+ * const validTask = requireTask(task, taskId);
+ * console.log(validTask.title); // Safe - never null
+ * ```
+ */
+export declare function requireTask(task: Task | null, taskId: string): Task;
+/**
+ * Ensures multiple tasks are not null, throwing an error if any is null.
+ *
+ * @param tasks - Array of tasks that may contain nulls
+ * @param context - Context for error message (e.g., "subtasks", "dependencies")
+ * @returns Array of tasks with nulls filtered out
+ * @throws Error if any task is null
+ */
+export declare function requireTasks(tasks: (Task | null)[], context?: string): Task[];
+/**
+ * Filters out null tasks from an array, with type narrowing.
+ *
+ * @param tasks - Array of tasks that may contain nulls
+ * @returns Array of tasks with nulls removed
+ *
+ * @example
+ * ```typescript
+ * const tasks = await Promise.all(ids.map(id => storage.getTask(id)));
+ * const validTasks = filterNullTasks(tasks);
+ * // validTasks has type Task[] (no null)
+ * ```
+ */
+export declare function filterNullTasks(tasks: (Task | null)[]): Task[];
+/**
+ * Validates that a task ID is a non-empty string.
+ *
+ * @param taskId - Task ID to validate
+ * @throws Error if task ID is invalid
+ */
+export declare function validateTaskId(taskId: string): void;
+//# sourceMappingURL=storage-utils.d.ts.map

package/dist/utils/storage-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-utils.d.ts","sourceRoot":"","sources":["../../src/utils/storage-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAEzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAKnE;AAED;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,KAAK,EAAE,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,EACtB,OAAO,GAAE,MAAgB,GACxB,IAAI,EAAE,CAiBR;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,CAAC,IAAI,GAAG,IAAI,CAAC,EAAE,GAAG,IAAI,EAAE,CAE9D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAInD"}

package/dist/utils/storage-utils.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireTask = requireTask;
+exports.requireTasks = requireTasks;
+exports.filterNullTasks = filterNullTasks;
+exports.validateTaskId = validateTaskId;
+/**
+ * Ensures a task is not null, throwing an error if it is.
+ * Useful for enforcing null checks after storage operations.
+ *
+ * @param task - Task that may be null
+ * @param taskId - ID of the task for error message
+ * @returns The task if not null
+ * @throws Error if task is null
+ *
+ * @example
+ * ```typescript
+ * const task = await storage.getTask(taskId);
+ * const validTask = requireTask(task, taskId);
+ * console.log(validTask.title); // Safe - never null
+ * ```
+ */
+function requireTask(task, taskId) {
+    if (!task) {
+        throw new Error(`Task not found: ${taskId}`);
+    }
+    return task;
+}
+/**
+ * Ensures multiple tasks are not null, throwing an error if any is null.
+ *
+ * @param tasks - Array of tasks that may contain nulls
+ * @param context - Context for error message (e.g., "subtasks", "dependencies")
+ * @returns Array of tasks with nulls filtered out
+ * @throws Error if any task is null
+ */
+function requireTasks(tasks, context = "tasks") {
+    const validTasks = [];
+    const missingIds = [];
+    tasks.forEach((task, index) => {
+        if (!task) {
+            missingIds.push(`index ${index}`);
+        }
+        else {
+            validTasks.push(task);
+        }
+    });
+    if (missingIds.length > 0) {
+        throw new Error(`Missing ${context}: ${missingIds.join(", ")}`);
+    }
+    return validTasks;
+}
+/**
+ * Filters out null tasks from an array, with type narrowing.
+ *
+ * @param tasks - Array of tasks that may contain nulls
+ * @returns Array of tasks with nulls removed
+ *
+ * @example
+ * ```typescript
+ * const tasks = await Promise.all(ids.map(id => storage.getTask(id)));
+ * const validTasks = filterNullTasks(tasks);
+ * // validTasks has type Task[] (no null)
+ * ```
+ */
+function filterNullTasks(tasks) {
+    return tasks.filter((task) => task !== null);
+}
+/**
+ * Validates that a task ID is a non-empty string.
+ *
+ * @param taskId - Task ID to validate
+ * @throws Error if task ID is invalid
+ */
+function validateTaskId(taskId) {
+    if (!taskId || typeof taskId !== "string" || !taskId.trim()) {
+        throw new Error("Invalid task ID: must be a non-empty string");
+    }
+}

package/dist/utils/streaming-utils.d.ts

@@ -0,0 +1,38 @@
+import { StreamingOptions } from "../types/index.js";
+/**
+ * Token usage metrics from AI operations
+ */
+export interface TokenUsage {
+    prompt: number;
+    completion: number;
+    total: number;
+}
+export interface MetricsTracker {
+    tokenUsage: TokenUsage;
+    timeToFirstToken: number | undefined;
+}
+export interface MetricsStreamingResult {
+    options: StreamingOptions;
+    getMetrics: () => MetricsTracker;
+}
+/**
+ * Creates streaming options with automatic metrics tracking.
+ * Wraps provided streaming callbacks to capture token usage and timing metrics.
+ *
+ * @param streamingOptions - Optional base streaming options to wrap
+ * @param aiStartTime - Optional timestamp when AI operation started (for measuring time to first token)
+ * @returns Object containing wrapped streaming options and metrics getter
+ *
+ * @example
+ * ```typescript
+ * const aiStartTime = Date.now();
+ * const { options, getMetrics } = createMetricsStreamingOptions(userCallbacks, aiStartTime);
+ *
+ * await generateText({ model, prompt, ...options });
+ *
+ * const { tokenUsage, timeToFirstToken } = getMetrics();
+ * console.log(`Used ${tokenUsage.total} tokens in ${timeToFirstToken}ms`);
+ * ```
+ */
+export declare function createMetricsStreamingOptions(streamingOptions?: StreamingOptions, aiStartTime?: number): MetricsStreamingResult;
+//# sourceMappingURL=streaming-utils.d.ts.map

package/dist/utils/streaming-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming-utils.d.ts","sourceRoot":"","sources":["../../src/utils/streaming-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,cAAc;IAC7B,UAAU,EAAE,UAAU,CAAC;IACvB,gBAAgB,EAAE,MAAM,GAAG,SAAS,CAAC;CACtC;AAED,MAAM,WAAW,sBAAsB;IACrC,OAAO,EAAE,gBAAgB,CAAC;IAC1B,UAAU,EAAE,MAAM,cAAc,CAAC;CAClC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,6BAA6B,CAC3C,gBAAgB,CAAC,EAAE,gBAAgB,EACnC,WAAW,CAAC,EAAE,MAAM,GACnB,sBAAsB,CAsCxB"}

package/dist/utils/streaming-utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMetricsStreamingOptions = createMetricsStreamingOptions;
+/**
+ * Creates streaming options with automatic metrics tracking.
+ * Wraps provided streaming callbacks to capture token usage and timing metrics.
+ *
+ * @param streamingOptions - Optional base streaming options to wrap
+ * @param aiStartTime - Optional timestamp when AI operation started (for measuring time to first token)
+ * @returns Object containing wrapped streaming options and metrics getter
+ *
+ * @example
+ * ```typescript
+ * const aiStartTime = Date.now();
+ * const { options, getMetrics } = createMetricsStreamingOptions(userCallbacks, aiStartTime);
+ *
+ * await generateText({ model, prompt, ...options });
+ *
+ * const { tokenUsage, timeToFirstToken } = getMetrics();
+ * console.log(`Used ${tokenUsage.total} tokens in ${timeToFirstToken}ms`);
+ * ```
+ */
+function createMetricsStreamingOptions(streamingOptions, aiStartTime) {
+    let tokenUsage = { prompt: 0, completion: 0, total: 0 };
+    let timeToFirstToken = undefined;
+    const wrappedOptions = {
+        onFinish: async (result) => {
+            // Extract token usage from result
+            if (result.usage) {
+                tokenUsage = {
+                    prompt: result.usage.inputTokens || result.usage.promptTokens || 0,
+                    completion: result.usage.outputTokens || result.usage.completionTokens || 0,
+                    total: result.usage.totalTokens || 0,
+                };
+            }
+            // Call original onFinish callback if provided
+            await streamingOptions?.onFinish?.(result);
+        },
+        onChunk: (chunk) => {
+            // Measure time to first token (ignore empty/whitespace chunks)
+            if (chunk && chunk.trim() && !timeToFirstToken && aiStartTime) {
+                timeToFirstToken = Date.now() - aiStartTime;
+            }
+            // Call original onChunk callback if provided
+            streamingOptions?.onChunk?.(chunk);
+        },
+        onError: (error) => {
+            // Pass through error callback
+            streamingOptions?.onError?.(error);
+        },
+    };
+    return {
+        options: wrappedOptions,
+        getMetrics: () => ({ tokenUsage, timeToFirstToken }),
+    };
+}