task-o-matic-core 0.1.0

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

@@ -0,0 +1,107 @@
+/**
+ * Validates that a file exists at the given path (synchronous).
+ * Throws an error with a custom message if the file doesn't exist.
+ *
+ * @param filePath - Path to the file to validate
+ * @param customMessage - Optional custom error message
+ * @throws TaskOMaticError if file doesn't exist
+ *
+ * @example
+ * ```typescript
+ * validateFileExists("./config.json", "Configuration file not found");
+ * // Throws: TaskOMaticError with code INVALID_INPUT if file doesn't exist
+ * ```
+ */
+export declare function validateFileExists(filePath: string, customMessage?: string): void;
+/**
+ * Validates that a file exists at the given path (asynchronous).
+ * Throws an error with a custom message if the file doesn't exist.
+ *
+ * @param filePath - Path to the file to validate
+ * @param customMessage - Optional custom error message
+ * @throws TaskOMaticError if file doesn't exist
+ *
+ * @example
+ * ```typescript
+ * await validateFileExistsAsync("./data.json");
+ * // Throws: TaskOMaticError with code INVALID_INPUT if file doesn't exist
+ * ```
+ */
+export declare function validateFileExistsAsync(filePath: string, customMessage?: string): Promise<void>;
+/**
+ * Checks if a file exists at the given path (synchronous).
+ * Returns true if file exists, false otherwise.
+ * Unlike validateFileExists, this doesn't throw an error.
+ *
+ * @param filePath - Path to check
+ * @returns true if file exists, false otherwise
+ */
+export declare function fileExists(filePath: string): boolean;
+/**
+ * Checks if a file exists at the given path (asynchronous).
+ * Returns true if file exists, false otherwise.
+ * Unlike validateFileExistsAsync, this doesn't throw an error.
+ *
+ * @param filePath - Path to check
+ * @returns Promise resolving to true if file exists, false otherwise
+ */
+export declare function fileExistsAsync(filePath: string): Promise<boolean>;
+/**
+ * Saves a file to the PRD directory, ensuring the directory exists.
+ * If no output directory is specified, uses `.task-o-matic/prd/` by default.
+ *
+ * @param content - Content to write to the file
+ * @param filename - Filename (defaults to "prd.md")
+ * @param outputDir - Optional output directory override
+ * @returns Full path to the saved file
+ * @throws TaskOMaticError if file saving fails
+ *
+ * @example
+ * ```typescript
+ * // Save to default location (.task-o-matic/prd/prd.md)
+ * const path = savePRDFile("# My PRD\n...");
+ *
+ * // Save with custom filename
+ * const path = savePRDFile("# My PRD\n...", "custom-prd.md");
+ *
+ * // Save to custom directory
+ * const path = savePRDFile("# My PRD\n...", "prd.md", "./docs");
+ * ```
+ */
+export declare function savePRDFile(content: string, filename?: string, outputDir?: string): string;
+/**
+ * Saves a stack configuration to a JSON file.
+ * If no output path is specified, saves to `.task-o-matic/stack.json`.
+ *
+ * @param config - BTSConfig object to save
+ * @param outputPath - Optional custom output path
+ * @returns Full path to the saved file
+ *
+ * @example
+ * ```typescript
+ * // Save to default location
+ * const path = saveStackFile(config);
+ *
+ * // Save to custom location
+ * const path = saveStackFile(config, "./my-project/stack.json");
+ * ```
+ */
+export declare function saveStackFile(config: object, outputPath?: string): string;
+/**
+ * Loads a stack configuration from a JSON file.
+ * If no input path is specified, loads from `.task-o-matic/stack.json`.
+ *
+ * @param inputPath - Optional custom input path
+ * @returns The parsed BTSConfig object, or null if file doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Load from default location
+ * const config = loadStackFile();
+ *
+ * // Load from custom location
+ * const config = loadStackFile("./my-project/stack.json");
+ * ```
+ */
+export declare function loadStackFile<T = Record<string, unknown>>(inputPath?: string): T | null;
+//# sourceMappingURL=file-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-utils.d.ts","sourceRoot":"","sources":["../../src/utils/file-utils.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,MAAM,GACrB,IAAI,CAUN;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,aAAa,CAAC,EAAE,MAAM,GACrB,OAAO,CAAC,IAAI,CAAC,CAYf;AAED;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED;;;;;;;GAOG;AACH,wBAAsB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAOxE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,QAAQ,GAAE,MAAiB,EAC3B,SAAS,CAAC,EAAE,MAAM,GACjB,MAAM,CAYR;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAWzE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,aAAa,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvD,SAAS,CAAC,EAAE,MAAM,GACjB,CAAC,GAAG,IAAI,CAUV"}

