nx-auto-cache-deps 0.0.0 → 0.0.2

package/dist/dependencies.js

@@ -0,0 +1,64 @@
+import { createHash } from 'node:crypto';
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { isAbsolute, join, relative, sep } from 'node:path';
+// Nx のワークスペースデータと Git のメタデータは、Nx 自身もタスクハッシュに含めない
+const EXCLUDED_ROOTS = ['.nx', '.git'];
+const toWorkspacePath = (workspaceRoot, absolutePath) => {
+    const path = relative(workspaceRoot, absolutePath);
+    if (path === '')
+        return '.';
+    if (isAbsolute(path) || path === '..' || path.startsWith(`..${sep}`))
+        return undefined;
+    if (EXCLUDED_ROOTS.some((root) => path === root || path.startsWith(`${root}${sep}`)))
+        return undefined;
+    return path.split(sep).join('/');
+};
+const sortedUnique = (values) => [...new Set(values)].sort();
+export const toDependencyList = (accesses, workspaceRoot) => {
+    const inWorkspace = accesses.flatMap((access) => {
+        const path = toWorkspacePath(workspaceRoot, access.path);
+        return path === undefined ? [] : [{ kind: access.kind, path }];
+    });
+    // 自分で書いたパスを入力にすると、成果物の更新だけで毎回ミスするため除く
+    const written = new Set(inWorkspace.filter((a) => a.kind === 'write').map((a) => a.path));
+    const observed = (kind) => sortedUnique(inWorkspace.filter((a) => a.kind === kind && !written.has(a.path)).map((a) => a.path));
+    return { version: 1, paths: observed('read'), directories: observed('readDir') };
+};
+export const mergeDependencyLists = (a, b) => ({
+    version: 1,
+    paths: sortedUnique([...a.paths, ...b.paths]),
+    directories: sortedUnique([...a.directories, ...b.directories]),
+});
+const isMissingError = (error) => error instanceof Error && 'code' in error && (error.code === 'ENOENT' || error.code === 'ENOTDIR');
+const pathState = (absolutePath) => {
+    const stats = statSync(absolutePath, { throwIfNoEntry: false });
+    if (stats === undefined)
+        return 'missing';
+    if (stats.isDirectory())
+        return 'directory';
+    if (stats.isFile())
+        return `file:${createHash('sha256').update(readFileSync(absolutePath)).digest('hex')}`;
+    return 'other';
+};
+const directoryState = (absolutePath) => {
+    try {
+        return readdirSync(absolutePath, { withFileTypes: true })
+            .map((entry) => `${entry.name}:${entry.isDirectory() ? 'd' : entry.isFile() ? 'f' : entry.isSymbolicLink() ? 'l' : 'o'}`)
+            .sort()
+            .join('\n');
+    }
+    catch (error) {
+        if (isMissingError(error))
+            return 'missing';
+        throw error;
+    }
+};
+/** 依存一覧の各依存を現在のファイルシステムで評価したハッシュ。 */
+export const fingerprint = (list, workspaceRoot) => {
+    const hash = createHash('sha256');
+    for (const path of list.paths)
+        hash.update(`path\0${path}\0${pathState(join(workspaceRoot, path))}\0`);
+    for (const path of list.directories)
+        hash.update(`dir\0${path}\0${directoryState(join(workspaceRoot, path))}\0`);
+    return hash.digest('hex');
+};

package/dist/executor.js

