task-o-matic-core 0.1.0

package/dist/test/hooks.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=hooks.test.d.ts.map

package/dist/test/hooks.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.test.d.ts","sourceRoot":"","sources":["../../src/test/hooks.test.ts"],"names":[],"mappings":""}

package/dist/test/hooks.test.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const hooks_1 = require("../lib/hooks");
+describe("HookRegistry", () => {
+    beforeEach(() => {
+        hooks_1.hooks.clear();
+    });
+    it("should register and call a listener", async () => {
+        let called = false;
+        const task = { id: "1", title: "Test Task" };
+        hooks_1.hooks.on("task:created", (payload) => {
+            node_assert_1.default.strictEqual(payload.task, task);
+            called = true;
+        });
+        await hooks_1.hooks.emit("task:created", { task });
+        node_assert_1.default.strictEqual(called, true);
+    });
+    it("should handle multiple listeners", async () => {
+        let count = 0;
+        const task = { id: "1", title: "Test Task" };
+        hooks_1.hooks.on("task:created", () => {
+            count++;
+        });
+        hooks_1.hooks.on("task:created", () => {
+            count++;
+        });
+        await hooks_1.hooks.emit("task:created", { task });
+        node_assert_1.default.strictEqual(count, 2);
+    });
+    it("should remove a listener", async () => {
+        let count = 0;
+        const handler = () => {
+            count++;
+        };
+        const task = { id: "1", title: "Test Task" };
+        hooks_1.hooks.on("task:created", handler);
+        hooks_1.hooks.off("task:created", handler);
+        await hooks_1.hooks.emit("task:created", { task });
+        node_assert_1.default.strictEqual(count, 0);
+    });
+    it("should not fail if a listener throws", async () => {
+        const task = { id: "1", title: "Test Task" };
+        // Suppress console.error for this test
+        const originalConsoleError = console.error;
+        console.error = () => { };
+        try {
+            hooks_1.hooks.on("task:created", () => {
+                throw new Error("Oops");
+            });
+            let secondCalled = false;
+            hooks_1.hooks.on("task:created", () => {
+                secondCalled = true;
+            });
+            // Should not throw
+            await hooks_1.hooks.emit("task:created", { task });
+            node_assert_1.default.strictEqual(secondCalled, true);
+        }
+        finally {
+            // Restore console.error
+            console.error = originalConsoleError;
+        }
+    });
+});

package/dist/test/integration/callbacks.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=callbacks.test.d.ts.map

package/dist/test/integration/callbacks.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callbacks.test.d.ts","sourceRoot":"","sources":["../../../src/test/integration/callbacks.test.ts"],"names":[],"mappings":""}

package/dist/test/integration/callbacks.test.js

@@ -0,0 +1,64 @@
+"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 });
+const file_system_1 = require("../../lib/storage/file-system");
+const assert = __importStar(require("assert"));
+describe("Callback Integration", () => {
+    it("should use custom storage callbacks", async () => {
+        const memoryStore = new Map();
+        const callbacks = {
+            read: async (key) => memoryStore.get(key) || null,
+            write: async (key, value) => {
+                memoryStore.set(key, value);
+            },
+            delete: async (key) => {
+                memoryStore.delete(key);
+            },
+            list: async (prefix) => Array.from(memoryStore.keys()).filter((k) => k.startsWith(prefix || "")),
+            exists: async (key) => memoryStore.has(key),
+        };
+        const storage = new file_system_1.FileSystemStorage(callbacks);
+        // Create task
+        const task = await storage.createTask({ title: "Test Task" });
+        // Verify it was written to memory store
+        assert.strictEqual(memoryStore.has("tasks.json"), true);
+        const data = JSON.parse(memoryStore.get("tasks.json"));
+        assert.strictEqual(data.tasks.length, 1);
+        assert.strictEqual(data.tasks[0].title, "Test Task");
+        // Verify retrieval
+        const retrieved = await storage.getTask(task.id);
+        assert.strictEqual(retrieved?.id, task.id);
+    });
+});

package/dist/test/lib/ai-service/task-operations.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=task-operations.test.d.ts.map

package/dist/test/lib/ai-service/task-operations.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-operations.test.d.ts","sourceRoot":"","sources":["../../../../src/test/lib/ai-service/task-operations.test.ts"],"names":[],"mappings":""}

package/dist/test/lib/ai-service/task-operations.test.js

