codemodctl 0.1.14 → 0.1.16

package/dist/cli.js

@@ -1,11 +1,12 @@
 #!/usr/bin/env node
-import { analyzeCodeowners, getApplicableFiles } from "./codeowner-analysis-pG3p0RPU.js";
-import { calculateOptimalShardCount, distributeFilesAcrossShards } from "./consistent-sharding-pjG1rI6w.js";
+import "./codemod-cli-DailrcEf.js";
+import { analyzeCodeowners } from "./codeowner-analysis-BcFoet6s.js";
+import "./consistent-sharding-lYO6XLIO.js";
+import { analyzeDirectories } from "./directory-analysis-v_cncT1X.js";
 import { defineCommand, runMain } from "citty";
 import crypto from "node:crypto";
 import { $ } from "execa";
 import { writeFile } from "node:fs/promises";
-import path from "node:path";
 
 //#region src/commands/git/create-pr.ts
 const createPrCommand = defineCommand({
@@ -262,97 +263,6 @@ const codeownerCommand = defineCommand({
 	}
 });
 
-//#endregion
-//#region src/utils/directory-analysis.ts
-/**
-* Groups files by their immediate subdirectory within the target directory
-*
-* @param files - Array of file paths to group
-* @param target - Target directory to analyze subdirectories within
-* @returns Map of subdirectory paths to their file lists
-*/
-function groupFilesByDirectory(files, target) {
-	const normalizedTarget = path.normalize(target);
-	const filesByDirectory = /* @__PURE__ */ new Map();
-	for (const filePath of files) {
-		const normalizedFile = path.normalize(filePath);
-		if (!normalizedFile.startsWith(normalizedTarget)) continue;
-		const relativePath = path.relative(normalizedTarget, normalizedFile);
-		if (!relativePath.includes(path.sep)) continue;
-		const firstDir = relativePath.split(path.sep)[0];
-		if (!firstDir) continue;
-		const subdirectory = path.join(normalizedTarget, firstDir);
-		if (!filesByDirectory.has(subdirectory)) filesByDirectory.set(subdirectory, []);
-		filesByDirectory.get(subdirectory).push(normalizedFile);
-	}
-	return filesByDirectory;
-}
-/**
-* Creates directory-based shards using consistent hashing within each directory group.
-* Maintains consistency with existing state when provided.
-*
-* @param filesByDirectory - Map of directory paths to their file lists
-* @param shardSize - Target number of files per shard
-* @param existingState - Optional existing state for consistency
-* @returns Array of directory-based shards
-*/
-function createDirectoryShards(filesByDirectory, shardSize, existingState) {
-	const allShards = [];
-	const existingByDirectory = /* @__PURE__ */ new Map();
-	if (existingState) for (const shard of existingState) {
-		if (!existingByDirectory.has(shard.directory)) existingByDirectory.set(shard.directory, []);
-		existingByDirectory.get(shard.directory).push(shard);
-	}
-	for (const [directory, files] of filesByDirectory.entries()) {
-		const fileCount = files.length;
-		const optimalShardCount = calculateOptimalShardCount(fileCount, shardSize);
-		const existingShards = existingByDirectory.get(directory) || [];
-		const existingShardCount = existingShards.length > 0 ? existingShards[0]?.shardCount ?? 0 : 0;
-		const shardCount = existingShardCount > 0 ? existingShardCount : optimalShardCount;
-		console.log(`Directory "${directory}" contains ${fileCount} files, ${existingShardCount > 0 ? `maintaining ${shardCount} existing shards` : `creating ${shardCount} new shards`}`);
-		const shardMap = distributeFilesAcrossShards(files, shardCount);
-		for (let shardIndex = 0; shardIndex < shardCount; shardIndex++) {
-			const shardFiles = shardMap.get(shardIndex) || [];
-			allShards.push({
-				directory,
-				shard: shardIndex + 1,
-				shardCount,
-				files: shardFiles.sort()
-			});
-		}
-	}
-	return allShards;
-}
-/**
-* Main function to analyze directories and generate shard configuration.
-* Maintains consistency with existing state when provided.
-*
-* @param options - Configuration options for directory analysis
-* @returns Promise resolving to directory analysis result
-* @throws Error if no files found in target subdirectories
-*/
-async function analyzeDirectories(options) {
-	const { shardSize, target, rulePath, language, projectRoot = process.cwd(), existingState } = options;
-	console.debug(`Using rule file: ${rulePath}`);
-	console.debug(`Target directory: ${target}`);
-	console.debug(`Shard size: ${shardSize}`);
-	if (existingState) console.debug(`Using existing state with ${existingState.length} shards`);
-	console.log("Analyzing files with CLI command...");
-	const applicableFiles = await getApplicableFiles(rulePath, language, projectRoot);
-	console.log("Grouping files by directory...");
-	const filesByDirectory = groupFilesByDirectory(applicableFiles, target);
-	if (filesByDirectory.size === 0) throw new Error(`No files found in subdirectories of target: ${target}`);
-	console.log(`Found ${filesByDirectory.size} subdirectories in target`);
-	console.log("Generating directory-based shards...");
-	const shards = createDirectoryShards(filesByDirectory, shardSize, existingState);
-	const totalFiles = Array.from(filesByDirectory.values()).reduce((sum, files) => sum + files.length, 0);
-	console.log(`Generated ${shards.length} total shards for ${totalFiles} files across ${filesByDirectory.size} directories`);
-	return {
-		shards,
-		totalFiles
-	};
-}
-
 //#endregion
 //#region src/commands/shard/directory.ts
 /**

package/dist/codemod-cli-DailrcEf.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { execSync } from "node:child_process";
+
+//#region src/utils/codemod-cli.ts
+/**
+* Executes the codemod CLI command and returns applicable file paths
+*/
+async function getApplicableFiles(rulePath, language, projectRoot) {
+	try {
+		const command = `npx -y codemod@latest jssg list-applicable --language ${language} --target ${projectRoot} ${rulePath}`;
+		console.debug(`Executing: ${command}`);
+		const applicableFiles = execSync(command, {
+			encoding: "utf8",
+			cwd: projectRoot,
+			maxBuffer: 10 * 1024 * 1024
+		}).split("\n").filter((line) => line.startsWith("[Applicable] ")).map((line) => line.replace("[Applicable] ", "").trim()).filter((filePath) => filePath.length > 0);
+		console.debug(`Found ${applicableFiles.length} applicable files`);
+		return applicableFiles;
+	} catch (error) {
+		console.error("Error executing codemod CLI:", error);
+		throw new Error(`Failed to execute codemod CLI: ${error}`);
+	}
+}
+
+//#endregion
+export { getApplicableFiles };

package/dist/{codeowner-analysis-pG3p0RPU.js → codeowner-analysis-BcFoet6s.js}

@@ -1,31 +1,9 @@
 #!/usr/bin/env node
+import { getApplicableFiles } from "./codemod-cli-DailrcEf.js";
 import { existsSync } from "node:fs";
 import path, { resolve } from "node:path";
 import Codeowners from "codeowners";
-import { execSync } from "node:child_process";
 
-//#region src/utils/codemod-cli.ts
-/**
-* Executes the codemod CLI command and returns applicable file paths
-*/
-async function getApplicableFiles(rulePath, language, projectRoot) {
-	try {
-		const command = `npx -y codemod@latest jssg list-applicable --language ${language} --target ${projectRoot} ${rulePath}`;
-		console.debug(`Executing: ${command}`);
-		const applicableFiles = execSync(command, {
-			encoding: "utf8",
-			cwd: projectRoot,
-			maxBuffer: 10 * 1024 * 1024
-		}).split("\n").filter((line) => line.startsWith("[Applicable] ")).map((line) => line.replace("[Applicable] ", "").trim()).filter((filePath) => filePath.length > 0);
-		console.debug(`Found ${applicableFiles.length} applicable files`);
-		return applicableFiles;
-	} catch (error) {
-		console.error("Error executing codemod CLI:", error);
-		throw new Error(`Failed to execute codemod CLI: ${error}`);
-	}
-}
-
-//#endregion
 //#region src/utils/codeowner-analysis.ts
 /**
 * Finds and resolves the CODEOWNERS file path
@@ -177,4 +155,4 @@ async function analyzeCodeowners(options) {
 }
 
 //#endregion
-export { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getApplicableFiles, getTeamFileInfo, normalizeOwnerName };
+export { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName };

package/dist/codeowners.d.ts

@@ -1,2 +1,2 @@
-import { CodeownerAnalysisOptions, CodeownerAnalysisResult, ShardResult, TeamFileInfo, analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-B7Jrhm9T.js";
+import { CodeownerAnalysisOptions, CodeownerAnalysisResult, ShardResult, TeamFileInfo, analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-CkGR1oU6.js";
 export { CodeownerAnalysisOptions, CodeownerAnalysisResult, ShardResult, TeamFileInfo, analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName };

package/dist/codeowners.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
-import { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-pG3p0RPU.js";
+import "./codemod-cli-DailrcEf.js";
+import { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-BcFoet6s.js";
 
 export { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName };

package/dist/directory-analysis-v_cncT1X.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import { getApplicableFiles } from "./codemod-cli-DailrcEf.js";
+import { calculateOptimalShardCount, distributeFilesAcrossShards } from "./consistent-sharding-lYO6XLIO.js";
+import path from "node:path";
+
+//#region src/utils/directory-analysis.ts
+/**
+* Groups files by their immediate subdirectory within the target directory
+*
+* @param files - Array of file paths to group
+* @param target - Target directory to analyze subdirectories within
+* @param projectRoot - Root directory of the project for resolving relative paths
+* @returns Map of subdirectory paths to their file lists
+*/
+function groupFilesByDirectory(files, target, projectRoot) {
+	const resolvedTarget = path.resolve(projectRoot, target);
+	const filesByDirectory = /* @__PURE__ */ new Map();
+	for (const filePath of files) {
+		const normalizedFile = path.normalize(filePath);
+		const resolvedFile = path.resolve(projectRoot, normalizedFile);
+		if (!resolvedFile.startsWith(resolvedTarget)) continue;
+		const relativePath = path.relative(projectRoot, resolvedFile);
+		const relativeFromTarget = path.relative(resolvedTarget, resolvedFile);
+		if (!relativeFromTarget.includes(path.sep)) continue;
+		const firstDir = relativeFromTarget.split(path.sep)[0];
+		if (!firstDir) continue;
+		const subdirectory = path.relative(projectRoot, path.join(resolvedTarget, firstDir));
+		if (!filesByDirectory.has(subdirectory)) filesByDirectory.set(subdirectory, []);
+		filesByDirectory.get(subdirectory).push(relativePath);
+	}
+	return filesByDirectory;
+}
+/**
+* Creates directory-based shards using consistent hashing within each directory group.
+* Maintains consistency with existing state when provided.
+*
+* @param filesByDirectory - Map of directory paths to their file lists
+* @param shardSize - Target number of files per shard
+* @param existingState - Optional existing state for consistency
+* @returns Array of directory-based shards
+*/
+function createDirectoryShards(filesByDirectory, shardSize, existingState) {
+	const allShards = [];
+	const existingByDirectory = /* @__PURE__ */ new Map();
+	if (existingState) for (const shard of existingState) {
+		if (!existingByDirectory.has(shard.directory)) existingByDirectory.set(shard.directory, []);
+		existingByDirectory.get(shard.directory).push(shard);
+	}
+	for (const [directory, files] of filesByDirectory.entries()) {
+		const fileCount = files.length;
+		const optimalShardCount = calculateOptimalShardCount(fileCount, shardSize);
+		const existingShards = existingByDirectory.get(directory) || [];
+		const existingShardCount = existingShards.length > 0 ? existingShards[0]?.shardCount ?? 0 : 0;
+		const shardCount = existingShardCount > 0 ? existingShardCount : optimalShardCount;
+		console.log(`Directory "${directory}" contains ${fileCount} files, ${existingShardCount > 0 ? `maintaining ${shardCount} existing shards` : `creating ${shardCount} new shards`}`);
+		const shardMap = distributeFilesAcrossShards(files, shardCount);
+		for (let shardIndex = 0; shardIndex < shardCount; shardIndex++) {
+			const shardFiles = shardMap.get(shardIndex) || [];
+			allShards.push({
+				directory,
+				shard: shardIndex + 1,
+				shardCount,
+				files: shardFiles.sort()
+			});
+		}
+	}
+	return allShards;
+}
+/**
+* Main function to analyze directories and generate shard configuration.
+* Maintains consistency with existing state when provided.
+*
+* @param options - Configuration options for directory analysis
+* @returns Promise resolving to directory analysis result
+* @throws Error if no files found in target subdirectories
+*/
+async function analyzeDirectories(options) {
+	const { shardSize, target, rulePath, language, projectRoot = process.cwd(), existingState } = options;
+	if (existingState) console.debug(`Using existing state with ${existingState.length} shards`);
+	console.log("Analyzing files with CLI command...");
+	const applicableFiles = await getApplicableFiles(rulePath, language, projectRoot);
+	console.log("Grouping files by directory...");
+	const resolvedTarget = path.resolve(projectRoot, target);
+	const filesByDirectory = groupFilesByDirectory(applicableFiles, resolvedTarget, projectRoot);
+	if (filesByDirectory.size === 0) throw new Error(`No files found in subdirectories of target: ${target}`);
+	console.log(`Found ${filesByDirectory.size} subdirectories in target`);
+	console.log("Generating directory-based shards...");
+	const shards = createDirectoryShards(filesByDirectory, shardSize, existingState);
+	const totalFiles = Array.from(filesByDirectory.values()).reduce((sum, files) => sum + files.length, 0);
+	console.log(`Generated ${shards.length} total shards for ${totalFiles} files across ${filesByDirectory.size} directories`);
+	return {
+		shards,
+		totalFiles
+	};
+}
+
+//#endregion
+export { analyzeDirectories, createDirectoryShards, groupFilesByDirectory };

package/dist/directory.d.ts

@@ -0,0 +1,70 @@
+//#region src/utils/directory-analysis.d.ts
+/**
+ * Result for a single directory-based shard
+ */
+interface DirectoryShardResult {
+  /** The directory path this shard belongs to */
+  directory: string;
+  /** The shard number (1-based) within this directory */
+  shard: number;
+  /** Total number of shards for this directory */
+  shardCount: number;
+  /** Array of file paths in this shard */
+  files: string[];
+}
+/**
+ * Options for directory-based analysis
+ */
+interface DirectoryAnalysisOptions {
+  /** Target number of files per shard */
+  shardSize: number;
+  /** Target directory to analyze subdirectories within */
+  target: string;
+  /** Path to the codemod rule file */
+  rulePath: string;
+  /** Programming language for the codemod */
+  language: string;
+  /** Project root directory (defaults to process.cwd()) */
+  projectRoot?: string;
+  /** Existing state for consistency (optional) */
+  existingState?: DirectoryShardResult[];
+}
+/**
+ * Result of directory-based analysis
+ */
+interface DirectoryAnalysisResult {
+  /** Array of directory-based shards */
+  shards: DirectoryShardResult[];
+  /** Total number of files processed */
+  totalFiles: number;
+}
+/**
+ * Groups files by their immediate subdirectory within the target directory
+ *
+ * @param files - Array of file paths to group
+ * @param target - Target directory to analyze subdirectories within
+ * @param projectRoot - Root directory of the project for resolving relative paths
+ * @returns Map of subdirectory paths to their file lists
+ */
+declare function groupFilesByDirectory(files: string[], target: string, projectRoot: string): Map<string, string[]>;
+/**
+ * Creates directory-based shards using consistent hashing within each directory group.
+ * Maintains consistency with existing state when provided.
+ *
+ * @param filesByDirectory - Map of directory paths to their file lists
+ * @param shardSize - Target number of files per shard
+ * @param existingState - Optional existing state for consistency
+ * @returns Array of directory-based shards
+ */
+declare function createDirectoryShards(filesByDirectory: Map<string, string[]>, shardSize: number, existingState?: DirectoryShardResult[]): DirectoryShardResult[];
+/**
+ * Main function to analyze directories and generate shard configuration.
+ * Maintains consistency with existing state when provided.
+ *
+ * @param options - Configuration options for directory analysis
+ * @returns Promise resolving to directory analysis result
+ * @throws Error if no files found in target subdirectories
+ */
+declare function analyzeDirectories(options: DirectoryAnalysisOptions): Promise<DirectoryAnalysisResult>;
+//#endregion
+export { DirectoryAnalysisOptions, DirectoryAnalysisResult, DirectoryShardResult, analyzeDirectories, createDirectoryShards, groupFilesByDirectory };

package/dist/directory.js

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+import "./codemod-cli-DailrcEf.js";
+import "./consistent-sharding-lYO6XLIO.js";
+import { analyzeDirectories, createDirectoryShards, groupFilesByDirectory } from "./directory-analysis-v_cncT1X.js";
+
+export { analyzeDirectories, createDirectoryShards, groupFilesByDirectory };

package/dist/index.d.ts

@@ -1,3 +1,3 @@
-import { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename } from "./consistent-sharding-CwWnbSoW.js";
-import { CodeownerAnalysisOptions, CodeownerAnalysisResult, ShardResult, TeamFileInfo, analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-B7Jrhm9T.js";
+import { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename } from "./consistent-sharding-B-Si8jYX.js";
+import { CodeownerAnalysisOptions, CodeownerAnalysisResult, ShardResult, TeamFileInfo, analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-CkGR1oU6.js";
 export { CodeownerAnalysisOptions, CodeownerAnalysisResult, ShardResult, TeamFileInfo, analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, normalizeOwnerName };

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-pG3p0RPU.js";
-import { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename } from "./consistent-sharding-pjG1rI6w.js";
+import "./codemod-cli-DailrcEf.js";
+import { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, findCodeownersFile, generateShards, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-BcFoet6s.js";
+import { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename } from "./consistent-sharding-lYO6XLIO.js";
 
 export { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, normalizeOwnerName };

package/dist/sharding.d.ts

@@ -1,2 +1,2 @@
-import { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename } from "./consistent-sharding-CwWnbSoW.js";
+import { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename } from "./consistent-sharding-B-Si8jYX.js";
 export { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename };

package/dist/sharding.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename } from "./consistent-sharding-pjG1rI6w.js";
+import { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename } from "./consistent-sharding-lYO6XLIO.js";
 
 export { analyzeShardScaling, calculateOptimalShardCount, distributeFilesAcrossShards, fitsInShard, getFileHashPosition, getNumericFileNameSha1, getShardForFilename };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemodctl",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "CLI tool and utilities for workflow engine operations, file sharding, and codeowner analysis",
   "type": "module",
   "exports": {