task-o-matic-core 0.1.0

package/src/test/storage.test.ts

@@ -0,0 +1,206 @@
+import { FileSystemStorage } from "../lib/storage/file-system";
+import { TaskRepository } from "../lib/storage/types";
+import { CreateTaskRequest } from "../types";
+import * as assert from "assert";
+
+describe("FileSystemStorage", () => {
+  let storage: TaskRepository;
+
+  beforeEach(async () => {
+    storage = new FileSystemStorage();
+    // Clean up any existing data for fresh test
+    try {
+      const tasks = await storage.getTopLevelTasks();
+      for (const task of tasks) {
+        await storage.deleteTask(task.id);
+      }
+    } catch (error) {
+      // Ignore cleanup errors
+    }
+  });
+
+  describe("Task Management", () => {
+    it("should create a task successfully", async () => {
+      const taskRequest: CreateTaskRequest = {
+        title: "Test Task",
+        description: "A test task description",
+        estimatedEffort: "small",
+      };
+
+      const task = await storage.createTask(taskRequest);
+
+      assert.strictEqual(task.title, "Test Task");
+      assert.strictEqual(task.description, "A test task description");
+      assert.strictEqual(task.estimatedEffort, "small");
+      assert.strictEqual(task.status, "todo");
+      assert.ok(task.id);
+      assert.ok(task.createdAt);
+      assert.ok(task.updatedAt);
+    });
+
+    it("should retrieve a task by ID", async () => {
+      const taskRequest: CreateTaskRequest = {
+        title: "Test Task for Retrieval",
+      };
+
+      const createdTask = await storage.createTask(taskRequest);
+      const retrievedTask = await storage.getTask(createdTask.id);
+
+      assert.ok(retrievedTask);
+      assert.strictEqual(retrievedTask.id, createdTask.id);
+      assert.strictEqual(retrievedTask.title, createdTask.title);
+    });
+
+    it("should return null for non-existent task", async () => {
+      const task = await storage.getTask("non-existent-id");
+      assert.strictEqual(task, null);
+    });
+
+    it("should update a task", async () => {
+      const taskRequest: CreateTaskRequest = {
+        title: "Original Title",
+      };
+
+      const createdTask = await storage.createTask(taskRequest);
+
+      // Add a small delay to ensure different timestamps
+      await new Promise((resolve) => setTimeout(resolve, 1));
+
+      const updatedTask = await storage.updateTask(createdTask.id, {
+        title: "Updated Title",
+        status: "in-progress",
+      });
+
+      assert.ok(updatedTask);
+      assert.strictEqual(updatedTask.title, "Updated Title");
+      assert.strictEqual(updatedTask.status, "in-progress");
+      assert.ok(updatedTask.updatedAt >= createdTask.updatedAt);
+    });
+
+    it("should delete a task", async () => {
+      const taskRequest: CreateTaskRequest = {
+        title: "Task to Delete",
+      };
+
+      const createdTask = await storage.createTask(taskRequest);
+      const deleteResult = await storage.deleteTask(createdTask.id);
+
+      assert.strictEqual(deleteResult, true);
+
+      const deletedTask = await storage.getTask(createdTask.id);
+      assert.strictEqual(deletedTask, null);
+    });
+
+    it("should handle task dependencies", async () => {
+      const task1Request: CreateTaskRequest = {
+        title: "First Task",
+      };
+
+      const task2Request: CreateTaskRequest = {
+        title: "Second Task",
+        dependencies: [],
+      };
+
+      const task1 = await storage.createTask(task1Request);
+      const task2 = await storage.createTask({
+        ...task2Request,
+        dependencies: [task1.id],
+      });
+
+      assert.strictEqual(task2.dependencies?.length, 1);
+      assert.strictEqual(task2.dependencies[0], task1.id);
+    });
+  });
+
+  describe("Input Validation", () => {
+    it("should reject empty task title", async () => {
+      try {
+        await storage.createTask({ title: "" });
+        assert.fail("Should have thrown an error");
+      } catch (error) {
+        assert.ok(error instanceof Error);
+        assert.ok(error.message.includes("title"));
+      }
+    });
+
+    it("should reject invalid task ID", async () => {
+      try {
+        await storage.getTask("");
+        assert.fail("Should have thrown an error");
+      } catch (error) {
+        assert.ok(error instanceof Error);
+        assert.ok(error.message.includes("Task ID"));
+      }
+    });
+
+    it("should reject invalid estimated effort", async () => {
+      try {
+        await storage.createTask({
+          title: "Test Task",
+          estimatedEffort: "invalid" as any,
+        });
+        assert.fail("Should have thrown an error");
+      } catch (error) {
+        assert.ok(error instanceof Error);
+        assert.ok(error.message.includes("effort"));
+      }
+    });
+  });
+
+  describe("Storage Validation", () => {
+    it("should validate storage integrity", async () => {
+      const validation = await storage.validateStorageIntegrity();
+      assert.ok(validation.isValid);
+      assert.strictEqual(validation.issues.length, 0);
+    });
+
+    it("should detect duplicate task IDs", async () => {
+      // This would require manual manipulation to test
+      // For now, just ensure the method exists
+      const validation = await storage.validateStorageIntegrity();
+      assert.ok(typeof validation.isValid === "boolean");
+      assert.ok(Array.isArray(validation.issues));
+    });
+  });
+
+  describe("Content Management", () => {
+    it("should save and retrieve task content", async () => {
+      const taskRequest: CreateTaskRequest = {
+        title: "Task with Content",
+      };
+
+      const task = await storage.createTask(taskRequest);
+      const content = "# Task Content\nThis is the task content.";
+
+      const contentFile = await storage.saveTaskContent(task.id, content);
+      const retrievedContent = await storage.getTaskContent(task.id);
+
+      assert.strictEqual(retrievedContent, content);
+      assert.ok(contentFile.includes(task.id));
+    });
+
+    it("should return null for non-existent content", async () => {
+      // First create a task to ensure storage is initialized
+      const taskRequest: CreateTaskRequest = {
+        title: "Dummy Task for Initialization",
+      };
+      await storage.createTask(taskRequest);
+
+      const content = await storage.getTaskContent("non-existent-task");
+      assert.strictEqual(content, null);
+    });
+
+    it("should delete task content", async () => {
+      const taskRequest: CreateTaskRequest = {
+        title: "Task with Content to Delete",
+      };
+
+      const task = await storage.createTask(taskRequest);
+      await storage.saveTaskContent(task.id, "Some content");
+      await storage.deleteTaskContent(task.id);
+
+      const content = await storage.getTaskContent(task.id);
+      assert.strictEqual(content, null);
+    });
+  });
+});

