codemodctl 0.1.6 → 0.1.8

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { analyzeCodeowners } from "./codeowner-analysis-CcSOX0Ve.js";
+import { analyzeCodeowners } from "./codeowner-analysis-CYaliyNC.js";
 import { defineCommand, runMain } from "citty";
 import crypto from "node:crypto";
 import { $ } from "execa";
@@ -187,19 +187,24 @@ const codeownerCommand = defineCommand({
 		},
 		codeowners: {
 			type: "string",
-			alias: "c",
 			description: "Path to CODEOWNERS file (optional)",
 			required: false
 		},
-		rule: {
+		codemodFile: {
+			type: "string",
+			alias: "c",
+			description: "Path to codemod file",
+			required: true
+		},
+		language: {
 			type: "string",
-			alias: "r",
-			description: "Path to rule file",
+			alias: "l",
+			description: "Language of the codemod",
 			required: true
 		}
 	},
 	async run({ args }) {
-		const { shardSize: shardSizeStr, stateProp, codeowners: codeownersPath, rule: rulePath } = args;
+		const { shardSize: shardSizeStr, stateProp, codeowners: codeownersPath, codemodFile: codemodFilePath, language } = args;
 		const shardSize = parseInt(shardSizeStr, 10);
 		if (isNaN(shardSize) || shardSize <= 0) {
 			console.error("Error: shard-size must be a positive number");
@@ -215,8 +220,9 @@ const codeownerCommand = defineCommand({
 			const analysisOptions = {
 				shardSize,
 				codeownersPath,
-				rulePath,
-				projectRoot: process.cwd()
+				rulePath: codemodFilePath,
+				projectRoot: process.cwd(),
+				language
 			};
 			const result = await analyzeCodeowners(analysisOptions);
 			const stateOutput = `${stateProp}=${JSON.stringify(result.shards)}\n`;

package/dist/{codeowner-analysis-CcSOX0Ve.js → codeowner-analysis-CYaliyNC.js}

@@ -1,11 +1,9 @@
 #!/usr/bin/env node
 import crypto from "node:crypto";
-import { readFile } from "node:fs/promises";
+import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import path, { resolve } from "node:path";
-import { Lang, findInFiles } from "@ast-grep/napi";
 import Codeowners from "codeowners";
-import yaml from "yaml";
 
 //#region src/utils/consistent-sharding.ts
 const HASH_RING_SIZE = 1e6;
@@ -73,25 +71,6 @@ function calculateOptimalShardCount(totalFiles, targetShardSize) {
 	return Math.ceil(totalFiles / targetShardSize);
 }
 
-//#endregion
-//#region src/utils/counted-promise.ts
-function countedPromise(func) {
-	return async (lang, t, cb) => {
-		let i = 0;
-		let fileCount = void 0;
-		let resolve$1 = () => {};
-		async function wrapped(...args) {
-			const ret = await cb(...args);
-			if (++i === fileCount) resolve$1();
-			return ret;
-		}
-		fileCount = await func(lang, t, wrapped);
-		if (fileCount > i) await new Promise((r) => resolve$1 = r);
-		return fileCount;
-	};
-}
-const countedFindInFiles = countedPromise(findInFiles);
-
 //#endregion
 //#region src/utils/codeowner-analysis.ts
 /**
@@ -114,40 +93,41 @@ async function findCodeownersFile(projectRoot = process.cwd(), explicitPath) {
 	return null;
 }
 /**
-* Loads and parses AST-grep rule from YAML file
-*/
-async function loadAstGrepRule(rulePath) {
-	if (!existsSync(rulePath)) throw new Error(`Rule file not found at: ${rulePath}`);
-	const ruleContent = await readFile(rulePath, "utf8");
-	const parsedRules = yaml.parseAllDocuments(ruleContent);
-	if (!parsedRules[0]) throw new Error("Invalid rule file: no rules found");
-	return parsedRules[0].toJSON();
-}
-/**
 * Normalizes owner name by removing @ prefix and converting to lowercase
 */
 function normalizeOwnerName(owner) {
 	return owner.replace("@", "").toLowerCase();
 }
 /**
+* Executes the codemod CLI command and returns applicable file paths
+*/
+async function getApplicableFiles(rulePath, language, projectRoot) {
+	try {
+		const command = `npx 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}`);
+	}
+}
+/**
 * Analyzes files and groups them by codeowner team
 */
-async function analyzeFilesByOwner(codeownersPath, rule, projectRoot = process.cwd()) {
+async function analyzeFilesByOwner(codeownersPath, language, rulePath, projectRoot = process.cwd()) {
 	const codeowners = new Codeowners(codeownersPath);
 	const gitRootDir = codeowners.codeownersDirectory;
 	const filesByOwner = /* @__PURE__ */ new Map();
-	await countedFindInFiles(Lang.TypeScript, {
-		matcher: rule,
-		paths: [projectRoot]
-	}, (err, matches) => {
-		if (err) {
-			console.error("AST-grep error:", err);
-			return;
-		}
-		if (!matches || matches.length === 0) return;
-		const fileName = matches[0]?.getRoot().filename();
-		if (!fileName) return;
-		const relativePath = path.relative(gitRootDir, fileName);
+	const applicableFiles = await getApplicableFiles(rulePath, language, projectRoot);
+	for (const filePath of applicableFiles) {
+		const absolutePath = path.resolve(projectRoot, filePath);
+		const relativePath = path.relative(gitRootDir, absolutePath);
 		const owners = codeowners.getOwner(relativePath);
 		let ownerKey;
 		if (owners && owners.length > 0) {
@@ -156,29 +136,18 @@ async function analyzeFilesByOwner(codeownersPath, rule, projectRoot = process.c
 		} else ownerKey = "unassigned";
 		if (!filesByOwner.has(ownerKey)) filesByOwner.set(ownerKey, []);
 		filesByOwner.get(ownerKey).push(relativePath);
-	});
+	}
 	return filesByOwner;
 }
 /**
 * Analyzes files without codeowner parsing - assigns all files to "unassigned"
 */
-async function analyzeFilesWithoutOwner(rule, projectRoot = process.cwd()) {
+async function analyzeFilesWithoutOwner(language, rulePath, projectRoot = process.cwd()) {
 	const filesByOwner = /* @__PURE__ */ new Map();
-	filesByOwner.set("unassigned", []);
-	await countedFindInFiles(Lang.TypeScript, {
-		matcher: rule,
-		paths: [projectRoot]
-	}, (err, matches) => {
-		if (err) {
-			console.error("AST-grep error:", err);
-			return;
-		}
-		if (!matches || matches.length === 0) return;
-		const fileName = matches[0]?.getRoot().filename();
-		if (!fileName) return;
-		const relativePath = path.relative(projectRoot, fileName);
-		filesByOwner.get("unassigned").push(relativePath);
+	const unassignedFiles = (await getApplicableFiles(rulePath, language, projectRoot)).map((filePath) => {
+		return path.relative(projectRoot, path.resolve(projectRoot, filePath));
 	});
+	filesByOwner.set("unassigned", unassignedFiles);
 	return filesByOwner;
 }
 /**
@@ -212,20 +181,19 @@ function getTeamFileInfo(filesByOwner) {
 * Main function to analyze codeowners and generate shard configuration
 */
 async function analyzeCodeowners(options) {
-	const { shardSize, codeownersPath, rulePath, projectRoot = process.cwd() } = options;
+	const { shardSize, codeownersPath, rulePath, language, projectRoot = process.cwd() } = options;
 	const resolvedCodeownersPath = await findCodeownersFile(projectRoot, codeownersPath);
-	const rule = await loadAstGrepRule(rulePath);
 	let filesByOwner;
 	console.debug(`Using rule file: ${rulePath}`);
 	console.debug(`Shard size: ${shardSize}`);
 	if (resolvedCodeownersPath) {
 		console.log(`Analyzing CODEOWNERS file: ${resolvedCodeownersPath}`);
-		console.log("Analyzing files with AST-grep...");
-		filesByOwner = await analyzeFilesByOwner(resolvedCodeownersPath, rule, projectRoot);
+		console.log("Analyzing files with CLI command...");
+		filesByOwner = await analyzeFilesByOwner(resolvedCodeownersPath, language, rulePath, projectRoot);
 	} else {
 		console.log("No CODEOWNERS file found, assigning all files to 'unassigned'");
-		console.log("Analyzing files with AST-grep...");
-		filesByOwner = await analyzeFilesWithoutOwner(rule, projectRoot);
+		console.log("Analyzing files with CLI command...");
+		filesByOwner = await analyzeFilesWithoutOwner(language, rulePath, projectRoot);
 	}
 	console.log("File analysis completed. Generating shards...");
 	const teams = getTeamFileInfo(filesByOwner);
@@ -240,4 +208,4 @@ async function analyzeCodeowners(options) {
 }
 
 //#endregion
-export { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, loadAstGrepRule, normalizeOwnerName };
+export { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getApplicableFiles, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, normalizeOwnerName };

package/dist/index.d.ts

@@ -68,6 +68,7 @@ interface CodeownerAnalysisOptions {
   shardSize: number;
   codeownersPath?: string;
   rulePath: string;
+  language: string;
   projectRoot?: string;
 }
 interface CodeownerAnalysisResult {
@@ -81,22 +82,22 @@ interface CodeownerAnalysisResult {
  * Returns null if no CODEOWNERS file is found
  */
 declare function findCodeownersFile(projectRoot?: string, explicitPath?: string): Promise<string | null>;
-/**
- * Loads and parses AST-grep rule from YAML file
- */
-declare function loadAstGrepRule(rulePath: string): Promise<any>;
 /**
  * Normalizes owner name by removing @ prefix and converting to lowercase
  */
 declare function normalizeOwnerName(owner: string): string;
+/**
+ * Executes the codemod CLI command and returns applicable file paths
+ */
+declare function getApplicableFiles(rulePath: string, language: string, projectRoot: string): Promise<string[]>;
 /**
  * Analyzes files and groups them by codeowner team
  */
-declare function analyzeFilesByOwner(codeownersPath: string, rule: any, projectRoot?: string): Promise<Map<string, string[]>>;
+declare function analyzeFilesByOwner(codeownersPath: string, language: string, rulePath: string, projectRoot?: string): Promise<Map<string, string[]>>;
 /**
  * Analyzes files without codeowner parsing - assigns all files to "unassigned"
  */
-declare function analyzeFilesWithoutOwner(rule: any, projectRoot?: string): Promise<Map<string, string[]>>;
+declare function analyzeFilesWithoutOwner(language: string, rulePath: string, projectRoot?: string): Promise<Map<string, string[]>>;
 /**
  * Generates shard configuration from team file analysis
  */
@@ -110,4 +111,4 @@ declare function getTeamFileInfo(filesByOwner: Map<string, string[]>): TeamFileI
  */
 declare function analyzeCodeowners(options: CodeownerAnalysisOptions): Promise<CodeownerAnalysisResult>;
 //#endregion
-export { CodeownerAnalysisOptions, CodeownerAnalysisResult, ShardResult, TeamFileInfo, analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, loadAstGrepRule, normalizeOwnerName };
+export { CodeownerAnalysisOptions, CodeownerAnalysisResult, ShardResult, TeamFileInfo, analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getApplicableFiles, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, normalizeOwnerName };

package/dist/index.js

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, loadAstGrepRule, normalizeOwnerName } from "./codeowner-analysis-CcSOX0Ve.js";
+import { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getApplicableFiles, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, normalizeOwnerName } from "./codeowner-analysis-CYaliyNC.js";
 
-export { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, loadAstGrepRule, normalizeOwnerName };
+export { analyzeCodeowners, analyzeFilesByOwner, analyzeFilesWithoutOwner, calculateOptimalShardCount, distributeFilesAcrossShards, findCodeownersFile, fitsInShard, generateShards, getApplicableFiles, getFileHashPosition, getNumericFileNameSha1, getShardForFilename, getTeamFileInfo, normalizeOwnerName };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codemodctl",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "CLI tool and utilities for workflow engine operations, file sharding, and codeowner analysis",
   "type": "module",
   "exports": {
@@ -35,7 +35,6 @@
     "test": "vitest"
   },
   "dependencies": {
-    "@ast-grep/napi": "^0.39.4",
     "citty": "^0.1.6",
     "codeowners": "^5.1.1",
     "execa": "^9.6.0",