@@ -0,0 +1,362 @@
+"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 });
+const assert = __importStar(require("assert"));
+const task_operations_1 = require("../../../lib/ai-service/task-operations");
+const task_o_matic_error_1 = require("../../../utils/task-o-matic-error");
+/**
+ * ⚠️ CRITICAL: These integration tests use 100% MOCKS - ZERO real AI calls
+ * No API calls are made, no costs incurred, tests run fast
+ *
+ * These tests verify that TaskOperations properly integrates with AIOperationUtility
+ * and that errors propagate correctly through the stack.
+ */
+describe("TaskOperations Integration Tests", () => {
+    let taskOps;
+    let mockAIOperationUtility;
+    beforeEach(() => {
+        taskOps = new task_operations_1.TaskOperations();
+        // Create mock AIOperationUtility - NO REAL AI CALLS
+        mockAIOperationUtility = {
+            executeAIOperation: async (operationName, operation, options) => {
+                // Execute the operation and return mock metrics
+                const result = await operation();
+                return {
+                    result,
+                    metrics: {
+                        duration: 100,
+                        tokenUsage: {
+                            prompt: 50,
+                            completion: 25,
+                            total: 75,
+                        },
+                    },
+                };
+            },
+            streamTextWithTools: async (systemPrompt, userMessage, config, streamingOptions, tools) => {
+                // Return mock JSON response
+                return JSON.stringify({
+                    subtasks: [
+                        {
+                            title: "Mock subtask 1",
+                            description: "Mock description 1",
+                            effort: "small",
+                        },
+                        {
+                            title: "Mock subtask 2",
+                            description: "Mock description 2",
+                            effort: "medium",
+                        },
+                    ],
+                });
+            },
+            streamText: async (_prompt, _config, _systemPrompt, _userMessage, _streamingOptions) => {
+                return "Mock enhanced content";
+            },
+        };
+        // Inject mock into TaskOperations
+        taskOps.aiOperationUtility = mockAIOperationUtility;
+    });
+    describe("breakdownTask Integration", () => {
+        it("should successfully break down a task using AIOperationUtility", async () => {
+            const mockTask = {
+                id: "test-task-1",
+                title: "Test Task",
+                description: "A task to break down",
+                status: "todo",
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            const result = await taskOps.breakdownTask(mockTask);
+            // Verify result structure
+            assert.ok(Array.isArray(result));
+            assert.strictEqual(result.length, 2);
+            assert.strictEqual(result[0].title, "Mock subtask 1");
+            assert.strictEqual(result[0].content, "Mock description 1");
+            assert.strictEqual(result[0].estimatedEffort, "small");
+        });
+        it("should handle filesystem tools when enabled", async () => {
+            let toolsPassed = false;
+            // Override streamTextWithTools to capture tools parameter
+            mockAIOperationUtility.streamTextWithTools = async (_systemPrompt, _userMessage, _config, _streamingOptions, tools) => {
+                if (tools && Object.keys(tools).length > 0) {
+                    toolsPassed = true;
+                }
+                return JSON.stringify({
+                    subtasks: [
+                        {
+                            title: "Subtask with tools",
+                            description: "Used filesystem tools",
+                            effort: "small",
+                        },
+                    ],
+                });
+            };
+            const mockTask = {
+                id: "test-task-2",
+                title: "Task with tools",
+                status: "todo",
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            const result = await taskOps.breakdownTask(mockTask, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, true // enableFilesystemTools
+            );
+            assert.ok(toolsPassed, "Filesystem tools should be passed when enabled");
+            assert.strictEqual(result.length, 1);
+        });
+        it("should propagate TaskOMaticError from AIOperationUtility", async () => {
+            // Mock AIOperationUtility to throw error
+            taskOps.aiOperationUtility.executeAIOperation = async () => {
+                throw new task_o_matic_error_1.TaskOMaticError("AI operation failed: Task breakdown", {
+                    code: "AI_OPERATION_FAILED",
+                    context: "Mock error context",
+                    suggestions: ["Check AI configuration"],
+                });
+            };
+            const mockTask = {
+                id: "test-task-error",
+                title: "Task that will fail",
+                status: "todo",
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            try {
+                await taskOps.breakdownTask(mockTask);
+                assert.fail("Should have thrown TaskOMaticError");
+            }
+            catch (error) {
+                assert.ok(error instanceof task_o_matic_error_1.TaskOMaticError);
+                assert.strictEqual(error.code, "AI_OPERATION_FAILED");
+                assert.ok(error.message.includes("Task breakdown"));
+            }
+        });
+    });
+    describe("enhanceTask Integration", () => {
+        it("should successfully enhance a task using AIOperationUtility", async () => {
+            const result = await taskOps.enhanceTask("Test Task", "Basic description");
+            // Verify result
+            assert.strictEqual(typeof result, "string");
+            assert.strictEqual(result, "Mock enhanced content");
+        });
+        it("should propagate errors from AIOperationUtility", async () => {
+            // Mock AIOperationUtility to throw error
+            taskOps.aiOperationUtility.executeAIOperation = async () => {
+                throw new task_o_matic_error_1.TaskOMaticError("AI operation failed: Task enhancement", {
+                    code: "AI_OPERATION_FAILED",
+                    context: "Enhancement failed",
+                    suggestions: ["Retry with different parameters"],
+                });
+            };
+            try {
+                await taskOps.enhanceTask("Test", "Description");
+                assert.fail("Should have thrown TaskOMaticError");
+            }
+            catch (error) {
+                assert.ok(error instanceof task_o_matic_error_1.TaskOMaticError);
+                assert.ok(error.message.includes("Task enhancement"));
+            }
+        });
+    });
+    describe("planTask Integration", () => {
+        it("should successfully plan a task using AIOperationUtility", async () => {
+            // Mock streamTextWithTools to return plan
+            mockAIOperationUtility.streamTextWithTools = async () => {
+                return "Mock implementation plan:\n1. Step 1\n2. Step 2\n3. Step 3";
+            };
+            const result = await taskOps.planTask("Project context", "Task details");
+            // Verify result
+            assert.strictEqual(typeof result, "string");
+            assert.ok(result.includes("Mock implementation plan"));
+            assert.ok(result.includes("Step 1"));
+        });
+        it("should handle MCP tools and filesystem tools", async () => {
+            let toolsReceived = false;
+            mockAIOperationUtility.streamTextWithTools = async (_systemPrompt, _userMessage, _config, _streamingOptions, tools) => {
+                if (tools && Object.keys(tools).length > 0) {
+                    toolsReceived = true;
+                }
+                return "Plan with tools";
+            };
+            // Mock Context7Client to return MCP tools
+            const mockContext7Client = {
+                getMCPTools: async () => ({
+                    mockTool: {
+                        description: "Mock MCP tool",
+                        parameters: {},
+                        execute: async () => ({}),
+                    },
+                }),
+                saveContext7Documentation: () => { },
+            };
+            taskOps.context7Client = mockContext7Client;
+            const result = await taskOps.planTask("Context", "Details");
+            assert.ok(toolsReceived, "Tools should be passed to streamTextWithTools");
+            assert.strictEqual(result, "Plan with tools");
+        });
+        it("should propagate errors from AIOperationUtility", async () => {
+            // Mock AIOperationUtility to throw error
+            taskOps.aiOperationUtility.executeAIOperation = async () => {
+                throw new task_o_matic_error_1.TaskOMaticError("AI operation failed: Task planning", {
+                    code: "AI_OPERATION_FAILED",
+                    context: "Planning failed",
+                    suggestions: ["Check task context"],
+                });
+            };
+            try {
+                await taskOps.planTask("Context", "Details");
+                assert.fail("Should have thrown TaskOMaticError");
+            }
+            catch (error) {
+                assert.ok(error instanceof task_o_matic_error_1.TaskOMaticError);
+                assert.ok(error.message.includes("Task planning"));
+            }
+        });
+    });
+    describe("Metrics Flow", () => {
+        it("should return results from AIOperationUtility without exposing metrics", async () => {
+            // breakdownTask returns result.result directly, not the full AIOperationResult
+            const mockTask = {
+                id: "metrics-test",
+                title: "Metrics test task",
+                status: "todo",
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            const result = await taskOps.breakdownTask(mockTask);
+            // Verify we got the result, not the AIOperationResult wrapper
+            assert.ok(Array.isArray(result));
+            assert.ok(!("metrics" in result), "Should not expose metrics in result");
+            assert.ok(!("result" in result), "Should not expose AIOperationResult structure");
+        });
+    });
+    describe("Error Handling Integration", () => {
+        it("should wrap string errors in TaskOMaticError", async () => {
+            // Mock operation that throws string error
+            taskOps.aiOperationUtility.executeAIOperation = async () => {
+                const error = new Error("String error was converted");
+                throw new task_o_matic_error_1.TaskOMaticError("AI operation failed: Task breakdown", {
+                    code: "AI_OPERATION_FAILED",
+                    cause: error,
+                    context: JSON.stringify({
+                        operation: "Task breakdown",
+                        error: "String error was converted",
+                    }),
+                    suggestions: ["Check AI configuration"],
+                });
+            };
+            const mockTask = {
+                id: "string-error-test",
+                title: "Test",
+                status: "todo",
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            try {
+                await taskOps.breakdownTask(mockTask);
+                assert.fail("Should have thrown");
+            }
+            catch (error) {
+                assert.ok(error instanceof task_o_matic_error_1.TaskOMaticError);
+                const taskError = error;
+                assert.ok(taskError.cause instanceof Error);
+            }
+        });
+        it("should preserve error context and suggestions", async () => {
+            const mockError = new task_o_matic_error_1.TaskOMaticError("Original error", {
+                code: "TEST_ERROR",
+                context: "Original context",
+                suggestions: ["Original suggestion 1", "Original suggestion 2"],
+                metadata: { testData: "test value" },
+            });
+            taskOps.aiOperationUtility.executeAIOperation = async () => {
+                throw mockError;
+            };
+            const mockTask = {
+                id: "context-test",
+                title: "Test",
+                status: "todo",
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            try {
+                await taskOps.breakdownTask(mockTask);
+                assert.fail("Should have thrown");
+            }
+            catch (error) {
+                assert.ok(error instanceof task_o_matic_error_1.TaskOMaticError);
+                const taskError = error;
+                assert.strictEqual(taskError.code, "TEST_ERROR");
+                assert.ok(taskError.context?.includes("Original context"));
+                assert.ok(Array.isArray(taskError.suggestions));
+                assert.ok(taskError.metadata?.testData === "test value");
+            }
+        });
+    });
+    describe("Streaming Options Integration", () => {
+        it("should pass streaming options through to AIOperationUtility", async () => {
+            let onChunkCalled = false;
+            let onFinishCalled = false;
+            const streamingOptions = {
+                onChunk: (chunk) => {
+                    onChunkCalled = true;
+                },
+                onFinish: (result) => {
+                    onFinishCalled = true;
+                },
+            };
+            // Mock to verify streaming options are passed
+            let receivedOptions;
+            taskOps.aiOperationUtility.executeAIOperation = async (_operationName, operation, options) => {
+                receivedOptions = options;
+                const result = await operation();
+                return {
+                    result,
+                    metrics: { duration: 100 },
+                };
+            };
+            const mockTask = {
+                id: "streaming-test",
+                title: "Test",
+                status: "todo",
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+            };
+            await taskOps.breakdownTask(mockTask, undefined, undefined, undefined, streamingOptions);
+            // Verify streaming options were passed
+            assert.ok(receivedOptions);
+            assert.ok(receivedOptions.streamingOptions);
+        });
+    });
+});

package/dist/test/lib/config.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=config.test.d.ts.map

package/dist/test/lib/config.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.test.d.ts","sourceRoot":"","sources":["../../../src/test/lib/config.test.ts"],"names":[],"mappings":""}

package/dist/test/lib/config.test.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const config_1 = require("../../lib/config");
+const task_o_matic_error_1 = require("../../utils/task-o-matic-error");
+describe("ConfigManager", () => {
+    let mockCallbacks;
+    let mockStorage;
+    let mockEnv;
+    beforeEach(() => {
+        mockStorage = {};
+        mockEnv = {};
+        mockCallbacks = {
+            read: async (key) => mockStorage[key] || null,
+            write: async (key, value) => {
+                mockStorage[key] = value;
+            },
+            getEnv: (key) => mockEnv[key],
+        };
+    });
+    it("should load default configuration when no config file exists", async () => {
+        const configManager = new config_1.ConfigManager(mockCallbacks);
+        const config = await configManager.load();
+        assert_1.default.strictEqual(config.ai.provider, "openrouter"); // Default
+        assert_1.default.strictEqual(config.ai.model, "z-ai/glm-4.6"); // Default
+    });
+    it("should load configuration from file", async () => {
+        const storedConfig = {
+            ai: {
+                provider: "openai",
+                model: "gpt-4",
+                apiKey: "sk-test",
+                maxTokens: 1000,
+                temperature: 0.1,
+            },
+        };
+        mockStorage["config.json"] = JSON.stringify(storedConfig);
+        const configManager = new config_1.ConfigManager(mockCallbacks);
+        const config = await configManager.load();
+        assert_1.default.strictEqual(config.ai.provider, "openai");
+        assert_1.default.strictEqual(config.ai.model, "gpt-4");
+        assert_1.default.strictEqual(config.ai.apiKey, "sk-test");
+    });
+    it("should override config with environment variables", async () => {
+        const storedConfig = {
+            ai: {
+                provider: "openai",
+                model: "gpt-4",
+                apiKey: "sk-test",
+            },
+        };
+        mockStorage["config.json"] = JSON.stringify(storedConfig);
+        mockEnv["AI_PROVIDER"] = "anthropic";
+        mockEnv["ANTHROPIC_API_KEY"] = "sk-ant-test";
+        // Note: ConfigManager loads defaults based on provider, but file config overrides defaults,
+        // and env config overrides file config?
+        // Let's check implementation:
+        // ... fileConfig ... envConfig
+        // ai: { ...defaultConfig.ai, ...fileConfig.ai, ...envConfig }
+        // So envConfig wins.
+        const configManager = new config_1.ConfigManager(mockCallbacks);
+        const config = await configManager.load();
+        assert_1.default.strictEqual(config.ai.provider, "anthropic");
+        assert_1.default.strictEqual(config.ai.apiKey, "sk-ant-test");
+    });
+    it("should validate configuration", async () => {
+        const configManager = new config_1.ConfigManager(mockCallbacks);
+        // Invalid provider
+        const result1 = configManager.validate({
+            ai: { provider: "invalid", model: "test-model" },
+        });
+        assert_1.default.strictEqual(result1.valid, false);
+        assert_1.default.ok(result1.errors[0].includes("Invalid provider"));
+        // Valid provider
+        const result2 = configManager.validate({
+            ai: { provider: "openai", model: "gpt-5.2-mini" },
+        });
+        assert_1.default.strictEqual(result2.valid, true);
+    });
+    it("should save configuration", async () => {
+        const configManager = new config_1.ConfigManager(mockCallbacks);
+        await configManager.load(); // Load defaults
+        const newConfig = {
+            ai: {
+                provider: "custom",
+                model: "my-model",
+                apiKey: "secret",
+            },
+        };
+        configManager.setConfig(newConfig);
+        await configManager.save();
+        const saved = JSON.parse(mockStorage["config.json"]);
+        assert_1.default.strictEqual(saved.ai.provider, "custom");
+        assert_1.default.strictEqual(saved.ai.model, "my-model");
+    });
+    it("should throw error when accessing config before load", () => {
+        const configManager = new config_1.ConfigManager(mockCallbacks);
+        assert_1.default.throws(() => {
+            configManager.getConfig();
+        }, (err) => {
+            return err.code === task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR;
+        });
+    });
+    it("should set AI config partially and save", async () => {
+        const configManager = new config_1.ConfigManager(mockCallbacks);
+        await configManager.load();
+        await configManager.setAIConfig({
+            temperature: 0.9,
+            maxTokens: 500,
+        });
+        const saved = JSON.parse(mockStorage["config.json"]);
+        assert_1.default.strictEqual(saved.ai.temperature, 0.9);
+        assert_1.default.strictEqual(saved.ai.maxTokens, 500);
+        // Should preserve other defaults
+        assert_1.default.strictEqual(saved.ai.provider, "openrouter");
+    });
+    it("should update callbacks when changing working directory", () => {
+        const configManager = new config_1.ConfigManager();
+        const initialDir = configManager.getWorkingDirectory();
+        configManager.setWorkingDirectory("/new/path");
+        assert_1.default.notStrictEqual(configManager.getWorkingDirectory(), initialDir);
+        // Should reset config
+        assert_1.default.throws(() => configManager.getConfig());
+    });
+});

package/dist/test/lib/git-utils.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=git-utils.test.d.ts.map

package/dist/test/lib/git-utils.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-utils.test.d.ts","sourceRoot":"","sources":["../../../src/test/lib/git-utils.test.ts"],"names":[],"mappings":""}