package/dist/utils/file-utils.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFileExists = validateFileExists;
+exports.validateFileExistsAsync = validateFileExistsAsync;
+exports.fileExists = fileExists;
+exports.fileExistsAsync = fileExistsAsync;
+exports.savePRDFile = savePRDFile;
+exports.saveStackFile = saveStackFile;
+exports.loadStackFile = loadStackFile;
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+const task_o_matic_error_1 = require("./task-o-matic-error");
+const config_1 = require("../lib/config");
+/**
+ * Validates that a file exists at the given path (synchronous).
+ * Throws an error with a custom message if the file doesn't exist.
+ *
+ * @param filePath - Path to the file to validate
+ * @param customMessage - Optional custom error message
+ * @throws TaskOMaticError if file doesn't exist
+ *
+ * @example
+ * ```typescript
+ * validateFileExists("./config.json", "Configuration file not found");
+ * // Throws: TaskOMaticError with code INVALID_INPUT if file doesn't exist
+ * ```
+ */
+function validateFileExists(filePath, customMessage) {
+    if (!(0, fs_1.existsSync)(filePath)) {
+        throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_INPUT, customMessage || `File not found: ${filePath}`, {
+            suggestions: ["Verify the file path is correct."],
+        });
+    }
+}
+/**
+ * Validates that a file exists at the given path (asynchronous).
+ * Throws an error with a custom message if the file doesn't exist.
+ *
+ * @param filePath - Path to the file to validate
+ * @param customMessage - Optional custom error message
+ * @throws TaskOMaticError if file doesn't exist
+ *
+ * @example
+ * ```typescript
+ * await validateFileExistsAsync("./data.json");
+ * // Throws: TaskOMaticError with code INVALID_INPUT if file doesn't exist
+ * ```
+ */
+async function validateFileExistsAsync(filePath, customMessage) {
+    try {
+        await (0, promises_1.access)(filePath, promises_1.constants.F_OK);
+    }
+    catch {
+        throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.INVALID_INPUT, customMessage || `File not found: ${filePath}`, {
+            suggestions: ["Verify the file path is correct."],
+        });
+    }
+}
+/**
+ * Checks if a file exists at the given path (synchronous).
+ * Returns true if file exists, false otherwise.
+ * Unlike validateFileExists, this doesn't throw an error.
+ *
+ * @param filePath - Path to check
+ * @returns true if file exists, false otherwise
+ */
+function fileExists(filePath) {
+    return (0, fs_1.existsSync)(filePath);
+}
+/**
+ * Checks if a file exists at the given path (asynchronous).
+ * Returns true if file exists, false otherwise.
+ * Unlike validateFileExistsAsync, this doesn't throw an error.
+ *
+ * @param filePath - Path to check
+ * @returns Promise resolving to true if file exists, false otherwise
+ */
+async function fileExistsAsync(filePath) {
+    try {
+        await (0, promises_1.access)(filePath, promises_1.constants.F_OK);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Saves a file to the PRD directory, ensuring the directory exists.
+ * If no output directory is specified, uses `.task-o-matic/prd/` by default.
+ *
+ * @param content - Content to write to the file
+ * @param filename - Filename (defaults to "prd.md")
+ * @param outputDir - Optional output directory override
+ * @returns Full path to the saved file
+ * @throws TaskOMaticError if file saving fails
+ *
+ * @example
+ * ```typescript
+ * // Save to default location (.task-o-matic/prd/prd.md)
+ * const path = savePRDFile("# My PRD\n...");
+ *
+ * // Save with custom filename
+ * const path = savePRDFile("# My PRD\n...", "custom-prd.md");
+ *
+ * // Save to custom directory
+ * const path = savePRDFile("# My PRD\n...", "prd.md", "./docs");
+ * ```
+ */
+function savePRDFile(content, filename = "prd.md", outputDir) {
+    const taskOMaticDir = config_1.configManager.getTaskOMaticDir();
+    const prdDir = outputDir || (0, path_1.join)(taskOMaticDir, "prd");
+    if (!(0, fs_1.existsSync)(prdDir)) {
+        (0, fs_1.mkdirSync)(prdDir, { recursive: true });
+    }
+    const path = (0, path_1.join)(prdDir, filename);
+    (0, fs_1.writeFileSync)(path, content);
+    return path;
+}
+/**
+ * Saves a stack configuration to a JSON file.
+ * If no output path is specified, saves to `.task-o-matic/stack.json`.
+ *
+ * @param config - BTSConfig object to save
+ * @param outputPath - Optional custom output path
+ * @returns Full path to the saved file
+ *
+ * @example
+ * ```typescript
+ * // Save to default location
+ * const path = saveStackFile(config);
+ *
+ * // Save to custom location
+ * const path = saveStackFile(config, "./my-project/stack.json");
+ * ```
+ */
+function saveStackFile(config, outputPath) {
+    const taskOMaticDir = config_1.configManager.getTaskOMaticDir();
+    const stackPath = outputPath || (0, path_1.join)(taskOMaticDir, "stack.json");
+    const dir = (0, path_1.dirname)(stackPath);
+    if (!(0, fs_1.existsSync)(dir)) {
+        (0, fs_1.mkdirSync)(dir, { recursive: true });
+    }
+    (0, fs_1.writeFileSync)(stackPath, JSON.stringify(config, null, 2));
+    return stackPath;
+}
+/**
+ * Loads a stack configuration from a JSON file.
+ * If no input path is specified, loads from `.task-o-matic/stack.json`.
+ *
+ * @param inputPath - Optional custom input path
+ * @returns The parsed BTSConfig object, or null if file doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Load from default location
+ * const config = loadStackFile();
+ *
+ * // Load from custom location
+ * const config = loadStackFile("./my-project/stack.json");
+ * ```
+ */
+function loadStackFile(inputPath) {
+    const taskOMaticDir = config_1.configManager.getTaskOMaticDir();
+    const stackPath = inputPath || (0, path_1.join)(taskOMaticDir, "stack.json");
+    if (!(0, fs_1.existsSync)(stackPath)) {
+        return null;
+    }
+    const content = (0, fs_1.readFileSync)(stackPath, "utf-8");
+    return JSON.parse(content);
+}

package/dist/utils/id-generator.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Generates unique task IDs with consistent format.
+ * Uses timestamp + random hex for uniqueness.
+ */
+export declare class TaskIDGenerator {
+    /**
+     * Generates a unique task ID with format: prefix-timestamp-random
+     *
+     * @param prefix - Prefix for the ID (default: "task")
+     * @returns Unique task ID
+     *
+     * @example
+     * ```typescript
+     * const id = TaskIDGenerator.generate();
+     * // Returns: "task-1733750400000-a1b2c3d4"
+     *
+     * const customId = TaskIDGenerator.generate("subtask");
+     * // Returns: "subtask-1733750400000-e5f6g7h8"
+     * ```
+     */
+    static generate(prefix?: string): string;
+    /**
+     * Validates a task ID format.
+     * Accepts three formats:
+     * - Timestamped: "task-1234567890-abcd1234"
+     * - Hierarchical: "1.2.3"
+     * - Numeric: "123"
+     *
+     * @param id - Task ID to validate
+     * @returns true if ID format is valid
+     *
+     * @example
+     * ```typescript
+     * TaskIDGenerator.validate("task-1234-abcd"); // true
+     * TaskIDGenerator.validate("1.2.3"); // true
+     * TaskIDGenerator.validate("123"); // true
+     * TaskIDGenerator.validate("invalid!"); // false
+     * ```
+     */
+    static validate(id: string): boolean;
+    /**
+     * Checks if an ID is unique within a set of existing IDs.
+     *
+     * @param id - ID to check
+     * @param existingIds - Set of existing IDs
+     * @returns true if ID is unique
+     */
+    static isUnique(id: string, existingIds: Set<string>): boolean;
+    /**
+     * Generates a unique ID that doesn't exist in the provided set.
+     * Retries up to maxAttempts times if collisions occur.
+     *
+     * @param existingIds - Set of existing IDs to avoid
+     * @param prefix - Prefix for the ID
+     * @param maxAttempts - Maximum number of generation attempts
+     * @returns Unique task ID
+     * @throws TaskOMaticError if unable to generate unique ID after maxAttempts
+     */
+    static generateUnique(existingIds: Set<string>, prefix?: string, maxAttempts?: number): string;
+    /**
+     * Generates a hierarchical child ID from a parent ID.
+     * If parent is "1.2", generates "1.2.1", "1.2.2", etc.
+     *
+     * @param parentId - Parent task ID
+     * @param childIndex - Index of the child (1-based)
+     * @returns Child task ID
+     *
+     * @example
+     * ```typescript
+     * TaskIDGenerator.generateChildId("1", 1); // "1.1"
+     * TaskIDGenerator.generateChildId("1.2", 3); // "1.2.3"
+     * ```
+     */
+    static generateChildId(parentId: string, childIndex: number): string;
+    /**
+     * Parses a hierarchical ID to extract parent ID and child index.
+     *
+     * @param id - Hierarchical task ID
+     * @returns Object with parentId and childIndex, or null if not hierarchical
+     *
+     * @example
+     * ```typescript
+     * TaskIDGenerator.parseHierarchicalId("1.2.3");
+     * // Returns: { parentId: "1.2", childIndex: 3 }
+     * ```
+     */
+    static parseHierarchicalId(id: string): {
+        parentId: string;
+        childIndex: number;
+    } | null;
+}
+//# sourceMappingURL=id-generator.d.ts.map

package/dist/utils/id-generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"id-generator.d.ts","sourceRoot":"","sources":["../../src/utils/id-generator.ts"],"names":[],"mappings":"AAMA;;;GAGG;AACH,qBAAa,eAAe;IAC1B;;;;;;;;;;;;;;OAcG;IACH,MAAM,CAAC,QAAQ,CAAC,MAAM,GAAE,MAAe,GAAG,MAAM;IAMhD;;;;;;;;;;;;;;;;;OAiBG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IA0BpC;;;;;;OAMG;IACH,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,EAAE,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,OAAO;IAI9D;;;;;;;;;OASG;IACH,MAAM,CAAC,cAAc,CACnB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,EACxB,MAAM,GAAE,MAAe,EACvB,WAAW,GAAE,MAAW,GACvB,MAAM;IAoBT;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM;IAIpE;;;;;;;;;;;OAWG;IACH,MAAM,CAAC,mBAAmB,CACxB,EAAE,EAAE,MAAM,GACT;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI;CAcnD"}

package/dist/utils/id-generator.js

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskIDGenerator = void 0;
+const crypto_1 = require("crypto");
+const task_o_matic_error_1 = require("./task-o-matic-error");
+/**
+ * Generates unique task IDs with consistent format.
+ * Uses timestamp + random hex for uniqueness.
+ */
+class TaskIDGenerator {
+    /**
+     * Generates a unique task ID with format: prefix-timestamp-random
+     *
+     * @param prefix - Prefix for the ID (default: "task")
+     * @returns Unique task ID
+     *
+     * @example
+     * ```typescript
+     * const id = TaskIDGenerator.generate();
+     * // Returns: "task-1733750400000-a1b2c3d4"
+     *
+     * const customId = TaskIDGenerator.generate("subtask");
+     * // Returns: "subtask-1733750400000-e5f6g7h8"
+     * ```
+     */
+    static generate(prefix = "task") {
+        const timestamp = Date.now();
+        const random = (0, crypto_1.randomBytes)(4).toString("hex");
+        return `${prefix}-${timestamp}-${random}`;
+    }
+    /**
+     * Validates a task ID format.
+     * Accepts three formats:
+     * - Timestamped: "task-1234567890-abcd1234"
+     * - Hierarchical: "1.2.3"
+     * - Numeric: "123"
+     *
+     * @param id - Task ID to validate
+     * @returns true if ID format is valid
+     *
+     * @example
+     * ```typescript
+     * TaskIDGenerator.validate("task-1234-abcd"); // true
+     * TaskIDGenerator.validate("1.2.3"); // true
+     * TaskIDGenerator.validate("123"); // true
+     * TaskIDGenerator.validate("invalid!"); // false
+     * ```
+     */
+    static validate(id) {
+        if (!id || typeof id !== "string") {
+            return false;
+        }
+        // Format 1: Timestamped (task-timestamp-random)
+        const timestampedPattern = /^[a-z]+-\d+-[a-f0-9]{8}$/;
+        if (timestampedPattern.test(id)) {
+            return true;
+        }
+        // Format 2: Hierarchical (1.2.3)
+        const hierarchicalPattern = /^[\d.]+$/;
+        if (hierarchicalPattern.test(id)) {
+            return true;
+        }
+        // Format 3: Numeric (123)
+        const numericPattern = /^\d+$/;
+        if (numericPattern.test(id)) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Checks if an ID is unique within a set of existing IDs.
+     *
+     * @param id - ID to check
+     * @param existingIds - Set of existing IDs
+     * @returns true if ID is unique
+     */
+    static isUnique(id, existingIds) {
+        return !existingIds.has(id);
+    }
+    /**
+     * Generates a unique ID that doesn't exist in the provided set.
+     * Retries up to maxAttempts times if collisions occur.
+     *
+     * @param existingIds - Set of existing IDs to avoid
+     * @param prefix - Prefix for the ID
+     * @param maxAttempts - Maximum number of generation attempts
+     * @returns Unique task ID
+     * @throws TaskOMaticError if unable to generate unique ID after maxAttempts
+     */
+    static generateUnique(existingIds, prefix = "task", maxAttempts = 10) {
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const id = this.generate(prefix);
+            if (this.isUnique(id, existingIds)) {
+                return id;
+            }
+        }
+        throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.UNEXPECTED_ERROR, `Failed to generate unique ID after ${maxAttempts} attempts`, {
+            context: `Could not find a unique ID with prefix '${prefix}' after ${maxAttempts} attempts.`,
+            suggestions: [
+                "Increase maxAttempts if you have a very large number of tasks.",
+            ],
+        });
+    }
+    /**
+     * Generates a hierarchical child ID from a parent ID.
+     * If parent is "1.2", generates "1.2.1", "1.2.2", etc.
+     *
+     * @param parentId - Parent task ID
+     * @param childIndex - Index of the child (1-based)
+     * @returns Child task ID
+     *
+     * @example
+     * ```typescript
+     * TaskIDGenerator.generateChildId("1", 1); // "1.1"
+     * TaskIDGenerator.generateChildId("1.2", 3); // "1.2.3"
+     * ```
+     */
+    static generateChildId(parentId, childIndex) {
+        return `${parentId}.${childIndex}`;
+    }
+    /**
+     * Parses a hierarchical ID to extract parent ID and child index.
+     *
+     * @param id - Hierarchical task ID
+     * @returns Object with parentId and childIndex, or null if not hierarchical
+     *
+     * @example
+     * ```typescript
+     * TaskIDGenerator.parseHierarchicalId("1.2.3");
+     * // Returns: { parentId: "1.2", childIndex: 3 }
+     * ```
+     */
+    static parseHierarchicalId(id) {
+        const parts = id.split(".");
+        if (parts.length < 2) {
+            return null;
+        }
+        const childIndex = parseInt(parts[parts.length - 1], 10);
+        if (isNaN(childIndex)) {
+            return null;
+        }
+        const parentId = parts.slice(0, -1).join(".");
+        return { parentId, childIndex };
+    }
+}
+exports.TaskIDGenerator = TaskIDGenerator;

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