@@ -0,0 +1,48 @@
+import { cacheDir, logger } from '@nx/devkit';
+import { spawn } from 'node:child_process';
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { mergeDependencyLists, toDependencyList } from './dependencies.js';
+import { resolveTraceBinary } from './platform.js';
+import { dependencyListPath, readDependencyList, storeDirectory, taskKey, writeDependencyList } from './store.js';
+const runOriginalScript = fileURLToPath(new URL('./run-original.js', import.meta.url));
+const runTraced = (args, cwd) => new Promise((resolve, reject) => {
+    const child = spawn(resolveTraceBinary(), args, { cwd, stdio: 'inherit' });
+    child.once('error', reject);
+    child.once('exit', (code) => resolve(code ?? 1));
+});
+export default async function run(options, context) {
+    const { projectName, targetName } = context;
+    if (projectName === undefined || targetName === undefined)
+        throw new Error('nx-auto-cache-deps: missing task target');
+    const project = context.projectsConfigurations.projects[projectName];
+    const target = project?.targets?.[targetName];
+    if (project === undefined || typeof target?.original_executor !== 'string') {
+        throw new Error(`nx-auto-cache-deps: ${projectName}:${targetName} needs "original_executor"`);
+    }
+    const runs = join(storeDirectory(cacheDir), 'runs');
+    mkdirSync(runs, { recursive: true });
+    const work = mkdtempSync(join(runs, 'run-'));
+    try {
+        const payload = join(work, 'execution.json');
+        const reportPath = join(work, 'report.json');
+        const execution = { executor: target.original_executor, options, context };
+        writeFileSync(payload, JSON.stringify(execution));
+        const code = await runTraced([reportPath, process.execPath, runOriginalScript, payload], process.cwd());
+        const report = JSON.parse(readFileSync(reportPath, 'utf8'));
+        if (report.status === 'incomplete') {
+            logger.warn(`nx-auto-cache-deps: tracing of ${projectName}:${targetName} was incomplete, dependency list not updated: ${report.reason}`);
+        }
+        else if (code === 0) {
+            const listPath = dependencyListPath(cacheDir, taskKey(project.root, targetName));
+            const observed = toDependencyList(report.accesses, context.root);
+            const stored = readDependencyList(listPath);
+            writeDependencyList(listPath, stored.status === 'found' ? mergeDependencyLists(stored.list, observed) : observed);
+        }
+        return { success: code === 0 };
+    }
+    finally {
+        rmSync(work, { recursive: true, force: true });
+    }
+}

package/dist/fingerprint-cli.js

@@ -0,0 +1,14 @@
+// Nx の runtime input から呼ばれ、標準出力がタスクハッシュに入る。
+import { cacheDir, workspaceRoot } from '@nx/devkit';
+import { randomUUID } from 'node:crypto';
+import { fingerprint } from './dependencies.js';
+import { dependencyListPath, readDependencyList } from './store.js';
+const key = process.argv[2];
+if (key === undefined)
+    throw new Error('nx-auto-cache-deps: fingerprint requires a task key');
+const stored = readDependencyList(dependencyListPath(cacheDir, key));
+if (stored.status === 'unreadable') {
+    process.stderr.write(`nx-auto-cache-deps: ignoring unreadable dependency list for ${key}: ${stored.reason}\n`);
+}
+// 依存一覧がなければ毎回違う値を返し、実行結果のキャッシュに必ずミスさせる
+process.stdout.write(stored.status === 'found' ? fingerprint(stored.list, workspaceRoot) : `no-dependency-list:${randomUUID()}`);

package/dist/generators/init.js

@@ -0,0 +1,17 @@
+import { formatFiles, readNxJson, updateNxJson } from '@nx/devkit';
+const PLUGIN = 'nx-auto-cache-deps';
+/**
+ * `nx add nx-auto-cache-deps` から呼ばれ、nx.json の plugins に本プラグインを登録する。
+ * project.json で executor を差し替えた target は wrap なしの登録が扱うため、wrap 付きの登録だけでは登録済みとしない。
+ */
+export default async function init(tree) {
+    const nxJson = readNxJson(tree) ?? {};
+    const plugins = nxJson.plugins ?? [];
+    const registered = plugins.some((entry) => typeof entry === 'string'
+        ? entry === PLUGIN
+        : entry.plugin === PLUGIN && entry.options?.wrap === undefined);
+    if (registered)
+        return;
+    updateNxJson(tree, { ...nxJson, plugins: [...plugins, PLUGIN] });
+    await formatFiles(tree);
+}

package/dist/platform.js

