@grunnverk/kodrdriv 1.3.0

package/temp-dist/util/storage.js

@@ -0,0 +1,149 @@
+// eslint-disable-next-line no-restricted-imports
+import * as fs from 'fs';
+import { glob } from 'glob';
+import path from 'path';
+import crypto from 'crypto';
+export const create = (params) => {
+    // eslint-disable-next-line no-console
+    const log = params.log || console.log;
+    const exists = async (path) => {
+        try {
+            await fs.promises.stat(path);
+            return true;
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        }
+        catch (error) {
+            return false;
+        }
+    };
+    const isDirectory = async (path) => {
+        const stats = await fs.promises.stat(path);
+        if (!stats.isDirectory()) {
+            // Log at debug level since this is expected when scanning directories
+            // that contain both files and directories
+            return false;
+        }
+        return true;
+    };
+    const isFile = async (path) => {
+        const stats = await fs.promises.stat(path);
+        if (!stats.isFile()) {
+            // Log removed since this is expected when checking file types
+            return false;
+        }
+        return true;
+    };
+    const isReadable = async (path) => {
+        try {
+            await fs.promises.access(path, fs.constants.R_OK);
+        }
+        catch (error) {
+            log(`${path} is not readable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isWritable = async (path) => {
+        try {
+            await fs.promises.access(path, fs.constants.W_OK);
+        }
+        catch (error) {
+            log(`${path} is not writable: %s %s`, error.message, error.stack);
+            return false;
+        }
+        return true;
+    };
+    const isFileReadable = async (path) => {
+        return await exists(path) && await isFile(path) && await isReadable(path);
+    };
+    const isDirectoryWritable = async (path) => {
+        return await exists(path) && await isDirectory(path) && await isWritable(path);
+    };
+    const isDirectoryReadable = async (path) => {
+        return await exists(path) && await isDirectory(path) && await isReadable(path);
+    };
+    const createDirectory = async (path) => {
+        try {
+            await fs.promises.mkdir(path, { recursive: true });
+        }
+        catch (mkdirError) {
+            throw new Error(`Failed to create output directory ${path}: ${mkdirError.message} ${mkdirError.stack}`);
+        }
+    };
+    const ensureDirectory = async (path) => {
+        if (!(await exists(path))) {
+            await createDirectory(path);
+        }
+    };
+    const removeDirectory = async (path) => {
+        try {
+            if (await exists(path)) {
+                await fs.promises.rm(path, { recursive: true, force: true });
+            }
+        }
+        catch (rmError) {
+            throw new Error(`Failed to remove directory ${path}: ${rmError.message} ${rmError.stack}`);
+        }
+    };
+    const readFile = async (path, encoding) => {
+        return await fs.promises.readFile(path, { encoding: encoding });
+    };
+    const writeFile = async (path, data, encoding) => {
+        await fs.promises.writeFile(path, data, { encoding: encoding });
+    };
+    const rename = async (oldPath, newPath) => {
+        await fs.promises.rename(oldPath, newPath);
+    };
+    const deleteFile = async (path) => {
+        try {
+            if (await exists(path)) {
+                await fs.promises.unlink(path);
+            }
+        }
+        catch (deleteError) {
+            throw new Error(`Failed to delete file ${path}: ${deleteError.message} ${deleteError.stack}`);
+        }
+    };
+    const forEachFileIn = async (directory, callback, options = { pattern: '*.*' }) => {
+        try {
+            const files = await glob(options.pattern, { cwd: directory, nodir: true });
+            for (const file of files) {
+                await callback(path.join(directory, file));
+            }
+        }
+        catch (err) {
+            throw new Error(`Failed to glob pattern ${options.pattern} in ${directory}: ${err.message}`);
+        }
+    };
+    const readStream = async (path) => {
+        return fs.createReadStream(path);
+    };
+    const hashFile = async (path, length) => {
+        const file = await readFile(path, 'utf8');
+        return crypto.createHash('sha256').update(file).digest('hex').slice(0, length);
+    };
+    const listFiles = async (directory) => {
+        return await fs.promises.readdir(directory);
+    };
+    return {
+        exists,
+        isDirectory,
+        isFile,
+        isReadable,
+        isWritable,
+        isFileReadable,
+        isDirectoryWritable,
+        isDirectoryReadable,
+        createDirectory,
+        ensureDirectory,
+        readFile,
+        readStream,
+        writeFile,
+        rename,
+        deleteFile,
+        forEachFileIn,
+        hashFile,
+        listFiles,
+        removeDirectory,
+    };
+};

package/temp-dist/util/validation.js

@@ -0,0 +1,110 @@
+/**
+ * Runtime validation utilities for safe type handling
+ */
+/**
+ * Validates and safely casts data to ReleaseSummary type
+ */
+export const validateReleaseSummary = (data) => {
+    if (!data || typeof data !== 'object') {
+        throw new Error('Invalid release summary: not an object');
+    }
+    if (typeof data.title !== 'string') {
+        throw new Error('Invalid release summary: title must be a string');
+    }
+    if (typeof data.body !== 'string') {
+        throw new Error('Invalid release summary: body must be a string');
+    }
+    return data;
+};
+/**
+ * Validates and safely casts data to LinkBackup type
+ */
+export const validateLinkBackup = (data) => {
+    if (!data || typeof data !== 'object') {
+        throw new Error('Invalid link backup: not an object');
+    }
+    // Validate each backup entry
+    for (const [key, value] of Object.entries(data)) {
+        if (!value || typeof value !== 'object') {
+            throw new Error(`Invalid link backup entry for ${key}: not an object`);
+        }
+        const entry = value;
+        if (typeof entry.originalVersion !== 'string') {
+            throw new Error(`Invalid link backup entry for ${key}: originalVersion must be a string`);
+        }
+        if (typeof entry.dependencyType !== 'string') {
+            throw new Error(`Invalid link backup entry for ${key}: dependencyType must be a string`);
+        }
+        if (typeof entry.relativePath !== 'string') {
+            throw new Error(`Invalid link backup entry for ${key}: relativePath must be a string`);
+        }
+    }
+    return data;
+};
+/**
+ * Validates transcription result has required text property
+ */
+export const validateTranscriptionResult = (data) => {
+    if (!data || typeof data !== 'object') {
+        throw new Error('Invalid transcription result: not an object');
+    }
+    if (typeof data.text !== 'string') {
+        throw new Error('Invalid transcription result: text property must be a string');
+    }
+    return data;
+};
+/**
+ * Safely parses JSON with error handling
+ */
+export const safeJsonParse = (jsonString, context) => {
+    try {
+        const parsed = JSON.parse(jsonString);
+        if (parsed === null || parsed === undefined) {
+            throw new Error('Parsed JSON is null or undefined');
+        }
+        return parsed;
+    }
+    catch (error) {
+        const contextStr = context ? ` (${context})` : '';
+        throw new Error(`Failed to parse JSON${contextStr}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+};
+/**
+ * Validates that a value is a non-empty string
+ */
+export const validateString = (value, fieldName) => {
+    if (typeof value !== 'string') {
+        throw new Error(`${fieldName} must be a string, got ${typeof value}`);
+    }
+    if (value.trim() === '') {
+        throw new Error(`${fieldName} cannot be empty`);
+    }
+    return value;
+};
+/**
+ * Validates that a value exists and has a specific property
+ */
+export const validateHasProperty = (obj, property, context) => {
+    if (!obj || typeof obj !== 'object') {
+        const contextStr = context ? ` in ${context}` : '';
+        throw new Error(`Object is null or not an object${contextStr}`);
+    }
+    if (!(property in obj)) {
+        const contextStr = context ? ` in ${context}` : '';
+        throw new Error(`Missing required property '${property}'${contextStr}`);
+    }
+};
+/**
+ * Validates package.json structure has basic required fields
+ */
+export const validatePackageJson = (data, context, requireName = true) => {
+    if (!data || typeof data !== 'object') {
+        const contextStr = context ? ` (${context})` : '';
+        throw new Error(`Invalid package.json${contextStr}: not an object`);
+    }
+    if (requireName && typeof data.name !== 'string') {
+        const contextStr = context ? ` (${context})` : '';
+        throw new Error(`Invalid package.json${contextStr}: name must be a string`);
+    }
+    return data;
+};

package/test-external-unlink/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@test/external-unlink-test",
+  "version": "1.0.0",
+  "description": "Test package for external unlink patterns",
+  "main": "index.js",
+  "dependencies": {
+    "@somelib/core": "^1.0.0",
+    "@somelib/utils": "^1.0.0",
+    "lodash": "^4.17.21",
+    "express": "^4.18.2"
+  },
+  "devDependencies": {
+    "@somelib/dev": "^1.0.0",
+    "jest": "^29.0.0"
+  }
+}

package/test-externals/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@test/app",
+  "version": "1.0.0",
+  "dependencies": {
+    "@external/lib": "^1.0.0",
+    "lodash": "^4.17.0"
+  }
+}

package/test-multiline/cli/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "cli-tool",
+  "version": "1.0.0",
+  "description": "Command line tool",
+  "dependencies": {
+    "core-library": "^1.0.0"
+  }
+}