package/src/test/task-loop-git.test.ts

@@ -0,0 +1,142 @@
+import assert from "assert";
+import { extractCommitInfo } from "../lib/git-utils";
+
+describe("Task Loop Git Integration", () => {
+  const mockTaskTitle = "Test Task";
+  const mockExecutionMessage = "Executed task";
+
+  it("should extract commit info from existing commit", async () => {
+    const gitState = {
+      beforeHead: "abc",
+      afterHead: "def",
+      hasUncommittedChanges: false,
+    };
+
+    const mockExec = async (cmd: string) => {
+      if (cmd.includes("git show")) {
+        return {
+          stdout: "feat: test commit\n\nBody\n src/file.ts | 10 +",
+          stderr: "",
+        };
+      }
+      return { stdout: "", stderr: "" };
+    };
+
+    const result = await extractCommitInfo(
+      "1",
+      mockTaskTitle,
+      mockExecutionMessage,
+      gitState,
+      mockExec
+    );
+
+    assert.strictEqual(result.message, "feat: test commit");
+    assert.deepStrictEqual(result.files, ["src/file.ts"]);
+  });
+
+  it("should generate commit info from uncommitted changes", async () => {
+    const gitState = {
+      beforeHead: "abc",
+      afterHead: "abc",
+      hasUncommittedChanges: true,
+    };
+
+    const mockExec = async (cmd: string) => {
+      if (cmd.includes("git diff")) {
+        return { stdout: "diff content", stderr: "" };
+      }
+      if (cmd.includes("git status")) {
+        return { stdout: " M src/changed.ts", stderr: "" };
+      }
+      return { stdout: "", stderr: "" };
+    };
+
+    const mockAiOps = {
+      streamText: async () => JSON.stringify({ message: "fix: auto commit" }),
+    };
+
+    const result = await extractCommitInfo(
+      "1",
+      mockTaskTitle,
+      mockExecutionMessage,
+      gitState,
+      mockExec,
+      mockAiOps
+    );
+
+    assert.strictEqual(result.message, "fix: auto commit");
+    assert.deepStrictEqual(result.files, ["src/changed.ts"]);
+  });
+
+  it("should return default info when no changes", async () => {
+    const gitState = {
+      beforeHead: "abc",
+      afterHead: "abc",
+      hasUncommittedChanges: false,
+    };
+
+    const result = await extractCommitInfo(
+      "1",
+      mockTaskTitle,
+      mockExecutionMessage,
+      gitState
+    );
+
+    assert.strictEqual(result.message, `feat: complete task ${mockTaskTitle}`);
+    assert.deepStrictEqual(result.files, []);
+  });
+
+  it("should handle git command failures gracefully", async () => {
+    const gitState = {
+      beforeHead: "abc",
+      afterHead: "def",
+      hasUncommittedChanges: false,
+    };
+
+    const mockExec = async () => {
+      throw new Error("Git failed");
+    };
+
+    const result = await extractCommitInfo(
+      "1",
+      mockTaskTitle,
+      mockExecutionMessage,
+      gitState,
+      mockExec
+    );
+
+    assert.strictEqual(result.message, `feat: complete task ${mockTaskTitle}`);
+    assert.deepStrictEqual(result.files, []);
+  });
+
+  it("should handle invalid AI JSON response", async () => {
+    const gitState = {
+      beforeHead: "abc",
+      afterHead: "abc",
+      hasUncommittedChanges: true,
+    };
+
+    const mockExec = async (cmd: string) => {
+      if (cmd.includes("git diff")) return { stdout: "diff", stderr: "" };
+      if (cmd.includes("git status"))
+        return { stdout: " M file.ts", stderr: "" };
+      return { stdout: "", stderr: "" };
+    };
+
+    const mockAiOps = {
+      streamText: async () => "Not JSON",
+    };
+
+    const result = await extractCommitInfo(
+      "1",
+      mockTaskTitle,
+      mockExecutionMessage,
+      gitState,
+      mockExec,
+      mockAiOps
+    );
+
+    assert.strictEqual(result.message, `feat: complete task ${mockTaskTitle}`);
+    assert.deepStrictEqual(result.files, ["file.ts"]);
+  });
+});