@@ -0,0 +1,30 @@
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+export const PACKAGE_NAME = 'nx-auto-cache-deps';
+/** トレーサーのバイナリを同梱するプラットフォーム。パッケージには bin/<id>/ として全プラットフォーム分を入れる。 */
+export const PLATFORMS = [
+    { id: 'linux-x64-gnu', os: 'linux', cpu: 'x64', libc: 'glibc' },
+    { id: 'linux-arm64-gnu', os: 'linux', cpu: 'arm64', libc: 'glibc' },
+    { id: 'darwin-arm64', os: 'darwin', cpu: 'arm64' },
+];
+export const traceBinaryName = (os) => `${PACKAGE_NAME}-trace${os === 'win32' ? '.exe' : ''}`;
+/** パッケージ内でのバイナリの位置。パッケージのルートからの相対パス。 */
+export const traceBinaryPath = (platform) => `bin/${platform.id}/${traceBinaryName(platform.os)}`;
+const isGlibc = () => {
+    const header = process.report.getReport().header;
+    return header?.glibcVersionRuntime !== undefined;
+};
+export const currentPlatform = () => PLATFORMS.find((platform) => platform.os === process.platform &&
+    platform.cpu === process.arch &&
+    (platform.libc === undefined || isGlibc()));
+/** 実行中の環境に対応する、同梱のトレーサーのバイナリを返す。 */
+export const resolveTraceBinary = () => {
+    const platform = currentPlatform();
+    if (platform === undefined) {
+        throw new Error(`${PACKAGE_NAME}: ${process.platform}-${process.arch} is not supported`);
+    }
+    const binary = fileURLToPath(new URL(`../${traceBinaryPath(platform)}`, import.meta.url));
+    if (!existsSync(binary))
+        throw new Error(`${PACKAGE_NAME}: tracer binary is missing: ${binary}`);
+    return binary;
+};

package/dist/plugin.js

