@depup/nx 22.5.4-depup.0

package/src/adapter/rxjs-for-await.d.ts

@@ -0,0 +1,110 @@
+import { Observable } from 'rxjs';
+export declare class Deferred<T> {
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+    promise: Promise<T>;
+}
+/**
+ * Will subscribe to the `source` observable provided,
+ *
+ * Allowing a `for await..of` loop to iterate over every
+ * value that the source emits.
+ *
+ * **WARNING**: If the async loop is slower than the observable
+ * producing values, the values will build up in a buffer
+ * and you could experience an out of memory error.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of eachValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function eachValueFrom<T>(source: Observable<T>): AsyncIterableIterator<T>;
+/**
+ * Will subscribe to the `source` observable provided
+ * and build the emitted values up in a buffer. Allowing
+ * `for await..of` loops to iterate and get the buffer
+ * on each loop.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const buffer of bufferedValuesFrom(source$)) {
+ *     for (const value of buffer) {
+ *       console.log(value);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function bufferedValuesFrom<T>(source: Observable<T>): AsyncGenerator<any, void, unknown>;
+/**
+ * Will subscribe to the provided `source` observable,
+ * allowing `for await..of` loops to iterate and get the
+ * most recent value that was emitted. Will not iterate out
+ * the same emission twice.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of latestValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function latestValueFrom<T>(source: Observable<T>): AsyncGenerator<any, void, unknown>;
+/**
+ * Subscribes to the provided `source` observable and allows
+ * `for await..of` loops to iterate over it, such that
+ * all values are dropped until the iteration occurs, then
+ * the very next value that arrives is provided to the
+ * `for await` loop.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of nextValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+export declare function nextValueFrom<T>(source: Observable<T>): AsyncGenerator<T, void, void>;
+//# sourceMappingURL=rxjs-for-await.d.ts.map

package/src/adapter/rxjs-for-await.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rxjs-for-await.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/adapter/rxjs-for-await.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAElC,qBAAa,QAAQ,CAAC,CAAC;IACrB,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI,CAAS;IACrD,MAAM,EAAE,CAAC,MAAM,CAAC,EAAE,GAAG,KAAK,IAAI,CAAS;IACvC,OAAO,aAGJ;CACJ;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GACpB,qBAAqB,CAAC,CAAC,CAAC,CAsD1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAuB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,sCA+DjE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAuB,eAAe,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,sCA+D9D;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACpC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC,GACpB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,CAgD/B"}

package/src/adapter/rxjs-for-await.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Deferred = void 0;
+exports.eachValueFrom = eachValueFrom;
+exports.bufferedValuesFrom = bufferedValuesFrom;
+exports.latestValueFrom = latestValueFrom;
+exports.nextValueFrom = nextValueFrom;
+class Deferred {
+    constructor() {
+        this.resolve = null;
+        this.reject = null;
+        this.promise = new Promise((a, b) => {
+            this.resolve = a;
+            this.reject = b;
+        });
+    }
+}
+exports.Deferred = Deferred;
+const RESOLVED = Promise.resolve();
+/**
+ * Will subscribe to the `source` observable provided,
+ *
+ * Allowing a `for await..of` loop to iterate over every
+ * value that the source emits.
+ *
+ * **WARNING**: If the async loop is slower than the observable
+ * producing values, the values will build up in a buffer
+ * and you could experience an out of memory error.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of eachValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* eachValueFrom(source) {
+    const deferreds = [];
+    const values = [];
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferreds.length > 0) {
+                deferreds.shift().resolve({ value, done: false });
+            }
+            else {
+                values.push(value);
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            while (deferreds.length > 0) {
+                deferreds.shift().reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            while (deferreds.length > 0) {
+                deferreds.shift().resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (values.length > 0) {
+                yield values.shift();
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                const d = new Deferred();
+                deferreds.push(d);
+                const result = await d.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+/**
+ * Will subscribe to the `source` observable provided
+ * and build the emitted values up in a buffer. Allowing
+ * `for await..of` loops to iterate and get the buffer
+ * on each loop.
+ *
+ * This is a lossless subscription method. No value
+ * will be missed or duplicated.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const buffer of bufferedValuesFrom(source$)) {
+ *     for (const value of buffer) {
+ *       console.log(value);
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* bufferedValuesFrom(source) {
+    let deferred = null;
+    const buffer = [];
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferred) {
+                deferred.resolve(RESOLVED.then(() => {
+                    const bufferCopy = buffer.slice();
+                    buffer.length = 0;
+                    return { value: bufferCopy, done: false };
+                }));
+                deferred = null;
+            }
+            buffer.push(value);
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+                deferred = null;
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                deferred.resolve({ value: undefined, done: true });
+                deferred = null;
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (buffer.length > 0) {
+                const bufferCopy = buffer.slice();
+                buffer.length = 0;
+                yield bufferCopy;
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+/**
+ * Will subscribe to the provided `source` observable,
+ * allowing `for await..of` loops to iterate and get the
+ * most recent value that was emitted. Will not iterate out
+ * the same emission twice.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of latestValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* latestValueFrom(source) {
+    let deferred = undefined;
+    let latestValue;
+    let hasLatestValue = false;
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            hasLatestValue = true;
+            latestValue = value;
+            if (deferred) {
+                deferred.resolve(RESOLVED.then(() => {
+                    hasLatestValue = false;
+                    return { value: latestValue, done: false };
+                }));
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                hasLatestValue = false;
+                deferred.resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (hasLatestValue) {
+                await RESOLVED;
+                const value = latestValue;
+                hasLatestValue = false;
+                yield value;
+            }
+            else if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}
+/**
+ * Subscribes to the provided `source` observable and allows
+ * `for await..of` loops to iterate over it, such that
+ * all values are dropped until the iteration occurs, then
+ * the very next value that arrives is provided to the
+ * `for await` loop.
+ *
+ * This is a lossy subscription method. Do not use if
+ * every value is important.
+ *
+ * Example usage:
+ *
+ * ```ts
+ * async function test() {
+ *   const source$ = getSomeObservable();
+ *
+ *   for await(const value of nextValueFrom(source$)) {
+ *     console.log(value);
+ *   }
+ * }
+ * ```
+ *
+ * @param source the Observable source to await values from
+ */
+async function* nextValueFrom(source) {
+    let deferred = undefined;
+    let hasError = false;
+    let error = null;
+    let completed = false;
+    const subs = source.subscribe({
+        next: (value) => {
+            if (deferred) {
+                deferred.resolve({ value, done: false });
+            }
+        },
+        error: (err) => {
+            hasError = true;
+            error = err;
+            if (deferred) {
+                deferred.reject(err);
+            }
+        },
+        complete: () => {
+            completed = true;
+            if (deferred) {
+                deferred.resolve({ value: undefined, done: true });
+            }
+        },
+    });
+    try {
+        while (true) {
+            if (completed) {
+                return;
+            }
+            else if (hasError) {
+                throw error;
+            }
+            else {
+                deferred = new Deferred();
+                const result = await deferred.promise;
+                if (result.done) {
+                    return;
+                }
+                else {
+                    yield result.value;
+                }
+            }
+        }
+    }
+    catch (err) {
+        throw err;
+    }
+    finally {
+        subs.unsubscribe();
+    }
+}