package/src/test/test-mock-setup.ts

@@ -0,0 +1,46 @@
+/**
+ * Test Mock Setup - Provides mock instances for ai-service-factory
+ * Uses the injectTestInstances function to inject mocks
+ */
+
+import { MockStorage } from "./mocks/mock-storage";
+import { MockAIOperations } from "./mocks/mock-ai-operations";
+import { MockModelProvider } from "./mocks/mock-model-provider";
+import { MockContextBuilder } from "./mocks/mock-context-builder";
+import { injectTestInstances } from "../utils/ai-service-factory";
+
+// Store mock instances
+export let mockStorage: MockStorage;
+export let mockAIOperations: MockAIOperations;
+export let mockModelProvider: MockModelProvider;
+export let mockContextBuilder: MockContextBuilder;
+
+/**
+ * Initialize fresh mock instances and inject them into the service factory
+ */
+export function resetMocks() {
+  mockStorage = new MockStorage();
+  mockAIOperations = new MockAIOperations() as any; // Cast to any to avoid type issues
+  mockModelProvider = new MockModelProvider() as any;
+  mockContextBuilder = new MockContextBuilder(mockStorage) as any;
+
+  // Inject mocks into the service factory
+  injectTestInstances({
+    storage: mockStorage,
+    aiOperations: mockAIOperations as any,
+    modelProvider: mockModelProvider as any,
+    contextBuilder: mockContextBuilder as any,
+  });
+}
+
+/**
+ * Get current mock instances for test assertions
+ */
+export function getMocks() {
+  return {
+    storage: mockStorage,
+    aiOperations: mockAIOperations,
+    modelProvider: mockModelProvider,
+    contextBuilder: mockContextBuilder,
+  };
+}

