wormajs 0.0.1

package/dist/core/workerPool/poolManager.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolManager = void 0;
+/**
+ * P2: Global reusable WorkerPool manager (singleton factory).
+ * Caches pools by key to avoid create/destroy overhead across repeated generate() calls.
+ * Workers auto-terminate after idleTimeout (default 30s) of inactivity.
+ */
+const WorkerPool_1 = require("../../core/WorkerPool");
+class PoolManager {
+    static getInstance() {
+        if (!PoolManager.instance) {
+            PoolManager.instance = new PoolManager();
+        }
+        return PoolManager.instance;
+    }
+    constructor() {
+        this.pools = new Map();
+    }
+    get(options) {
+        const { key, workerScript, sharedContext, poolSize, idleTimeout } = options;
+        let pool = this.pools.get(key);
+        if (!pool) {
+            pool = new WorkerPool_1.WorkerPool({ workerScript, sharedContext, poolSize, idleTimeout });
+            this.pools.set(key, pool);
+        }
+        return pool;
+    }
+    /** Explicitly terminate and remove a pool (e.g. on project config change). */
+    release(key) {
+        const pool = this.pools.get(key);
+        if (pool) {
+            pool.terminate();
+            this.pools.delete(key);
+        }
+    }
+    /** Terminate all cached pools. */
+    releaseAll() {
+        for (const [, pool] of this.pools) {
+            pool.terminate();
+        }
+        this.pools.clear();
+    }
+}
+exports.PoolManager = PoolManager;

package/dist/core/workerPool/swagger2Worker.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * 9.3.4: Worker for Swagger2→OpenAPI3 conversion (moved from openApiParser).
+ * Handles batches of swagger2 documents via WorkerPool.
+ */
+const node_worker_threads_1 = require("node:worker_threads");
+const swagger2openapi_1 = __importDefault(require("swagger2openapi"));
+node_worker_threads_1.parentPort?.on('message', async (batch) => {
+    const results = [];
+    try {
+        for (const data of batch) {
+            const result = await swagger2openapi_1.default.convertObj(data, { warnOnly: true });
+            results.push({ openapi: result.openapi });
+        }
+        node_worker_threads_1.parentPort?.postMessage({ type: 'result', data: results });
+    }
+    catch (err) {
+        node_worker_threads_1.parentPort?.postMessage({ type: 'error', message: err.message });
+    }
+});

package/dist/core/workerPool/worker.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * M4-C1: Worker entry point for schema→TS conversion.
+ * Each worker receives shared context (document + config) at startup,
+ * then processes batches of schema objects in its own thread.
+ */
+const node_worker_threads_1 = require("node:worker_threads");
+// Initialize global config required by logger etc.
+const config_1 = require("../../config");
+const loader_1 = require("../../core/loader");
+(0, config_1.setGlobalConfig)({ Error });
+const { document, config, refNameMapEntries } = node_worker_threads_1.workerData;
+const refNameMap = new Map(refNameMapEntries);
+/** Worker-local cache: keyName → generated TS string, avoids re-transforming the same referenced schema. */
+const schemaCache = new Map();
+async function processSchema(key, schema) {
+    const results = [];
+    const tsStr = await loader_1.schemaLoader.transform(schema, {
+        document,
+        deep: false,
+        noEnum: true,
+        commentType: 'doc',
+        preText: '',
+        defaultRequire: config.defaultRequire,
+        refNameMap,
+        async onReference(ast) {
+            if (config.externalTypes?.includes(ast.keyName ?? ''))
+                return;
+            if (ast.keyName) {
+                let result = schemaCache.get(ast.keyName);
+                if (!result) {
+                    result = await loader_1.astLoader.transformTsStr(ast, {
+                        shallowDeep: true,
+                        commentType: 'doc',
+                        noEnum: true,
+                        format: true,
+                        export: true,
+                    });
+                    schemaCache.set(ast.keyName, result);
+                }
+                results.push({ key: ast.keyName, result });
+            }
+        },
+    });
+    results.push({ key, result: tsStr });
+    return results;
+}
+node_worker_threads_1.parentPort?.on('message', async (batch) => {
+    try {
+        const allResults = [];
+        for (const item of batch) {
+            const taskResults = await processSchema(item.key, item.schema);
+            allResults.push(...taskResults);
+        }
+        node_worker_threads_1.parentPort?.postMessage({ type: 'result', data: allResults });
+    }
+    catch (err) {
+        node_worker_threads_1.parentPort?.postMessage({ type: 'error', message: err.message });
+    }
+});

