task-o-matic-core 0.1.0

package/src/test/lib/git-utils.test.ts

@@ -0,0 +1,198 @@
+import assert from "assert";
+import {
+  hasNewCommitsSince,
+  captureGitState,
+  autoCommit,
+  commitFile,
+  isClean,
+  getCurrentBranch,
+  createBenchmarkBranch,
+  checkoutBranch,
+  cleanupBenchmarkBranch,
+  GitState,
+  CommitInfo
+} from "../../lib/git-utils";
+
+describe("Git Utilities", () => {
+  describe("hasNewCommitsSince", () => {
+    it("should return true when HEAD has changed", async () => {
+      const mockExec = async (cmd: string) => {
+        if (cmd === "git rev-parse HEAD") {
+          return { stdout: "new-hash", stderr: "" };
+        }
+        return { stdout: "", stderr: "" };
+      };
+      const result = await hasNewCommitsSince("old-hash", mockExec);
+      assert.strictEqual(result, true);
+    });
+
+    it("should return false when HEAD is unchanged", async () => {
+      const mockExec = async (cmd: string) => {
+        if (cmd === "git rev-parse HEAD") {
+          return { stdout: "old-hash", stderr: "" };
+        }
+        return { stdout: "", stderr: "" };
+      };
+      const result = await hasNewCommitsSince("old-hash", mockExec);
+      assert.strictEqual(result, false);
+    });
+
+    it("should return false when command fails", async () => {
+      const mockExec = async () => {
+        throw new Error("git error");
+      };
+      const result = await hasNewCommitsSince("old-hash", mockExec);
+      assert.strictEqual(result, false);
+    });
+
+    it("should return false when beforeHead is empty", async () => {
+        const result = await hasNewCommitsSince("", async () => ({ stdout: "", stderr: "" }));
+        assert.strictEqual(result, false);
+    });
+  });
+
+  describe("captureGitState", () => {
+    it("should return git state with no uncommitted changes", async () => {
+      const mockExec = async (cmd: string) => {
+        if (cmd === "git rev-parse HEAD") return { stdout: "current-hash", stderr: "" };
+        if (cmd === "git status --porcelain") return { stdout: "", stderr: "" };
+        return { stdout: "", stderr: "" };
+      };
+
+      const state = await captureGitState(mockExec);
+      assert.strictEqual(state.beforeHead, "current-hash");
+      assert.strictEqual(state.afterHead, "current-hash");
+      assert.strictEqual(state.hasUncommittedChanges, false);
+    });
+
+    it("should return git state with uncommitted changes", async () => {
+      const mockExec = async (cmd: string) => {
+        if (cmd === "git rev-parse HEAD") return { stdout: "current-hash", stderr: "" };
+        if (cmd === "git status --porcelain") return { stdout: "M file.ts", stderr: "" };
+        return { stdout: "", stderr: "" };
+      };
+
+      const state = await captureGitState(mockExec);
+      assert.strictEqual(state.hasUncommittedChanges, true);
+    });
+
+    it("should return empty object on failure", async () => {
+      const mockExec = async () => {
+        throw new Error("fail");
+      };
+      const state = await captureGitState(mockExec);
+      assert.deepStrictEqual(state, {});
+    });
+  });
+
+  describe("autoCommit", () => {
+    it("should stage specific files and commit", async () => {
+      const commands: string[] = [];
+      const mockExec = async (cmd: string) => {
+        commands.push(cmd);
+        return { stdout: "", stderr: "" };
+      };
+
+      const commitInfo: CommitInfo = {
+        message: "feat: test",
+        files: ["file1.ts", "file2.ts"]
+      };
+
+      await autoCommit(commitInfo, mockExec);
+      
+      assert.ok(commands.includes("git add file1.ts file2.ts"));
+      assert.ok(commands.includes('git commit -m "feat: test"'));
+    });
+
+    it("should stage all files if no specific files provided", async () => {
+      const commands: string[] = [];
+      const mockExec = async (cmd: string) => {
+        commands.push(cmd);
+        return { stdout: "", stderr: "" };
+      };
+
+      const commitInfo: CommitInfo = {
+        message: "feat: test",
+        files: []
+      };
+
+      await autoCommit(commitInfo, mockExec);
+      
+      assert.ok(commands.includes("git add ."));
+      assert.ok(commands.includes('git commit -m "feat: test"'));
+    });
+
+    it("should handle errors gracefully", async () => {
+      const mockExec = async () => {
+        throw new Error("fail");
+      };
+      // Should not throw
+      await autoCommit({ message: "test", files: [] }, mockExec);
+    });
+  });
+
+  describe("commitFile", () => {
+    it("should stage and commit a single file", async () => {
+      const commands: string[] = [];
+      const mockExec = async (cmd: string) => {
+        commands.push(cmd);
+        return { stdout: "", stderr: "" };
+      };
+
+      await commitFile("file.ts", "update file", mockExec);
+
+      assert.ok(commands.includes("git add file.ts"));
+      assert.ok(commands.includes('git commit -m "update file"'));
+    });
+  });
+
+  describe("Branch Management", () => {
+    it("isClean should return true for empty status", async () => {
+        const mockExec = async () => ({ stdout: "", stderr: "" });
+        const result = await isClean(mockExec);
+        assert.strictEqual(result, true);
+    });
+
+    it("isClean should return false for dirty status", async () => {
+        const mockExec = async () => ({ stdout: "M file.ts", stderr: "" });
+        const result = await isClean(mockExec);
+        assert.strictEqual(result, false);
+    });
+
+    it("getCurrentBranch should return branch name", async () => {
+        const mockExec = async () => ({ stdout: "main", stderr: "" });
+        const result = await getCurrentBranch(mockExec);
+        assert.strictEqual(result, "main");
+    });
+
+    it("createBenchmarkBranch should create branch", async () => {
+        const commands: string[] = [];
+        const mockExec = async (cmd: string) => {
+            commands.push(cmd);
+            return { stdout: "", stderr: "" };
+        };
+        await createBenchmarkBranch("bench-1", "main", mockExec);
+        assert.ok(commands.includes("git checkout -b bench-1 main"));
+    });
+
+    it("checkoutBranch should checkout branch", async () => {
+        const commands: string[] = [];
+        const mockExec = async (cmd: string) => {
+            commands.push(cmd);
+            return { stdout: "", stderr: "" };
+        };
+        await checkoutBranch("main", mockExec);
+        assert.ok(commands.includes("git checkout main"));
+    });
+
+    it("cleanupBenchmarkBranch should delete branch", async () => {
+        const commands: string[] = [];
+        const mockExec = async (cmd: string) => {
+            commands.push(cmd);
+            return { stdout: "", stderr: "" };
+        };
+        await cleanupBenchmarkBranch("bench-1", mockExec);
+        assert.ok(commands.includes("git branch -D bench-1"));
+    });
+  });
+});