package/src/test/test-setup.ts

@@ -0,0 +1,48 @@
+/**
+ * Test Setup - Global test configuration and cleanup
+ * This file sets up the test environment to ensure proper isolation and configuration
+ */
+
+import { configManager } from "../lib/config";
+import { hooks } from "../lib/hooks";
+import { resetMocks } from "./test-mock-setup";
+
+// Global test setup
+before(async function () {
+  // Set up a test working directory
+  const testDir = process.cwd();
+  configManager.setWorkingDirectory(testDir);
+
+  // Set up a minimal test configuration (no need to load from disk)
+  configManager.setConfig({
+    ai: {
+      provider: "openrouter",
+      model: "anthropic/claude-3-5-sonnet",
+      maxTokens: 4000,
+      temperature: 0.7,
+      apiKey: "test-key",
+    },
+    workingDirectory: testDir,
+  });
+
+  // Reset mocks to ensure clean state
+  resetMocks();
+});
+
+// Clean up between tests
+afterEach(function () {
+  // Reset mocks to ensure clean state
+  resetMocks();
+
+  // Clean up hooks to prevent interference
+  hooks.clear();
+});
+
+// Additional test utilities
+export function setupTestEnvironment() {
+  // This can be called in individual tests for additional setup
+  return {
+    config: configManager.getConfig(),
+    workingDir: configManager.getWorkingDirectory(),
+  };
+}

package/src/test/test-utils.ts

@@ -0,0 +1,45 @@
+import { resetMockServices } from "./mocks/mock-service-factory";
+import { MockStorage } from "./mocks/mock-storage";
+import { MockAIOperations } from "./mocks/mock-ai-operations";
+import { MockModelProvider } from "./mocks/mock-model-provider";
+import { MockContextBuilder } from "./mocks/mock-context-builder";
+
+export interface TestContext {
+  storage: MockStorage;
+  aiOperations: MockAIOperations;
+  modelProvider: MockModelProvider;
+  contextBuilder: MockContextBuilder;
+}
+
+export function createTestContext(): TestContext {
+  resetMockServices();
+
+  const storage = new MockStorage();
+  const aiOperations = new MockAIOperations();
+  const modelProvider = new MockModelProvider();
+  const contextBuilder = new MockContextBuilder(storage);
+
+  return {
+    storage,
+    aiOperations,
+    modelProvider,
+    contextBuilder,
+  };
+}
+
+export function createTestTaskData() {
+  return {
+    title: "Test Task",
+    description: "This is a test task description",
+    content: "Full content for the test task",
+    effort: "medium" as const,
+  };
+}
+
+export function createTestPRDData() {
+  return {
+    description: "Test PRD description",
+    content:
+      "# Test PRD\n\nThis is a test PRD document with multiple sections.\n\n## Features\n- Feature 1\n- Feature 2\n\n## Requirements\n- Requirement 1\n- Requirement 2",
+  };
+}