@@ -0,0 +1,87 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { basename, dirname, join, matchesGlob, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { taskKey } from './store.js';
+export const RUN_EXECUTOR = 'nx-auto-cache-deps:run';
+const loadWrappedPlugin = (workspaceRoot, name) => {
+    const require = createRequire(join(workspaceRoot, 'package.json'));
+    return require(require.resolve(name, { paths: [workspaceRoot] }));
+};
+const fingerprintCommand = (workspaceRoot, key) => {
+    // worktree ごとにタスクハッシュが変わらないよう、スクリプトはワークスペースからの相対パスで指す
+    const script = relative(workspaceRoot, fileURLToPath(new URL('./fingerprint-cli.js', import.meta.url)));
+    return { runtime: `node ${JSON.stringify(script)} ${JSON.stringify(key)}` };
+};
+const isFileInput = (input) => typeof input === 'string' || 'fileset' in input || 'input' in input || 'dependentTasksOutputFiles' in input;
+export const wrapTarget = (target, fingerprintInput) => {
+    const { executor, command, inputs, options, ...rest } = target;
+    return {
+        ...rest,
+        executor: RUN_EXECUTOR,
+        original_executor: executor ?? 'nx:run-commands',
+        options: command === undefined ? options : { command, ...options },
+        // ファイル入力は依存一覧で置き換え、環境変数・外部依存・runtime input は残す
+        inputs: [fingerprintInput, ...(inputs ?? []).filter((input) => !isFileInput(input))],
+    };
+};
+const wrapResult = (result, targetNames, workspaceRoot) => ({
+    ...result,
+    projects: Object.fromEntries(Object.entries(result.projects ?? {}).map(([projectRoot, project]) => [
+        projectRoot,
+        {
+            ...project,
+            targets: Object.fromEntries(Object.entries(project.targets ?? {}).map(([name, target]) => [
+                name,
+                targetNames.has(name) ? wrapTarget(target, fingerprintCommand(workspaceRoot, taskKey(projectRoot, name))) : target,
+            ])),
+        },
+    ])),
+});
+const createWrappedNodes = async (files, options, context) => {
+    const wrapped = loadWrappedPlugin(context.workspaceRoot, options.wrap.plugin);
+    const createNodes = wrapped.createNodes ?? wrapped.createNodesV2;
+    if (createNodes === undefined)
+        throw new Error(`nx-auto-cache-deps: ${options.wrap.plugin} does not export createNodes`);
+    const [pattern, create] = createNodes;
+    const matched = files.filter((file) => matchesGlob(file, pattern));
+    if (matched.length === 0)
+        return [];
+    const targetNames = new Set(options.targets ?? []);
+    const results = await create(matched, options.wrap.options, context);
+    return results.map(([file, result]) => [file, wrapResult(result, targetNames, context.workspaceRoot)]);
+};
+const createExplicitNodes = (files, context) => files
+    .filter((file) => basename(file) === 'project.json')
+    .flatMap((file) => {
+    const projectRoot = dirname(file);
+    const projectJson = JSON.parse(readFileSync(join(context.workspaceRoot, file), 'utf8'));
+    const targets = Object.entries(projectJson.targets ?? {})
+        .filter(([, target]) => target.executor === RUN_EXECUTOR)
+        .map(([name]) => [name, { inputs: [fingerprintCommand(context.workspaceRoot, taskKey(projectRoot, name))] }]);
+    return targets.length === 0
+        ? []
+        : [[file, { projects: { [projectRoot]: { targets: Object.fromEntries(targets) } } }]];
+});
+// 包むプラグインの glob は登録ごとに違うため、全ファイルを受け取り内側で絞り込む
+export const createNodes = [
+    '**/*',
+    async (files, options, context) => {
+        const wrap = options?.wrap;
+        return wrap === undefined
+            ? createExplicitNodes(files, context)
+            : createWrappedNodes(files, { ...options, wrap }, context);
+    },
+];
+export const createDependencies = (options, context) => {
+    const wrap = options?.wrap;
+    if (wrap === undefined)
+        return [];
+    return loadWrappedPlugin(context.workspaceRoot, wrap.plugin).createDependencies?.(wrap.options, context) ?? [];
+};
+export const createMetadata = (graph, options, context) => {
+    const wrap = options?.wrap;
+    if (wrap === undefined)
+        return {};
+    return loadWrappedPlugin(context.workspaceRoot, wrap.plugin).createMetadata?.(graph, wrap.options, context) ?? {};
+};

package/dist/run-original.js

@@ -0,0 +1,45 @@
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { dirname, join } from 'node:path';
+const readJson = (path) => JSON.parse(readFileSync(path, 'utf8'));
+const resolveExecutor = (workspaceRoot, name) => {
+    const separator = name.lastIndexOf(':');
+    const packageName = name.slice(0, separator);
+    const executorName = name.slice(separator + 1);
+    const packageJsonPath = createRequire(join(workspaceRoot, 'package.json')).resolve(`${packageName}/package.json`);
+    const packageJson = readJson(packageJsonPath);
+    const executorsFile = packageJson.executors ?? packageJson.builders;
+    if (executorsFile === undefined)
+        throw new Error(`${packageName} does not declare executors`);
+    const executorsJsonPath = join(dirname(packageJsonPath), executorsFile);
+    const entry = readJson(executorsJsonPath).executors?.[executorName];
+    if (entry === undefined)
+        throw new Error(`executor ${name} not found`);
+    const base = dirname(executorsJsonPath);
+    const [modulePath = '', exportName = 'default'] = entry.implementation.split('#');
+    const module = createRequire(executorsJsonPath)(join(base, modulePath));
+    const implementation = typeof module === 'function' ? module : module[exportName];
+    if (typeof implementation !== 'function')
+        throw new Error(`executor ${name} has no implementation`);
+    return { implementation: implementation, schema: readJson(join(base, entry.schema)) };
+};
+// Nx は executor の schema の既定値を補ってから呼ぶ。外側の executor はそれを内側の schema で行えないため、ここで補う
+const withDefaults = (schema, options) => ({
+    ...Object.fromEntries(Object.entries(schema.properties ?? {}).flatMap(([key, property]) => property.default === undefined ? [] : [[key, property.default]])),
+    ...options,
+});
+const lastResult = async (output) => {
+    if (!(Symbol.asyncIterator in output))
+        return output;
+    let last = { success: false };
+    for await (const result of output)
+        last = result;
+    return last;
+};
+const path = process.argv[2];
+if (path === undefined)
+    throw new Error('nx-auto-cache-deps: missing execution file');
+const { executor, options, context } = readJson(path);
+const { implementation, schema } = resolveExecutor(context.root, executor);
+const result = await lastResult(implementation(withDefaults(schema, options), context));
+process.exitCode = result.success ? 0 : 1;

package/dist/store.js

@@ -0,0 +1,40 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+/** タスクは worktree の場所に依存しないよう、ワークスペースルートからの project root と target 名で識別する。 */
+export const taskKey = (projectRoot, targetName) => `${projectRoot}:${targetName}`;
+export const storeDirectory = (cacheDirectory) => join(cacheDirectory, 'nx-auto-cache-deps');
+export const dependencyListPath = (cacheDirectory, key) => join(storeDirectory(cacheDirectory), 'dependencies', `${encodeURIComponent(key)}.json`);
+const isDependencyList = (value) => typeof value === 'object' &&
+    value !== null &&
+    'version' in value &&
+    value.version === 1 &&
+    'paths' in value &&
+    Array.isArray(value.paths) &&
+    'directories' in value &&
+    Array.isArray(value.directories);
+export const readDependencyList = (path) => {
+    let text;
+    try {
+        text = readFileSync(path, 'utf8');
+    }
+    catch (error) {
+        if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
+            return { status: 'missing' };
+        throw error;
+    }
+    try {
+        const value = JSON.parse(text);
+        return isDependencyList(value) ? { status: 'found', list: value } : { status: 'unreadable', reason: 'unknown format' };
+    }
+    catch (error) {
+        return { status: 'unreadable', reason: String(error) };
+    }
+};
+/** 別プロセスが書きかけの一覧を読まないよう、一時ファイルから rename で置き換える。 */
+export const writeDependencyList = (path, list) => {
+    mkdirSync(dirname(path), { recursive: true });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, JSON.stringify(list));
+    renameSync(temporary, path);
+};