package/test-multiline/core/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "core-library",
+  "version": "1.0.0",
+  "description": "Core library"
+}

package/test-multiline/mobile/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "mobile-app",
+  "version": "1.0.0",
+  "description": "Mobile application",
+  "dependencies": {
+    "core-library": "^1.0.0"
+  }
+}

package/test-multiline/web/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "web-app",
+  "version": "1.0.0",
+  "description": "Web application",
+  "dependencies": {
+    "core-library": "^1.0.0"
+  }
+}

package/test-project/package-lock.json

@@ -0,0 +1,21 @@
+{
+  "name": "test-project",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "test-project",
+      "dependencies": {
+        "@myorg/utils": "file:../packages/utils"
+      }
+    },
+    "../packages/utils": {
+      "name": "@myorg/utils",
+      "version": "1.2.3"
+    },
+    "node_modules/@myorg/utils": {
+      "resolved": "../packages/utils",
+      "link": true
+    }
+  }
+}

package/test-project/package.json

@@ -0,0 +1 @@
+{"name": "test-project", "dependencies": {"@myorg/utils": "file:../packages/utils"}}

package/test-review-flow.sh

@@ -0,0 +1,15 @@
+#!/bin/bash
+
+echo "Testing the new two-phase review flow..."
+echo "This will test the file selection phase and then the analysis phase"
+
+# Test with a single file in the test-project directory
+echo "Test review note content" > test-project/test-review.md
+
+echo "Running review command in test-project directory..."
+echo "You should see:"
+echo "1. File selection phase with c/s/a options"
+echo "2. Analysis phase after files are selected"
+
+cd test-project
+../dist/main.js review --directory .