@@ -0,0 +1,40 @@
+import { AIConfig } from "../types";
+/**
+ * Creates base AI metadata object with common fields.
+ * Caller can extend with operation-specific fields.
+ *
+ * @param taskId - The ID of the task
+ * @param aiConfig - AI configuration used for the operation
+ * @param promptOverride - Optional custom prompt override
+ * @param defaultPrompt - Default prompt if no override provided
+ * @param confidence - Confidence score (0-1) for the AI operation
+ * @returns Base metadata object
+ *
+ * @example
+ * ```typescript
+ * const baseMetadata = createBaseAIMetadata(
+ *   "task-123",
+ *   { provider: "anthropic", model: "claude-sonnet-4.5" },
+ *   undefined,
+ *   "Split task into subtasks",
+ *   0.9
+ * );
+ *
+ * // Extend with operation-specific fields
+ * const subtaskMetadata = {
+ *   ...baseMetadata,
+ *   parentTaskId: "parent-123",
+ *   subtaskIndex: 1
+ * };
+ * ```
+ */
+export declare function createBaseAIMetadata(taskId: string, aiConfig: Partial<AIConfig>, promptOverride?: string, defaultPrompt?: string, confidence?: number): {
+    taskId: string;
+    aiGenerated: boolean;
+    aiPrompt: string;
+    confidence: number;
+    aiProvider: "custom" | "openai" | "anthropic" | "openrouter" | "gemini" | "zai" | undefined;
+    aiModel: string | undefined;
+    generatedAt: number;
+};
+//# sourceMappingURL=metadata-utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-utils.d.ts","sourceRoot":"","sources":["../../src/utils/metadata-utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAC;AAEpC;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,EAC3B,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,GAAE,MAA4B,EAC3C,UAAU,GAAE,MAAY;;;;;;;;EAWzB"}