package/src/ai/clone-ai-config-repo.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Get the path to the cached nx-ai-agents-config repository.
+ * Uses a commit-hash based caching strategy:
+ * 1. Fetches the latest commit hash from the remote repository
+ * 2. Checks if a cached version exists for that hash
+ * 3. If not, clones the repository and cleans up old caches
+ *
+ * @returns The path to the cached repository
+ * @throws Error if unable to fetch or clone the repository
+ */
+export declare function getAiConfigRepoPath(): string;
+//# sourceMappingURL=clone-ai-config-repo.d.ts.map

package/src/ai/clone-ai-config-repo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-ai-config-repo.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/ai/clone-ai-config-repo.ts"],"names":[],"mappings":"AAuHA;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAiB5C"}

package/src/ai/clone-ai-config-repo.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAiConfigRepoPath = getAiConfigRepoPath;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const REPO_URL = 'https://github.com/nrwl/nx-ai-agents-config';
+const CACHE_DIR = (0, path_1.join)((0, os_1.tmpdir)(), 'nx-ai-agents-config');
+/**
+ * Get the latest commit hash from the remote repository.
+ * Uses `git ls-remote` to fetch the HEAD commit hash without cloning.
+ */
+function getLatestCommitHash() {
+    try {
+        const output = (0, child_process_1.execSync)(`git ls-remote ${REPO_URL} HEAD`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 30000, // 30 second timeout
+        });
+        const hash = output.split('\t')[0];
+        if (!hash || hash.length < 10) {
+            throw new Error('Invalid commit hash received');
+        }
+        // Return first 10 characters of the commit hash
+        return hash.substring(0, 10);
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch latest commit hash from ${REPO_URL}. Please check your network connection.`);
+    }
+}
+/**
+ * Clone the repository to the specified path using shallow clone.
+ */
+function cloneRepo(targetPath) {
+    try {
+        // Ensure parent directory exists
+        (0, fs_1.mkdirSync)(CACHE_DIR, { recursive: true });
+        // Use a temporary path first to avoid race conditions
+        const tempPath = `${targetPath}.tmp.${process.pid}`;
+        // Clean up any leftover temp directory
+        if ((0, fs_1.existsSync)(tempPath)) {
+            (0, fs_1.rmSync)(tempPath, { recursive: true, force: true });
+        }
+        (0, child_process_1.execSync)(`git clone --depth 1 ${REPO_URL} "${tempPath}"`, {
+            encoding: 'utf-8',
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout: 120000, // 2 minute timeout for clone
+        });
+        // Remove .git directory after clone
+        const gitDir = (0, path_1.join)(tempPath, '.git');
+        if ((0, fs_1.existsSync)(gitDir)) {
+            (0, fs_1.rmSync)(gitDir, { recursive: true, force: true });
+        }
+        // Atomically move temp directory to final location
+        // If targetPath already exists (race condition), just clean up temp
+        if ((0, fs_1.existsSync)(targetPath)) {
+            (0, fs_1.rmSync)(tempPath, { recursive: true, force: true });
+        }
+        else {
+            // Rename is atomic on the same filesystem
+            try {
+                (0, fs_1.renameSync)(tempPath, targetPath);
+            }
+            catch {
+                // Rename failed - check if another process won the race
+                if ((0, fs_1.existsSync)(targetPath)) {
+                    // Another process created it, clean up our temp
+                    (0, fs_1.rmSync)(tempPath, { recursive: true, force: true });
+                }
+                else {
+                    // targetPath still doesn't exist - retry once
+                    try {
+                        (0, fs_1.renameSync)(tempPath, targetPath);
+                    }
+                    catch (retryError) {
+                        // Clean up and fail
+                        (0, fs_1.rmSync)(tempPath, { recursive: true, force: true });
+                        throw new Error(`Failed to move cloned repository to cache location: ${retryError.message}`);
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Re-throw if it's already our error (from rename failure)
+        if (error instanceof Error && error.message.startsWith('Failed to move')) {
+            throw error;
+        }
+        throw new Error(`Failed to clone ${REPO_URL}. Please check your network connection.`);
+    }
+}
+/**
+ * Clean up old cached versions, keeping only the current one.
+ */
+function cleanupOldCaches(currentCommitHash) {
+    if (!(0, fs_1.existsSync)(CACHE_DIR)) {
+        return;
+    }
+    try {
+        const entries = (0, fs_1.readdirSync)(CACHE_DIR, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && entry.name !== currentCommitHash) {
+                const oldCachePath = (0, path_1.join)(CACHE_DIR, entry.name);
+                (0, fs_1.rmSync)(oldCachePath, { recursive: true, force: true });
+            }
+        }
+    }
+    catch {
+        // Ignore cleanup errors - not critical
+    }
+}
+/**
+ * Get the path to the cached nx-ai-agents-config repository.
+ * Uses a commit-hash based caching strategy:
+ * 1. Fetches the latest commit hash from the remote repository
+ * 2. Checks if a cached version exists for that hash
+ * 3. If not, clones the repository and cleans up old caches
+ *
+ * @returns The path to the cached repository
+ * @throws Error if unable to fetch or clone the repository
+ */
+function getAiConfigRepoPath() {
+    // 1. Get latest commit hash (first 10 chars)
+    const commitHash = getLatestCommitHash();
+    // 2. Check if cached version exists
+    const cachedPath = (0, path_1.join)(CACHE_DIR, commitHash);
+    if ((0, fs_1.existsSync)(cachedPath)) {
+        return cachedPath;
+    }
+    // 3. Clone fresh
+    cloneRepo(cachedPath);
+    // 4. Clean up old cached versions
+    cleanupOldCaches(commitHash);
+    return cachedPath;
+}

package/src/ai/constants.d.ts

@@ -0,0 +1,27 @@
+import { AgentRulesOptions } from './set-up-ai-agents/get-agent-rules';
+export type { AgentRulesOptions };
+export declare function agentsMdPath(root: string): string;
+export declare function geminiMdPath(root: string): string;
+export declare function parseGeminiSettings(root: string): any | undefined;
+export declare function geminiSettingsPath(root: string): string;
+export declare function claudeMdPath(root: string): string;
+export declare function claudeMcpJsonPath(root: string): string;
+export declare function opencodeMcpPath(root: string): string;
+export declare const codexConfigTomlPath: string;
+export declare const nxRulesMarkerCommentStart = "<!-- nx configuration start-->";
+export declare const nxRulesMarkerCommentDescription = "<!-- Leave the start & end comments to automatically receive updates. -->";
+export declare const nxRulesMarkerCommentEnd = "<!-- nx configuration end-->";
+export declare const rulesRegex: RegExp;
+export interface AgentRulesWrappedOptions {
+    writeNxCloudRules: boolean;
+    useH1?: boolean;
+}
+export declare const getAgentRulesWrapped: (options: AgentRulesWrappedOptions) => string;
+export declare const nxMcpTomlHeader = "[mcp_servers.\"nx-mcp\"]";
+/**
+ * Get the MCP TOML configuration based on the Nx version.
+ * For Nx 22+, uses 'nx mcp'
+ * For Nx < 22, uses 'nx-mcp'
+ */
+export declare function getNxMcpTomlConfig(nxVersion: string): string;
+//# sourceMappingURL=constants.d.ts.map

package/src/ai/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/ai/constants.ts"],"names":[],"mappings":"AAIA,OAAO,EAEL,iBAAiB,EAClB,MAAM,oCAAoC,CAAC;AAE5C,YAAY,EAAE,iBAAiB,EAAE,CAAC;AAElC,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,SAAS,CAOjE;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEvD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEtD;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,eAAO,MAAM,mBAAmB,QAA2C,CAAC;AAE5E,eAAO,MAAM,yBAAyB,mCAAmC,CAAC;AAC1E,eAAO,MAAM,+BAA+B,8EAA8E,CAAC;AAC3H,eAAO,MAAM,uBAAuB,iCAAiC,CAAC;AACtE,eAAO,MAAM,UAAU,QAGtB,CAAC;AAEF,MAAM,WAAW,wBAAwB;IACvC,iBAAiB,EAAE,OAAO,CAAC;IAC3B,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,eAAO,MAAM,oBAAoB,GAAI,SAAS,wBAAwB,WAIrE,CAAC;AAEF,eAAO,MAAM,eAAe,6BAA2B,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAQ5D"}