package/test-sort-files/alpha.md

@@ -0,0 +1,3 @@
+# Alpha Review
+
+This file should be processed first alphabetically.

package/test-sort-files/middle.txt

@@ -0,0 +1,3 @@
+# Middle Review
+
+This file should be processed in the middle alphabetically.

package/test-sort-files/zebra.txt

@@ -0,0 +1,3 @@
+# Zebra Review
+
+This file should be processed last alphabetically.

package/test_output.txt

@@ -0,0 +1,161 @@
+
+> @grunnverk/kodrdriv@1.2.3-dev.0 test
+> vitest run --coverage tests/commands/tree.test.ts
+
+
+ RUN  v3.2.4 kodrdriv
+      Coverage enabled with v8
+
+ ❯ tests/commands/tree.test.ts (60 tests | 6 failed) 57ms
+   ✓ tree > execute > should handle empty directory with no package.json files 3ms
+   ✓ tree > execute > should scan and build dependency graph for simple packages 1ms
+   ✓ tree > execute > should handle circular dependencies 1ms
+   ✓ tree > execute > should exclude packages based on patterns 1ms
+   ✓ tree > execute > should start from specified package 1ms
+   ✓ tree > execute > should throw error for invalid startFrom package 0ms
+   ✓ tree > execute > should stop at specified package 0ms
+   ✓ tree > execute > should stop at specified package with multiple dependencies 1ms
+   ✓ tree > execute > should combine startFrom and stopAt options 0ms
+   ✓ tree > execute > should throw error for invalid stopAt package 0ms
+   ✓ tree > execute > should execute command in dry run mode 1ms
+   ✓ tree > execute > should execute command in packages 1ms
+   ✓ tree > execute > should handle command execution failure and provide recovery command 1ms
+   ✓ tree > execute > should handle package.json without name field 1ms
+   ✓ tree > execute > should handle invalid JSON in package.json 1ms
+   ✓ tree > execute > should handle file system errors during scanning 0ms
+   ✓ tree > execute > should use custom directories from config 0ms
+   ✓ tree > execute > should return build order without executing command when no cmd provided 1ms
+   ✓ tree > execute > should collect all dependency types 1ms
+   ✓ tree > error formatting and handling > should format command errors with stderr and stdout 1ms
+   ✓ tree > error formatting and handling > should format simple errors without stderr/stdout 1ms
+   ✓ tree > error formatting and handling > should restore working directory after command failure 1ms
+   ✓ tree > error formatting and handling > should handle packages with no version field 1ms
+   ✓ tree > complex dependency scenarios > should handle deep dependency chains 1ms
+   ✓ tree > complex dependency scenarios > should handle diamond dependency pattern 1ms
+   ✓ tree > complex dependency scenarios > should handle multiple independent packages 1ms
+   ✓ tree > complex dependency scenarios > should handle mixed dependency types 1ms
+   ✓ tree > inter-project dependency updates for tree publish > should handle dry run for inter-project dependency updates 1ms
+   ✓ tree > continue functionality and execution context > should handle missing execution context gracefully 1ms
+   × tree > continue functionality and execution context > should save execution context for publish commands 6ms
+     → Failed to analyze workspace: Command failed in package package-a
+   × tree > continue functionality and execution context > should cleanup context on successful completion 1ms
+     → Failed to analyze workspace: Command failed in package package-a
+   ✓ tree > built-in command execution > should execute commit command across packages 1ms
+   ✓ tree > built-in command execution > should execute link command with package argument 1ms
+   ✓ tree > built-in command execution > should execute unlink command with clean-node-modules option 1ms
+   × tree > built-in command execution > should propagate global options to built-in commands 2ms
+     → expected "spy" to be called at least once
+   ✓ tree > built-in command execution > should handle link status subcommand 1ms
+   ✓ tree > built-in command execution > should handle unlink status subcommand 1ms
+   ✓ tree > built-in command execution > should throw error for unsupported built-in command 1ms
+   × tree > inter-project dependency updates > should update inter-project dependencies before publish 1ms
+     → Failed to analyze workspace: Command failed in package package-a
+   × tree > inter-project dependency updates > should commit dependency updates before publish 1ms
+     → Failed to analyze workspace: Command failed in package package-a
+   ✓ tree > error handling edge cases > should handle working directory restoration failure 2ms
+   × tree > error handling edge cases > should handle storage errors during context operations 1ms
+     → Failed to analyze workspace: Command failed in package package-a
+   ✓ tree > error handling edge cases > should handle invalid execution context data 1ms
+   ✓ tree > multiple directory scenarios > should handle empty directories gracefully 1ms
+   ✓ tree > multiple directory scenarios > should handle mixed directory scenarios 1ms
+   ✓ tree > exclusion pattern edge cases > should handle complex glob patterns 1ms
+   ✓ tree > exclusion pattern edge cases > should handle exclusion patterns with special characters 1ms
+   ✓ tree > package logger functionality > should create package-specific loggers with correct prefixes 1ms
+   ✓ tree > package logger functionality > should handle dry run logging correctly 1ms
+   ✓ tree > branches command advanced features > should handle packages with consumers and link problems 1ms
+   ✓ tree > branches command advanced features > should handle ANSI color support detection 1ms
+   ✓ tree > verbose and debug logging modes > should provide detailed logging in verbose mode 1ms
+   ✓ tree > additional tree functionality > should handle exclusion patterns correctly 1ms
+   ✓ tree > additional tree functionality > should handle multiple directories scanning 1ms
+   ✓ tree > additional tree functionality > should show appropriate logging levels for command execution 1ms
+   ✓ tree > branches command > should display branch status table for all packages 1ms
+   ✓ tree > branches command > should handle git errors gracefully in branches command 1ms
+   ✓ tree > branches command > should format table columns correctly with varying lengths 1ms
+   ✓ tree > branches command > should not execute other commands when branches is specified 1ms
+   ✓ tree > branches command > should display asterisk for packages with linked dependencies 1ms
+
+⎯⎯⎯⎯⎯⎯⎯ Failed Tests 6 ⎯⎯⎯⎯⎯⎯⎯
+
+ FAIL  tests/commands/tree.test.ts > tree > continue functionality and execution context > should save execution context for publish commands
+Error: Failed to analyze workspace: Command failed in package package-a
+ ❯ Module.execute src/commands/tree.ts:1648:15
+    1646|         const errorMessage = `Failed to analyze workspace: ${error.mes…
+    1647|         logger.error(errorMessage);
+    1648|         throw new Error(errorMessage);
+       |               ^
+    1649|     } finally {
+    1650|         // Clean up mutex resources to prevent memory leaks
+ ❯ tests/commands/tree.test.ts:968:13
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[1/6]⎯
+
+ FAIL  tests/commands/tree.test.ts > tree > continue functionality and execution context > should cleanup context on successful completion
+Error: Failed to analyze workspace: Command failed in package package-a
+ ❯ Module.execute src/commands/tree.ts:1648:15
+    1646|         const errorMessage = `Failed to analyze workspace: ${error.mes…
+    1647|         logger.error(errorMessage);
+    1648|         throw new Error(errorMessage);
+       |               ^
+    1649|     } finally {
+    1650|         // Clean up mutex resources to prevent memory leaks
+ ❯ tests/commands/tree.test.ts:993:13
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[2/6]⎯
+
+ FAIL  tests/commands/tree.test.ts > tree > built-in command execution > should propagate global options to built-in commands
+AssertionError: expected "spy" to be called at least once
+ ❯ tests/commands/tree.test.ts:1105:37
+    1103|
+    1104|             // Verify the command was executed (basic check)
+    1105|             expect(mockExecPromise).toHaveBeenCalled();
+       |                                     ^
+    1106|         });
+    1107|
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[3/6]⎯
+
+ FAIL  tests/commands/tree.test.ts > tree > inter-project dependency updates > should update inter-project dependencies before publish
+Error: Failed to analyze workspace: Command failed in package package-a
+ ❯ Module.execute src/commands/tree.ts:1648:15
+    1646|         const errorMessage = `Failed to analyze workspace: ${error.mes…
+    1647|         logger.error(errorMessage);
+    1648|         throw new Error(errorMessage);
+       |               ^
+    1649|     } finally {
+    1650|         // Clean up mutex resources to prevent memory leaks
+ ❯ tests/commands/tree.test.ts:1186:13
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[4/6]⎯
+
+ FAIL  tests/commands/tree.test.ts > tree > inter-project dependency updates > should commit dependency updates before publish
+Error: Failed to analyze workspace: Command failed in package package-a
+ ❯ Module.execute src/commands/tree.ts:1648:15
+    1646|         const errorMessage = `Failed to analyze workspace: ${error.mes…
+    1647|         logger.error(errorMessage);
+    1648|         throw new Error(errorMessage);
+       |               ^
+    1649|     } finally {
+    1650|         // Clean up mutex resources to prevent memory leaks
+ ❯ tests/commands/tree.test.ts:1206:13
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[5/6]⎯
+
+ FAIL  tests/commands/tree.test.ts > tree > error handling edge cases > should handle storage errors during context operations
+Error: Failed to analyze workspace: Command failed in package package-a
+ ❯ Module.execute src/commands/tree.ts:1648:15
+    1646|         const errorMessage = `Failed to analyze workspace: ${error.mes…
+    1647|         logger.error(errorMessage);
+    1648|         throw new Error(errorMessage);
+       |               ^
+    1649|     } finally {
+    1650|         // Clean up mutex resources to prevent memory leaks
+ ❯ tests/commands/tree.test.ts:1253:13
+
+⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯[6/6]⎯
+
+
+ Test Files  1 failed (1)
+      Tests  6 failed | 54 passed (60)
+   Start at  10:00:29
+   Duration  500ms (transform 80ms, setup 0ms, collect 97ms, tests 57ms, environment 0ms, prepare 35ms)
+