package/dist/utils/metadata-utils.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBaseAIMetadata = createBaseAIMetadata;
+/**
+ * Creates base AI metadata object with common fields.
+ * Caller can extend with operation-specific fields.
+ *
+ * @param taskId - The ID of the task
+ * @param aiConfig - AI configuration used for the operation
+ * @param promptOverride - Optional custom prompt override
+ * @param defaultPrompt - Default prompt if no override provided
+ * @param confidence - Confidence score (0-1) for the AI operation
+ * @returns Base metadata object
+ *
+ * @example
+ * ```typescript
+ * const baseMetadata = createBaseAIMetadata(
+ *   "task-123",
+ *   { provider: "anthropic", model: "claude-sonnet-4.5" },
+ *   undefined,
+ *   "Split task into subtasks",
+ *   0.9
+ * );
+ *
+ * // Extend with operation-specific fields
+ * const subtaskMetadata = {
+ *   ...baseMetadata,
+ *   parentTaskId: "parent-123",
+ *   subtaskIndex: 1
+ * };
+ * ```
+ */
+function createBaseAIMetadata(taskId, aiConfig, promptOverride, defaultPrompt = "AI-generated task", confidence = 0.9) {
+    return {
+        taskId,
+        aiGenerated: true,
+        aiPrompt: promptOverride || defaultPrompt,
+        confidence,
+        aiProvider: aiConfig.provider,
+        aiModel: aiConfig.model,
+        generatedAt: Date.now(),
+    };
+}

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

@@ -0,0 +1,38 @@
+import { ExecutorTool, ModelAttemptConfig } from "../types";
+/**
+ * Valid executor tools
+ */
+export declare const VALID_EXECUTORS: ExecutorTool[];
+/**
+ * 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 TaskOMaticError 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" }, ...]
+ * ```
+ */
+export declare function parseTryModels(value: string): ModelAttemptConfig[];
+/**
+ * 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
+ * }
+ * ```
+ */
+export declare function validateExecutor(executor: string): executor is ExecutorTool;
+//# sourceMappingURL=model-executor-parser.d.ts.map

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;AAM5D;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,YAAY,EAMzC,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,kBAAkB,EAAE,CA4BlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,QAAQ,IAAI,YAAY,CAE3E"}