@kakarot-ci/core 0.7.0 → 0.7.1

package/dist/index.cjs

@@ -161,24 +161,11 @@ async function findProjectRoot(startPath) {
 async function loadConfig() {
   const explorer = (0, import_cosmiconfig.cosmiconfig)("kakarot", {
     searchPlaces: [
-      "kakarot.config.ts",
       "kakarot.config.js",
-      ".kakarot-ci.config.ts",
       ".kakarot-ci.config.js",
       ".kakarot-ci.config.json",
       "package.json"
-    ],
-    loaders: {
-      ".ts": async (filepath) => {
-        try {
-          const configModule = await import(filepath);
-          return configModule.default || configModule.config || null;
-        } catch (err) {
-          error(`Failed to load TypeScript config: ${err instanceof Error ? err.message : String(err)}`);
-          return null;
-        }
-      }
-    }
+    ]
   });
   try {
     const result = await explorer.search();
@@ -215,7 +202,7 @@ async function loadConfig() {
   } catch (err) {
     if (err instanceof Error && err.message.includes("apiKey")) {
       error(
-        "Missing required apiKey. Provide it via:\n  - Config file (kakarot.config.ts, .kakarot-ci.config.js/json, or package.json)\n  - Environment variable: KAKAROT_API_KEY"
+        "Missing required apiKey. Provide it via:\n  - Config file (kakarot.config.js, .kakarot-ci.config.js/json, or package.json)\n  - Environment variable: KAKAROT_API_KEY"
       );
     }
     throw err;
@@ -438,6 +425,7 @@ var GitHubClient = class {
   async fileExists(ref, path) {
     const originalError = console.error;
     const originalWarn = console.warn;
+    const originalLog = console.log;
     const suppress404 = (...args) => {
       const message = String(args[0] || "");
       if (message.includes("404") || message.includes("Not Found")) {
@@ -452,9 +440,17 @@ var GitHubClient = class {
       }
       originalWarn(...args);
     };
+    const suppress404Log = (...args) => {
+      const message = String(args[0] || "");
+      if (message.includes("404") || message.includes("Not Found")) {
+        return;
+      }
+      originalLog(...args);
+    };
     try {
       console.error = suppress404;
       console.warn = suppress404Warn;
+      console.log = suppress404Log;
       await this.octokit.rest.repos.getContent({
         owner: this.owner,
         repo: this.repo,
@@ -477,6 +473,7 @@ var GitHubClient = class {
     } finally {
       console.error = originalError;
       console.warn = originalWarn;
+      console.log = originalLog;
     }
   }
   /**
@@ -1148,15 +1145,49 @@ function buildSystemPrompt(framework) {
   const importStatement = framework === "jest" ? "import { describe, it, expect } from 'jest';" : "import { describe, it, expect } from 'vitest';";
   return `You are an expert ${frameworkName} test writer. Your task is to generate comprehensive unit tests for TypeScript/JavaScript functions.
 
+CRITICAL: Test the ACTUAL behavior of the code, not assumed behavior.
+
 Requirements:
 1. Generate complete, runnable ${frameworkName} test code
 2. Use ${frameworkName} syntax and best practices
-3. Test edge cases, error conditions, and normal operation
-4. Use descriptive test names that explain what is being tested
-5. Include proper setup/teardown if needed
-6. Mock external dependencies appropriately
-7. Test both success and failure scenarios
-8. Follow the existing test file structure if one exists
+3. Analyze the function code to determine its ACTUAL runtime behavior before writing tests
+4. Test edge cases and normal operation based on what the code actually does
+5. Only test for errors/exceptions if the code actually throws them (check for try/catch, throw statements, or validation logic)
+6. Match JavaScript/TypeScript runtime semantics:
+   - Arithmetic operations (+, -, *, /, %, **) do NOT throw errors for invalid inputs; they return NaN or Infinity
+   - Division by zero returns Infinity (not an error)
+   - Modulo by zero returns NaN (not an error)
+   - Bitwise operations convert values to 32-bit integers
+   - Operations with null/undefined may coerce to numbers or return NaN
+   - TypeScript types are compile-time only; runtime behavior follows JavaScript rules
+7. For async functions:
+   - Use async/await or .then()/.catch() appropriately
+   - Test both resolved and rejected promises
+   - Use resolves and rejects matchers when appropriate
+   - Await async function calls in tests
+8. For functions with side effects or external dependencies:
+   - Mock external dependencies (APIs, file system, databases, etc.)
+   - Mock imported modules using ${framework === "jest" ? "jest.mock()" : "vi.mock()"}
+   - Reset mocks between tests to ensure test isolation
+   - Verify mock calls if the function's behavior depends on them
+9. For functions that modify state:
+   - Test state before and after function calls
+   - Reset state between tests if needed
+   - Test state mutations, not just return values
+10. For error testing:
+   - Only test for errors if the function actually throws them
+   - Match actual error types and messages (use toThrow() with specific error types/messages)
+   - For async errors, use rejects matcher
+11. Import handling:
+   - Use the same import paths as the source file
+   - Import types correctly (type imports for TypeScript types)
+   - Mock dependencies at the module level, not the function level
+12. Test isolation:
+   - Each test should be independent and not rely on other tests
+   - Use beforeEach/afterEach for setup/teardown when needed
+   - Don't share mutable state between tests
+13. Use descriptive test names that explain what is being tested
+14. Follow the existing test file structure if one exists
 
 Output format:
 - Return ONLY the test code, no explanations or markdown code blocks
@@ -1226,18 +1257,38 @@ ${existingTestFile}
 
 `;
   }
-  prompt += `Generate comprehensive unit tests for ${target.functionName}. Include:
+  prompt += `Generate comprehensive unit tests for ${target.functionName}. IMPORTANT: Analyze the function code above to determine its ACTUAL behavior before writing tests.
+
+`;
+  prompt += `Include:
 `;
   prompt += `- Tests for normal operation with various inputs
 `;
-  prompt += `- Tests for edge cases (null, undefined, empty arrays, etc.)
+  prompt += `- Tests for edge cases based on what the code actually does (null, undefined, empty arrays, etc.)
 `;
-  prompt += `- Tests for error conditions if applicable
+  prompt += `- Tests for error conditions ONLY if the code actually throws errors (check for throw statements, validation, or error handling)
 `;
   prompt += `- Tests for boundary conditions
 `;
   prompt += `- Proper mocking of dependencies if needed
 
+`;
+  prompt += `Key considerations:
+`;
+  prompt += `- If the function is async, use async/await in tests and test both success and error cases
+`;
+  prompt += `- If the function uses external dependencies (imports), mock them appropriately
+`;
+  prompt += `- If the function modifies state, test the state changes
+`;
+  prompt += `- Match actual return types and values, not assumed types
+`;
+  prompt += `- TypeScript types are compile-time only; test runtime behavior
+`;
+  prompt += `- JavaScript/TypeScript arithmetic and bitwise operations do NOT throw errors for invalid inputs. They return NaN, Infinity, or perform type coercion. Only test for errors if the function code explicitly throws them.
+`;
+  prompt += `- Use the same import paths as the source file for consistency
+
 `;
   prompt += `Return ONLY the test code, no explanations or markdown formatting.`;
   return prompt;
@@ -1262,13 +1313,34 @@ Context:
 - The test code failed to run or produced incorrect results
 - You need to analyze the error and fix the test code
 
+CRITICAL: Tests must match the ACTUAL behavior of the code being tested, not assumed behavior.
+
 Requirements:
-1. Fix the test code to make it pass
-2. Maintain the original test intent
-3. Use proper ${frameworkName} syntax
-4. Ensure all imports and dependencies are correct
-5. Fix any syntax errors, type errors, or logical errors
-6. If the original code being tested has issues, note that but focus on fixing the test
+1. Analyze the original function code to understand its ACTUAL runtime behavior
+2. Fix the test code to match what the function actually does, not what it "should" do
+3. Only expect errors/exceptions if the function code actually throws them
+4. Match JavaScript/TypeScript runtime semantics:
+   - Arithmetic operations do NOT throw errors; they return NaN or Infinity
+   - Division by zero returns Infinity (not an error)
+   - Modulo by zero returns NaN (not an error)
+   - Bitwise operations convert values to 32-bit integers
+   - TypeScript types are compile-time only; runtime behavior follows JavaScript rules
+5. For async functions:
+   - Ensure tests properly await async calls
+   - Use resolves/rejects matchers appropriately
+   - Test both success and error cases for async functions
+6. For functions with dependencies:
+   - Ensure mocks are properly set up
+   - Verify import paths match the source file
+   - Reset mocks if needed for test isolation
+7. For error testing:
+   - Only expect errors if the function actually throws them
+   - Match actual error types and messages
+   - Use appropriate matchers (toThrow, rejects, etc.)
+8. Maintain the original test intent where possible, but prioritize correctness
+9. Use proper ${frameworkName} syntax
+10. Ensure all imports and dependencies are correct
+11. Fix any syntax errors, type errors, or logical errors
 
 Output format:
 - Return ONLY the fixed test code, no explanations or markdown code blocks