feat: add task caching with hash-based cache invalidation

Author: IKatsuba

deno.json

@@ -7,10 +7,10 @@
       "command": "deno test packages/cli/**/*.spec.ts --allow-all"
     },
     "compile": {
-      "command": "deno compile --allow-read --allow-env --allow-run --output ./dist/cli packages/cli/mod.ts"
+      "command": "deno compile --allow-write --allow-read --allow-env --allow-run --output ./dist/cli packages/cli/mod.ts"
     },
     "install": {
-      "command": "deno install --allow-read --allow-env --allow-run -g -N -R -f -n runx jsr:@runx/cli"
+      "command": "deno install --allow-write --allow-read --allow-env --allow-run -g -N -R -f -n runx jsr:@runx/cli"
     }
   },
   "workspace": [

deno.lock

@@ -7,6 +7,7 @@
     "@std/fs": "jsr:@std/[email protected]",
     "@cliffy/command": "jsr:@cliffy/[email protected]",
     "@david/dax": "jsr:@david/[email protected]",
-    "@std/path": "jsr:@std/[email protected]"
+    "@std/path": "jsr:@std/[email protected]",
+    "@std/crypto": "jsr:@std/[email protected]"
   }
 }

packages/cli/deno.json

@@ -0,0 +1,91 @@
+import { crypto } from '@std/crypto';
+import { join } from '@std/path';
+import { ensureDir } from '@std/fs';
+
+interface TaskCache {
+  hash: string;
+  timestamp: number;
+  output: string;
+  exitCode: number;
+}
+
+export async function calculateTaskHash(
+  packageName: string,
+  taskName: string,
+  dependencies: {
+    files: string[];
+    packageJson: Record<string, unknown>;
+  },
+): Promise<string> {
+  console.log(`Calculating hash for ${packageName} ${taskName}`);
+
+  console.log(`Package name: ${packageName}`);
+  console.log(`Task name: ${taskName}`);
+  console.log(`Dependencies: ${JSON.stringify(dependencies)}`);
+
+  // Create a string that includes all the inputs that affect the task
+  const inputString = JSON.stringify({
+    packageName,
+    taskName,
+    dependencies,
+  });
+
+  // Calculate SHA-256 hash
+  const hashBuffer = await crypto.subtle.digest(
+    'SHA-256',
+    new TextEncoder().encode(inputString),
+  );
+
+  // Convert to hex string
+  const hash = Array.from(new Uint8Array(hashBuffer))
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('');
+
+  console.log(`Hash for ${packageName} ${taskName}: ${hash}`);
+
+  return hash;
+}
+
+export class TaskCacheManager {
+  private cacheDir: string;
+
+  constructor(workspaceRoot: string) {
+    this.cacheDir = join(workspaceRoot, '.runx', 'cache');
+  }
+
+  private getCachePath(hash: string): string {
+    return join(this.cacheDir, `${hash}.json`);
+  }
+
+  async init(): Promise<void> {
+    await ensureDir(this.cacheDir);
+  }
+
+  async saveCache(
+    hash: string,
+    output: string,
+    exitCode: number,
+  ): Promise<void> {
+    const cache: TaskCache = {
+      hash,
+      timestamp: Date.now(),
+      output,
+      exitCode,
+    };
+
+    await Deno.writeTextFile(
+      this.getCachePath(hash),
+      JSON.stringify(cache, null, 2),
+    );
+  }
+
+  async getCache(hash: string): Promise<TaskCache | null> {
+    try {
+      const cachePath = this.getCachePath(hash);
+      const cacheContent = await Deno.readTextFile(cachePath);
+      return JSON.parse(cacheContent) as TaskCache;
+    } catch {
+      return null;
+    }
+  }
+}

packages/cli/lib/cache.ts