package/dist/createConfig.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_path_1 = __importDefault(require("node:path"));
+const constant_1 = require("./constant");
+const getAutoTemplateType_1 = __importDefault(require("./functions/getAutoTemplateType"));
+const helper_1 = require("./helper");
+const template_1 = require("./template");
+const TEMPLATE_PRESET_MAP = {
+    alovaGlobals: { importName: 'alovaGlobals', call: 'alovaGlobals()', presetName: constant_1.PresetTemplateName.GLOBALS },
+    [constant_1.PresetTemplateName.ALOVA]: { importName: 'alova', call: 'alova()', presetName: constant_1.PresetTemplateName.ALOVA },
+    [constant_1.PresetTemplateName.AXIOS]: { importName: 'axios', call: 'axios()', presetName: constant_1.PresetTemplateName.AXIOS },
+    [constant_1.PresetTemplateName.FETCH]: { importName: 'fetch', call: 'fetch()', presetName: constant_1.PresetTemplateName.FETCH },
+    [constant_1.PresetTemplateName.KY]: { importName: 'ky', call: 'ky()', presetName: constant_1.PresetTemplateName.KY },
+};
+async function createConfig({ projectPath = '', type, template = constant_1.PresetTemplateName.ALOVA } = {}) {
+    projectPath = node_path_1.default.isAbsolute(projectPath)
+        ? projectPath
+        : node_path_1.default.resolve(process.cwd(), projectPath);
+    type = type || await (0, getAutoTemplateType_1.default)(projectPath);
+    const preset = TEMPLATE_PRESET_MAP[template];
+    const templatePath = (0, template_1.getPresetTemplatePath)(constant_1.PresetTemplateName.CONFIG);
+    helper_1.templateHelper.load({
+        type,
+        templatePath,
+    });
+    // generateFromTemplateDir now writes files internally
+    await helper_1.templateHelper.generateFromTemplateDir(templatePath, projectPath, {
+        type,
+        moduleType: helper_1.templateHelper.getModuleType(),
+        templateImport: preset.importName,
+        templateCall: preset.call,
+    });
+}
+exports.default = createConfig;

package/dist/defineConfig.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineConfig = defineConfig;
+function defineConfig(config) {
+    return config;
+}

package/dist/functions/getAutoTemplateType.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getAutoTemplateType;
+exports.getFrameworkTag = getFrameworkTag;
+const constant_1 = require("../constant");
+const readPackageJson_1 = require("../utils/readPackageJson");
+/**
+ * Get the template type based on project configuration
+ * @param projectPath - The project root path
+ * @returns TemplateType - 'typescript' | 'module' | 'commonjs'
+ */
+async function getAutoTemplateType(projectPath) {
+    const packageJson = await (0, readPackageJson_1.readPackageJson)(projectPath);
+    if (packageJson?.devDependencies?.typescript) {
+        return constant_1.TemplateTypeEnum.TYPESCRIPT;
+    }
+    const type = packageJson?.type;
+    return type ?? constant_1.TemplateTypeEnum.MODULE;
+}
+/**
+ * Get the framework tag based on project dependencies
+ * @param projectPath - The project root path
+ * @returns FrameworkName or empty string
+ */
+async function getFrameworkTag(projectPath) {
+    const packageJson = await (0, readPackageJson_1.readPackageJson)(projectPath);
+    if (!packageJson) {
+        return '';
+    }
+    // Framework technology stack tag vue | react
+    // Find in dependencies
+    const frameTag = constant_1.FRAMEWORK_NAMES.find(framework => packageJson.dependencies?.[framework]);
+    // Find in dev dependencies
+    // Priority: Production dependencies > Development dependencies
+    const devFrameTag = constant_1.FRAMEWORK_NAMES.find(framework => packageJson.devDependencies?.[framework]);
+    return frameTag ?? devFrameTag ?? '';
+}