package/src/test/mocks/mock-ai-operations.ts

@@ -0,0 +1,205 @@
+import { Task, StreamingOptions, TaskAIMetadata, AIConfig } from "../../types";
+import { AIOptions } from "../../utils/ai-config-builder";
+
+export class MockAIOperations {
+  async enhanceTaskWithDocumentation(
+    taskId: string,
+    title: string,
+    description: string,
+    stackInfo: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: any,
+    aiConfig?: AIConfig,
+    existingResearch?: any
+  ): Promise<string> {
+    return `${description}\n\n🤖 Enhanced with AI documentation for ${title}`;
+  }
+
+  async breakdownTask(
+    task: Task,
+    aiConfig: AIConfig,
+    promptOverride?: string,
+    messageOverride?: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: any,
+    fullContent?: string,
+    stackInfo?: string,
+    existingSubtasks?: Task[],
+    enableFilesystemTools?: boolean
+  ): Promise<Task[]> {
+    return [
+      {
+        id: `${task.id}.1`,
+        title: `Subtask 1: ${task.title}`,
+        description: `First subtask for ${task.title}`,
+        content: `Content for subtask 1`,
+        status: "todo",
+        estimatedEffort: "small",
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      },
+      {
+        id: `${task.id}.2`,
+        title: `Subtask 2: ${task.title}`,
+        description: `Second subtask for ${task.title}`,
+        content: `Content for subtask 2`,
+        status: "todo",
+        estimatedEffort: "medium",
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+      },
+    ];
+  }
+
+  async planTask(
+    taskContext: string,
+    taskDetails: string,
+    aiConfig: AIConfig,
+    promptOverride?: string,
+    messageOverride?: string,
+    streamingOptions?: StreamingOptions
+  ): Promise<string> {
+    return `# Implementation Plan for ${
+      taskContext.split("\n")[0]
+    }\n\n1. Analyze requirements\n2. Implement core functionality\n3. Write tests\n4. Review and refactor`;
+  }
+
+  async analyzeDocumentationNeeds(
+    taskId: string,
+    title: string,
+    content: string,
+    stackInfo: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: any,
+    aiConfig?: AIConfig,
+    existingDocumentations?: string[]
+  ): Promise<any> {
+    return {
+      libraries: [
+        {
+          name: "react",
+          context7Id: "/facebook/react",
+          reason: "Task involves React development",
+          searchQuery: "React hooks best practices",
+        },
+      ],
+      confidence: 0.9,
+      files: ["src/components/TaskComponent.tsx"],
+    };
+  }
+
+  async generateDocumentationRecap(
+    libraries: any[],
+    toolResults: any[],
+    streamingOptions?: StreamingOptions
+  ): Promise<string> {
+    return `## Documentation Recap\n\n${libraries
+      .map((lib) => `- ${lib.name}: ${lib.reason}`)
+      .join("\n")}`;
+  }
+
+  async parsePRD(
+    prdContent: string,
+    aiConfig: AIConfig,
+    promptOverride?: string,
+    messageOverride?: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: any,
+    workingDirectory?: string,
+    enableFilesystemTools?: boolean
+  ): Promise<any> {
+    return {
+      tasks: [
+        {
+          id: "1",
+          title: "Implement user authentication",
+          description: "Add login/logout functionality",
+          content: "Full authentication implementation",
+          estimatedEffort: "medium",
+          dependencies: [],
+          tags: ["auth", "backend"],
+        },
+        {
+          id: "2",
+          title: "Create task management UI",
+          description: "Build React components for task management",
+          content: "Task list, create, edit, delete components",
+          estimatedEffort: "large",
+          dependencies: ["1"],
+          tags: ["ui", "frontend"],
+        },
+      ],
+      summary: "PRD for task management application",
+      estimatedDuration: "2 weeks",
+      confidence: 0.95,
+    };
+  }
+
+  async generatePRDQuestions(
+    prdContent: string,
+    aiConfig: AIConfig,
+    promptOverride?: string,
+    messageOverride?: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: any,
+    workingDirectory?: string,
+    enableFilesystemTools?: boolean
+  ): Promise<string[]> {
+    return [
+      "What authentication providers should be supported?",
+      "Should the task management support real-time collaboration?",
+      "What are the expected performance requirements?",
+    ];
+  }
+
+  async reworkPRD(
+    prdContent: string,
+    feedback: string,
+    aiConfig: AIConfig,
+    promptOverride?: string,
+    messageOverride?: string,
+    streamingOptions?: StreamingOptions,
+    retryConfig?: any,
+    workingDirectory?: string,
+    enableFilesystemTools?: boolean
+  ): Promise<string> {
+    return `${prdContent}\n\n## Improvements Based on Feedback\n\n${feedback}`;
+  }
+
+  async answerPRDQuestions(
+    prdContent: string,
+    questions: string[],
+    aiConfig: AIConfig,
+    context: any,
+    streamingOptions?: StreamingOptions
+  ): Promise<Record<string, string>> {
+    const answers: Record<string, string> = {};
+    questions.forEach((question) => {
+      answers[question] = `AI-generated answer for: ${question}`;
+    });
+    return answers;
+  }
+
+  async generatePRD(
+    description: string,
+    aiConfig: AIConfig,
+    promptOverride?: string,
+    messageOverride?: string,
+    streamingOptions?: StreamingOptions
+  ): Promise<string> {
+    return `# Product Requirements Document\n\n## Overview\n${description}\n\n## Features\n- User authentication\n- Task management\n- Real-time collaboration\n\n## Technical Requirements\n- React frontend\n- Node.js backend\n- PostgreSQL database`;
+  }
+
+  async combinePRDs(
+    prds: string[],
+    originalDescription: string,
+    aiConfig: AIConfig,
+    promptOverride?: string,
+    messageOverride?: string,
+    streamingOptions?: StreamingOptions
+  ): Promise<string> {
+    return `# Master PRD\n\n${prds
+      .map((prd, index) => `## PRD ${index + 1}\n\n${prd}`)
+      .join("\n\n")}`;
+  }
+}

package/src/test/mocks/mock-context-builder.ts

@@ -0,0 +1,84 @@
+import { TaskRepository } from "../../lib/storage/types";
+import { TaskContext } from "../../types";
+
+export class MockContextBuilder {
+  constructor(private storage: TaskRepository) {}
+
+  async buildContextForNewTask(
+    title: string,
+    content?: string
+  ): Promise<TaskContext> {
+    return {
+      task: {
+        id: "new-task",
+        title,
+        description: content || "",
+        fullContent: content,
+      },
+      stack: {
+        projectName: "test-project",
+        frontend: "next",
+        backend: "hono",
+        database: "sqlite",
+        auth: "better-auth",
+        runtime: "node",
+        api: "none",
+        payments: "none",
+        orm: "drizzle",
+        dbSetup: "none",
+        packageManager: "npm",
+        git: true,
+        webDeploy: "none",
+        serverDeploy: "none",
+        install: true,
+        addons: [],
+        examples: [],
+        createdAt: new Date().toISOString(),
+        _source: "mock",
+      },
+      existingResearch: {},
+    };
+  }
+
+  async buildContext(taskId: string): Promise<TaskContext> {
+    const task = await this.storage.getTask(taskId);
+    if (!task) {
+      throw new Error(`Task ${taskId} not found`);
+    }
+
+    return {
+      task: {
+        id: task.id,
+        title: task.title,
+        description: task.description || "",
+        fullContent: task.content || task.description,
+      },
+      stack: {
+        projectName: "test-project",
+        frontend: "next",
+        backend: "hono",
+        database: "sqlite",
+        auth: "better-auth",
+        runtime: "node",
+        api: "none",
+        payments: "none",
+        orm: "drizzle",
+        dbSetup: "none",
+        packageManager: "npm",
+        git: true,
+        webDeploy: "none",
+        serverDeploy: "none",
+        install: true,
+        addons: [],
+        examples: [],
+        createdAt: new Date().toISOString(),
+        _source: "mock",
+      },
+      existingResearch: {},
+    };
+  }
+
+  isDocumentationFresh(documentation: any): boolean {
+    return true;
+  }
+}

package/src/test/mocks/mock-model-provider.ts

@@ -0,0 +1,21 @@
+import { AIConfig } from "../../types";
+
+export class MockModelProvider {
+  private config: AIConfig = {
+    provider: "openrouter",
+    model: "anthropic/claude-3.5-sonnet",
+    apiKey: "test-api-key",
+    baseURL: "https://openrouter.ai/api/v1",
+    maxTokens: 4096,
+    temperature: 0.7,
+    context7Enabled: true,
+  };
+
+  getAIConfig(): AIConfig {
+    return this.config;
+  }
+
+  setAIConfig(config: Partial<AIConfig>): void {
+    this.config = { ...this.config, ...config };
+  }
+}

package/src/test/mocks/mock-service-factory.ts

@@ -0,0 +1,64 @@
+import { MockStorage } from "./mock-storage";
+import { MockAIOperations } from "./mock-ai-operations";
+import { MockModelProvider } from "./mock-model-provider";
+import { MockContextBuilder } from "./mock-context-builder";
+
+// Add jest types for TypeScript
+declare const jest: any;
+
+let mockStorage: MockStorage;
+let mockAIOperations: MockAIOperations;
+let mockModelProvider: MockModelProvider;
+let mockContextBuilder: MockContextBuilder;
+
+export function resetMockServices(): void {
+  mockStorage = new MockStorage();
+  mockAIOperations = new MockAIOperations();
+  mockModelProvider = new MockModelProvider();
+  mockContextBuilder = new MockContextBuilder(mockStorage);
+}
+
+export function getMockStorage(): MockStorage {
+  if (!mockStorage) {
+    resetMockServices();
+  }
+  return mockStorage;
+}
+
+export function getMockAIOperations(): MockAIOperations {
+  if (!mockAIOperations) {
+    resetMockServices();
+  }
+  return mockAIOperations;
+}
+
+export function getMockModelProvider(): MockModelProvider {
+  if (!mockModelProvider) {
+    resetMockServices();
+  }
+  return mockModelProvider;
+}
+
+export function getMockContextBuilder(): MockContextBuilder {
+  if (!mockContextBuilder) {
+    resetMockServices();
+  }
+  return mockContextBuilder;
+}
+
+// Mock the actual service factory functions
+export function mockServiceFactory() {
+  // Override the real service factory functions
+  const originalFactory = jest.requireActual("../../utils/ai-service-factory");
+
+  return {
+    ...originalFactory,
+    getStorage: () => getMockStorage(),
+    getAIOperations: () => getMockAIOperations(),
+    getModelProvider: () => getMockModelProvider(),
+    getContextBuilder: () => getMockContextBuilder(),
+    initializeServices: async () => {
+      // No-op for tests
+    },
+  };
+}