package/executors.json

@@ -0,0 +1,9 @@
+{
+  "executors": {
+    "run": {
+      "implementation": "./dist/executor.js",
+      "schema": "./schemas/run.json",
+      "description": "Runs original_executor under file access tracing and records the dependency list."
+    }
+  }
+}

package/generators.json

@@ -0,0 +1,9 @@
+{
+  "generators": {
+    "init": {
+      "factory": "./dist/generators/init.js",
+      "schema": "./schemas/init.json",
+      "description": "Registers nx-auto-cache-deps in nx.json."
+    }
+  }
+}

package/package.json

@@ -1,10 +1,47 @@
 {
   "name": "nx-auto-cache-deps",
-  "version": "0.0.0",
-  "description": "This version is not intended for use.",
-  "main": "index.js",
+  "version": "0.0.2",
+  "description": "Nx plugin that derives cache inputs from the files a task actually accessed",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/plugin.js",
+  "exports": {
+    ".": "./dist/plugin.js",
+    "./package.json": "./package.json"
+  },
+  "executors": "./executors.json",
+  "generators": "./generators.json",
   "files": [
-    "index.js"
+    "bin",
+    "dist",
+    "schemas",
+    "executors.json",
+    "generators.json"
   ],
-  "license": "UNLICENSED"
+  "preferUnplugged": true,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "build:native": "node scripts/build-native.mjs",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "node --test --test-concurrency=1 test/*.test.ts"
+  },
+  "peerDependencies": {
+    "nx": ">=24.0.0 <25"
+  },
+  "dependencies": {
+    "@nx/devkit": "24.0.5"
+  },
+  "devDependencies": {
+    "@types/node": "24.19.2",
+    "nx": "24.0.5",
+    "typescript": "7.0.2"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "packageManager": "pnpm@12.18.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/9wick/nx-auto-cache-deps.git"
+  }
 }

package/schemas/init.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "nx-auto-cache-deps:init",
+  "description": "Registers nx-auto-cache-deps in nx.json.",
+  "type": "object",
+  "properties": {}
+}

package/schemas/run.json

@@ -0,0 +1,15 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "title": "nx-auto-cache-deps:run",
+  "description": "Options are passed through to original_executor.",
+  "type": "object",
+  "properties": {
+    "__unparsed__": {
+      "hidden": true,
+      "type": "array",
+      "items": { "type": "string" },
+      "$default": { "$source": "unparsed" }
+    }
+  },
+  "additionalProperties": true
+}

package/README.md

@@ -1 +0,0 @@
-This version is not intended for use.

package/index.js

@@ -1 +0,0 @@
-throw new Error('This version is not intended for use.');