package/dist/functions/getFrameworkTag.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+const constant_1 = require("../constant");
+const readPackageJson_1 = require("../utils/readPackageJson");
+async function default_1(projectPath) {
+    const packageJson = await (0, readPackageJson_1.readPackageJson)(projectPath);
+    if (!packageJson) {
+        return '';
+    }
+    // Framework technology stack tag vue | react
+    // Find in dependencies
+    const frameTag = constant_1.FRAMEWORK_NAMES.find(framework => packageJson.dependencies?.[framework]);
+    // Find in dev dependencies
+    // Priority: Production dependencies > Development dependencies
+    const devFrameTag = constant_1.FRAMEWORK_NAMES.find(framework => packageJson.devDependencies?.[framework]);
+    return frameTag ?? devFrameTag ?? '';
+}

package/dist/functions/prepareConfig.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendsConfig = extendsConfig;
+exports.prepareConfig = prepareConfig;
+const lodash_1 = require("lodash");
+const helper_1 = require("../helper");
+function extendsConfig(config, newConfig) {
+    const mergedConfig = (0, lodash_1.cloneDeep)(config);
+    return (0, lodash_1.mergeWith)(mergedConfig, newConfig, (srcValue, newValue, key) => {
+        if (key !== 'handleApi') {
+            return newValue ?? srcValue; // fallback to default merge behavior
+        }
+        // handleApi is a special case, we need to merge the functions
+        if (typeof newValue === 'function' && typeof srcValue === 'function') {
+            // chain the functions
+            return (...args) => {
+                const result = srcValue(...args);
+                // null or undefined return is a valid value for filtering
+                // if plugin return undefined or null, we should break the chain
+                if (!result) {
+                    return result;
+                }
+                return newValue(result);
+            };
+        }
+        return newValue ?? srcValue; // fallback to default merge behavior
+    });
+}
+async function prepareConfig(config, projectPath = process.cwd(), tracker) {
+    let _config = (0, lodash_1.cloneDeep)(config);
+    const plugins = _config.plugins || [];
+    const reporter = (plugin) => tracker?.reporterFor(plugin.name ?? 'plugin') ?? (() => { });
+    const pluginDriver = new helper_1.PluginDriver(plugins, { reporter });
+    // plugin: handle config hook
+    _config = await pluginDriver.hookSeqEach('config', (_plugin, prevResult, _ctx) => {
+        const nextConfig = prevResult ?? _config;
+        return { config: nextConfig, projectPath };
+    }) ?? _config;
+    return _config;
+}
+exports.default = prepareConfig;