@@ -35,9 +35,6 @@ export function getAffectedPackages(
   changedFiles: string[],
   packages: { packageJson: { name: string }; cwd: string }[],
 ): Set<string> {
-  console.log('changedFiles', changedFiles);
-  console.log('packages', packages);
-
   const affectedPackages = new Set<string>();
 
   for (const pkg of packages) {

packages/cli/lib/git.ts

@@ -1,10 +1,11 @@
-import { expandGlob } from '@std/fs';
+import { exists, expandGlob } from '@std/fs';
 import { Command } from '@cliffy/command';
 import { parseFullCommand } from './lib/parse-command.ts';
 import { dirname, join } from '@std/path';
 import $ from '@david/dax';
 import { Graph, type PackageJson } from './lib/graph.ts';
 import { getAffectedPackages, getChangedFiles } from './lib/git.ts';
+import { calculateTaskHash, TaskCacheManager } from './lib/cache.ts';
 
 await new Command()
   .name('runx')
@@ -13,14 +14,23 @@ await new Command()
   .option(
     '-a, --affected [base:string]',
     'Run command only for affected packages',
-    (value) => value || value === '',
+    {
+      value: (value) => value || 'main',
+      default: 'main',
+    },
+  )
+  .option(
+    '--no-cache',
+    'Disable task caching',
+    { default: true },
   )
   .arguments('<task-name> [...project]')
-  .action(async ({ affected }, taskName, ...projects: string[]) => {
+  .action(async ({ affected, cache }, taskName, ...projects: string[]) => {
     const startTime = performance.now();
     console.log(`Running command ${taskName} with options:`, {
       affected,
       projects,
+      cache,
     });
 
     console.log(`\n> Starting execution of '${taskName}' command...`);
@@ -32,6 +42,12 @@ await new Command()
 
     const workspacePatterns = rootPackageJson.workspaces || ['**/package.json'];
 
+    // Initialize cache manager if caching is enabled
+    const cacheManager = cache ? new TaskCacheManager(Deno.cwd()) : null;
+    if (cacheManager) {
+      await cacheManager.init();
+    }
+
     // Collect all package.json files from workspace patterns
     const packageFileSpecs = await Promise.all(
       workspacePatterns.map((pattern) =>
@@ -155,12 +171,73 @@ await new Command()
         const executable = join(Deno.cwd(), which);
 
         try {
-          await $`${executable} ${args.join(' ')}`.cwd(
-            packageInfo.cwd,
-          ).env({
-            ...Deno.env.toObject(),
-            ...(env ?? {}),
-          });
+          // If caching is enabled, try to use cached result
+          if (cacheManager) {
+            const exclude = [];
+
+            const gitignorePath = join(Deno.cwd(), '.gitignore');
+
+            if (await exists(gitignorePath)) {
+              const gitignore = await Deno.readTextFile(gitignorePath);
+              exclude.push(
+                ...gitignore.split('\n').map((file) => file.trim()).filter(
+                  Boolean,
+                ),
+              );
+            }
+
+            // Get all files in the package directory
+            const packageFiles = await Array.fromAsync(
+              expandGlob('**/*', {
+                root: packageInfo.cwd,
+                exclude,
+              }),
+            ).then((files) =>
+              files.map((file) => file.path.replace(Deno.cwd() + '/', ''))
+            );
+
+            const hash = await calculateTaskHash(packageName, taskName, {
+              files: packageFiles,
+              packageJson: packageInfo.packageJson,
+            });
+
+            const cache = await cacheManager.getCache(hash);
+
+            if (cache) {
+              console.log(
+                `✓ Using cached result for ${packageName} (hash: ${hash})`,
+              );
+              console.log(cache.output);
+              if (cache.exitCode !== 0) {
+                throw new Error(`Task failed with exit code ${cache.exitCode}`);
+              }
+              continue;
+            }
+
+            const result = await $`${executable} ${args.join(' ')}`.cwd(
+              packageInfo.cwd,
+            ).env({
+              ...Deno.env.toObject(),
+              ...(env ?? {}),
+            }).stdout('inheritPiped');
+
+            console.log(result.stdout);
+
+            // Save the result to cache
+            await cacheManager.saveCache(hash, result.stdout, result.code);
+
+            if (result.code !== 0) {
+              throw new Error(`Task failed with exit code ${result.code}`);
+            }
+          } else {
+            // Run without caching
+            await $`${executable} ${args.join(' ')}`.cwd(
+              packageInfo.cwd,
+            ).env({
+              ...Deno.env.toObject(),
+              ...(env ?? {}),
+            });
+          }
 
           const packageDuration =
             ((performance.now() - packageStartTime) / 1000).toFixed(2);