package/dist/functions/readWormaRc.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readWormaRc = readWormaRc;
+exports.hasWormaRc = hasWormaRc;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const constant_1 = require("../constant");
+const logger_1 = require("../helper/logger");
+const plugins_1 = require("../plugins");
+const template_1 = require("../template");
+/**
+ * Parse a single line from .wormarc file
+ *
+ * Supported formats:
+ * - `https://xxxx.com/openapi.json` -> generates in src/api, default alova template
+ * - `https://yyyy.com/openapi.json, axios` -> generates in src/api2, axios template
+ * - `myApi=https://zzzz.com/openapi.json` -> generates in src/myApi, default alova template
+ * - `myApi=https://zzzz.com/openapi.json, fetch` -> generates in src/myApi, fetch template
+ */
+function parseLine(line) {
+    line = line.trim();
+    if (!line) {
+        return null;
+    }
+    // Lines starting with # are full-line comments
+    if (line.startsWith('#')) {
+        return null;
+    }
+    // Strip inline comments: ` //` (space before //) to avoid matching // in URLs
+    const inlineCommentIndex = line.indexOf(' //');
+    if (inlineCommentIndex !== -1) {
+        line = line.substring(0, inlineCommentIndex).trim();
+    }
+    if (!line) {
+        return null;
+    }
+    let outputKey;
+    let url;
+    let template;
+    // Check for key=value format
+    const equalIndex = line.indexOf('=');
+    if (equalIndex !== -1) {
+        outputKey = line.substring(0, equalIndex).trim();
+        line = line.substring(equalIndex + 1).trim();
+    }
+    // Split by comma to get URL and template
+    const commaIndex = line.indexOf(',');
+    if (commaIndex !== -1) {
+        url = line.substring(0, commaIndex).trim();
+        template = line.substring(commaIndex + 1).trim() || undefined;
+    }
+    else {
+        url = line.trim();
+    }
+    if (!url) {
+        return null;
+    }
+    return {
+        outputKey,
+        url,
+        template: template,
+    };
+}
+/**
+ * Template type mapping to plugin factories
+ */
+const PRESET_TEMPLATES = {
+    alova: template_1.alova,
+    alovaGlobals: template_1.alovaGlobals,
+    axios: template_1.axios,
+    fetch: template_1.fetch,
+    ky: template_1.ky,
+};
+/**
+ * Read and parse .wormarc file
+ *
+ * File format:
+ * ```bash
+ * # Comment lines start with #
+ * https://xxxx.com/openapi.json
+ * https://yyyy.com/openapi.json, axios
+ * myApi=https://zzzz.com/openapi.json, fetch
+ * ```
+ *
+ * @param projectPath The project path where .wormarc file is located
+ * @returns Parsed configuration or null if file doesn't exist
+ */
+async function readWormaRc(projectPath) {
+    const rcPath = node_path_1.default.join(projectPath, '.wormarc');
+    try {
+        const content = await promises_1.default.readFile(rcPath, 'utf-8');
+        const lines = content.split('\n');
+        const generators = [];
+        let defaultIndex = 1;
+        for (const line of lines) {
+            const parsed = parseLine(line);
+            if (!parsed) {
+                continue;
+            }
+            const { outputKey, url, template = constant_1.PresetTemplateName.ALOVA } = parsed;
+            // Determine output folder
+            let output;
+            if (outputKey) {
+                // If outputKey contains `/`, use it as-is (already a path)
+                output = outputKey.includes('/') ? outputKey : `src/${outputKey}`;
+            }
+            else {
+                // Default folder is src/api, src/api2, etc.
+                output = defaultIndex === 1 ? 'src/api' : `src/api${defaultIndex}`;
+                defaultIndex++;
+            }
+            // Set template if specified
+            if (!template || !PRESET_TEMPLATES[template]) {
+                throw logger_1.logger.throwError(`Invalid template: ${template}. Available templates: ${Object.keys(PRESET_TEMPLATES).join(', ')}`);
+            }
+            // Build generator config
+            const generatorConfig = {
+                input: url,
+                output,
+                plugins: [PRESET_TEMPLATES[template](), (0, plugins_1.aiDoc)({ installSkill: true })],
+            };
+            generators.push(generatorConfig);
+        }
+        if (generators.length === 0) {
+            return null;
+        }
+        return {
+            generator: generators,
+        };
+    }
+    catch (error) {
+        // File doesn't exist or can't be read
+        if (error.code === 'ENOENT') {
+            return null;
+        }
+        logger_1.logger.warn('Failed to read .wormarc file:', error);
+        return null;
+    }
+}
+/**
+ * Check if .wormarc file exists
+ */
+async function hasWormaRc(projectPath) {
+    const rcPath = node_path_1.default.join(projectPath, '.wormarc');
+    try {
+        await promises_1.default.access(rcPath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/functions/wormaJson.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCacheRelativePath = toCacheRelativePath;
+exports.computeApiHash = computeApiHash;
+exports.computePerTagHashes = computePerTagHashes;
+exports.readCacheIndex = readCacheIndex;
+exports.writeApiCacheEntry = writeApiCacheEntry;
+exports.writeCacheIndex = writeCacheIndex;
+exports.writeCacheEntry = writeCacheEntry;
+exports.readCacheApis = readCacheApis;
+exports.readAllCacheApis = readAllCacheApis;
+exports.getCacheEntry = getCacheEntry;
+exports.diffChangedTags = diffChangedTags;
+exports.toCacheData = toCacheData;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("../config");
+// ---- Directory-based cache format ----
+const CACHE_SCHEMA_VERSION = 1;
+function slugify(p) {
+    return p.replace(/[\\/.]/g, '_').replace(/[^\w-]/g, '').slice(0, 128);
+}
+/** Get the effective cache root directory. When cacheRoot is set in global config, it overrides projectRoot. */
+function getCacheRoot(projectRoot) {
+    return (0, config_1.getGlobalConfig)().cacheRoot || projectRoot;
+}
+function cacheDirPath(projectRoot) {
+    return node_path_1.default.join(getCacheRoot(projectRoot), (0, config_1.getGlobalConfig)().cacheDir);
+}
+/**
+ * Resolve outputPath to a cache-root-relative path used as the lookup key in cache index.
+ * In monorepo mode (cacheRoot ≠ projectPath), this converts a sub-package-relative path
+ * to a workspace-root-relative path so all caches live under one directory.
+ */
+function toCacheRelativePath(projectPath, outputPath) {
+    const cacheRoot = (0, config_1.getGlobalConfig)().cacheRoot;
+    if (!cacheRoot || cacheRoot === projectPath) {
+        return outputPath.replace(/\\/g, '/');
+    }
+    const absoluteOutput = node_path_1.default.isAbsolute(outputPath)
+        ? outputPath
+        : node_path_1.default.resolve(projectPath, outputPath);
+    return (node_path_1.default.relative(cacheRoot, absoluteOutput) || '.').replace(/\\/g, '/');
+}
+// ---- M3-B2: API hash computation ----
+/**
+ * P2: WeakMap cache for per-Api hashes. Same Api object reused across
+ * incremental runs shares the cached hash, avoiding redundant SHA256.
+ */
+const apiHashCache = new WeakMap();
+/**
+ * Compute stable hash for a single API (only essential fields).
+ * Result is cached per Api object identity via WeakMap.
+ */
+function computeApiHash(api) {
+    if (apiHashCache.has(api)) {
+        return apiHashCache.get(api);
+    }
+    const { tag, method, path: apiPath, name, response, requestBody, queryParameters, pathParameters } = api;
+    const hash = (0, node_crypto_1.createHash)('sha256')
+        .update(JSON.stringify({ tag, method, path: apiPath, name, response, requestBody, queryParameters, pathParameters }))
+        .digest('hex')
+        .slice(0, 16);
+    apiHashCache.set(api, hash);
+    return hash;
+}
+/**
+ * Compute aggregate hash + per-tag hashes for a set of APIs.
+ * When `tagedApis` is provided, avoids re-grouping APIs by tag.
+ */
+function computePerTagHashes(allApis, tagedApis) {
+    const tags = {};
+    const allHashes = [];
+    if (tagedApis) {
+        // P2: Use pre-grouped tagedApis to avoid O(n) re-grouping loop
+        for (const { tagName, apis: groupApis } of tagedApis) {
+            const hashes = groupApis.map(computeApiHash).sort();
+            allHashes.push(...hashes);
+            tags[tagName] = (0, node_crypto_1.createHash)('sha256').update(hashes.join('')).digest('hex').slice(0, 16);
+        }
+    }
+    else {
+        const tagGroups = new Map();
+        for (const api of allApis) {
+            const group = tagGroups.get(api.tag) || [];
+            group.push(api);
+            tagGroups.set(api.tag, group);
+        }
+        for (const [tag, groupApis] of tagGroups) {
+            const hashes = groupApis.map(computeApiHash).sort();
+            allHashes.push(...hashes);
+            tags[tag] = (0, node_crypto_1.createHash)('sha256').update(hashes.join('')).digest('hex').slice(0, 16);
+        }
+    }
+    const aggregateHash = (0, node_crypto_1.createHash)('sha256').update(allHashes.sort().join('')).digest('hex').slice(0, 16);
+    return { hash: aggregateHash, tags };
+}
+// ---- M3-B3: New format read/write ----
+async function readCacheIndex(projectRoot) {
+    try {
+        const indexFile = node_path_1.default.join(cacheDirPath(projectRoot), 'index.json');
+        const content = await promises_1.default.readFile(indexFile, 'utf-8');
+        const index = JSON.parse(content);
+        if (index.schemaVersion !== CACHE_SCHEMA_VERSION)
+            return null;
+        if (!Array.isArray(index.entries))
+            return null;
+        return index;
+    }
+    catch {
+        return null;
+    }
+}
+/** Write a single entry's API data file to disk (without updating index). */
+async function writeApiCacheEntry(projectRoot, outputPath, serverName, apis) {
+    const dataDir = node_path_1.default.join(cacheDirPath(projectRoot), 'data');
+    const slug = slugify(outputPath);
+    const entryFile = node_path_1.default.join(dataDir, `${slug}.json`);
+    await promises_1.default.mkdir(node_path_1.default.dirname(entryFile), { recursive: true });
+    await promises_1.default.writeFile(entryFile, JSON.stringify({ serverName, apis }));
+}
+/** Write/update the cache index.json from pre-computed entries. */
+async function writeCacheIndex(projectRoot, newEntries) {
+    const dir = cacheDirPath(projectRoot);
+    let index;
+    try {
+        const indexFile = node_path_1.default.join(dir, 'index.json');
+        index = JSON.parse(await promises_1.default.readFile(indexFile, 'utf-8'));
+        if (index.schemaVersion !== CACHE_SCHEMA_VERSION)
+            index = { schemaVersion: CACHE_SCHEMA_VERSION, entries: [] };
+    }
+    catch {
+        index = { schemaVersion: CACHE_SCHEMA_VERSION, entries: [] };
+    }
+    for (const newEntry of newEntries) {
+        const existingIdx = index.entries.findIndex(e => e.path === newEntry.path);
+        if (existingIdx >= 0)
+            index.entries[existingIdx] = newEntry;
+        else
+            index.entries.push(newEntry);
+    }
+    index.entries.sort((a, b) => a.path.localeCompare(b.path));
+    await promises_1.default.mkdir(dir, { recursive: true });
+    await promises_1.default.writeFile(node_path_1.default.join(dir, 'index.json'), JSON.stringify(index));
+}
+async function writeCacheEntry(projectRoot, outputPath, serverName, apis, hashInfo) {
+    // Resolve to cache-root-relative path: in monorepo this produces e.g. "packages/a/src/api"
+    const relativePath = toCacheRelativePath(projectRoot, outputPath);
+    await writeApiCacheEntry(projectRoot, relativePath, serverName, apis);
+    await writeCacheIndex(projectRoot, [{ path: relativePath, serverName, hash: hashInfo.hash, tags: hashInfo.tags }]);
+}
+/** Read APIs from cache directory */
+async function readCacheApis(projectRoot, outputPath) {
+    const relativePath = toCacheRelativePath(projectRoot, outputPath);
+    const index = await readCacheIndex(projectRoot);
+    if (index) {
+        const entry = index.entries.find(e => e.path === relativePath);
+        if (entry) {
+            const slug = slugify(relativePath);
+            const entryFile = node_path_1.default.join(cacheDirPath(projectRoot), 'data', `${slug}.json`);
+            try {
+                const content = JSON.parse(await promises_1.default.readFile(entryFile, 'utf-8'));
+                return { path: relativePath, serverName: content.serverName, apis: content.apis };
+            }
+            catch {
+                return null;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Read ALL cached API entries from the unified cache directory.
+ * In monorepo mode where cacheRoot unifies all sub-package caches,
+ * this returns entries from every sub-project at once.
+ */
+async function readAllCacheApis(projectRoot) {
+    const index = await readCacheIndex(projectRoot);
+    if (!index)
+        return [];
+    const results = [];
+    const dataDir = node_path_1.default.join(cacheDirPath(projectRoot), 'data');
+    for (const entry of index.entries) {
+        const slug = slugify(entry.path);
+        const entryFile = node_path_1.default.join(dataDir, `${slug}.json`);
+        try {
+            const content = JSON.parse(await promises_1.default.readFile(entryFile, 'utf-8'));
+            results.push({
+                path: entry.path,
+                serverName: content.serverName || entry.serverName || '',
+                apis: content.apis || [],
+            });
+        }
+        catch { /* skip corrupted data file */ }
+    }
+    return results;
+}
+/** Get cache entry metadata (hash + tags) without loading APIs */
+async function getCacheEntry(projectRoot, outputPath) {
+    const relativePath = toCacheRelativePath(projectRoot, outputPath);
+    const index = await readCacheIndex(projectRoot);
+    if (!index)
+        return null;
+    return index.entries.find(e => e.path === relativePath) ?? null;
+}
+/** Find set of tags whose hash differs between old and new */
+function diffChangedTags(oldTags, newTags) {
+    const changed = new Set();
+    for (const [tag, tagHash] of Object.entries(newTags)) {
+        if (oldTags[tag] !== tagHash)
+            changed.add(tag);
+    }
+    for (const tag of Object.keys(oldTags)) {
+        if (!newTags[tag])
+            changed.add(tag); // removed tags
+    }
+    return changed;
+}
+/**
+ * Convert TemplateData to standardized CacheData entry.
+ */
+function toCacheData(templateData, outputPath, config) {
+    return {
+        path: outputPath,
+        serverName: config?.serverName || templateData.title || '',
+        apis: templateData.allApis || [],
+    };
+}