jsdoc-builder 0.0.5 → 0.0.7

package/dist/index.js

@@ -1,71 +1,808 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateJSDoc = generateJSDoc;
-const ts = require("typescript");
-const fs = require("fs");
+exports.generateJSDocFromCode = generateJSDocFromCode;
+const ts = __importStar(require("typescript"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const https = __importStar(require("https"));
+const url_1 = require("url");
+const DEFAULT_PROMPT_TEMPLATE = "Write one concise sentence for the JSDoc @description of function '{{functionName}}'. Parameters: {{parameters}}. Return type: {{returnType}}. Source: {{sourceSnippet}}";
+const OPENAI_AI_DEFAULTS = {
+    provider: "openai",
+    model: "gpt-4o-mini",
+    baseUrl: "https://api.openai.com/v1/chat/completions",
+    timeoutMs: 12000,
+    promptTemplate: DEFAULT_PROMPT_TEMPLATE,
+};
+const GEMINI_AI_DEFAULTS = {
+    provider: "gemini",
+    model: "gemini-1.5-flash",
+    baseUrl: "https://generativelanguage.googleapis.com/v1beta",
+    timeoutMs: 12000,
+    promptTemplate: DEFAULT_PROMPT_TEMPLATE,
+};
+const DEFAULT_CONFIG = {
+    template: {
+        descriptionLine: "@description {{description}}",
+        paramLine: "@param {${type}} ${name}",
+        returnsLine: "@returns {${type}}",
+    },
+    ai: {
+        provider: OPENAI_AI_DEFAULTS.provider,
+        enabled: false,
+        model: OPENAI_AI_DEFAULTS.model,
+        baseUrl: OPENAI_AI_DEFAULTS.baseUrl,
+        timeoutMs: OPENAI_AI_DEFAULTS.timeoutMs,
+        promptTemplate: OPENAI_AI_DEFAULTS.promptTemplate,
+    },
+    includeReturnsWhenVoid: true,
+};
 /**
- * Parses a TypeScript or JavaScript file and adds JSDoc comments to functions.
+ * Parses a TypeScript, JavaScript, JSX, TSX, or Vue file and adds JSDoc comments to functions.
+ * Skips functions that already have JSDoc comments.
  * @param filePath - The path of the file to process.
  */
-function generateJSDoc(filePath) {
-    const sourceCode = fs.readFileSync(filePath, "utf-8");
-    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
-    const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
-    // Visit function that processes each node
-    function visit(node, context) {
+function generateJSDoc(filePath_1) {
+    return __awaiter(this, arguments, void 0, function* (filePath, options = {}) {
+        const sourceCode = fs.readFileSync(filePath, "utf-8");
+        const updatedCode = yield generateJSDocFromCode(filePath, sourceCode, options);
+        if (updatedCode !== sourceCode) {
+            fs.writeFileSync(filePath, updatedCode, "utf-8");
+        }
+    });
+}
+function generateJSDocFromCode(filePath_1, code_1) {
+    return __awaiter(this, arguments, void 0, function* (filePath, code, options = {}) {
+        const config = loadConfig(options);
+        return transformCode(filePath, code, config);
+    });
+}
+function transformCode(filePath, originalCode, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const ext = path.extname(filePath).toLowerCase();
+        let sourceCode = originalCode;
+        let vueScriptRange;
+        let scriptKind = resolveScriptKind(ext);
+        if (ext === ".vue") {
+            const vueScript = extractVueScript(originalCode);
+            if (!vueScript) {
+                return originalCode;
+            }
+            sourceCode = vueScript.content;
+            vueScriptRange = { start: vueScript.contentStart, end: vueScript.contentEnd };
+            scriptKind = resolveScriptKindFromVue(vueScript.openTag);
+        }
+        const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true, scriptKind);
+        const checker = createTypeChecker(filePath, sourceCode, scriptKind, sourceFile);
+        const targets = collectTargets(sourceFile, sourceCode, checker);
+        const commentMap = yield buildCommentMap(targets, config, checker);
+        if (commentMap.size === 0) {
+            return originalCode;
+        }
+        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+        const transformer = (context) => {
+            const visit = (node) => {
+                const key = makeNodeKey(node);
+                const comment = commentMap.get(key);
+                if (comment) {
+                    ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, comment, true);
+                }
+                return ts.visitEachChild(node, visit, context);
+            };
+            return (node) => ts.visitNode(node, visit);
+        };
+        const result = ts.transform(sourceFile, [transformer]);
+        const transformedSourceFile = result.transformed[0];
+        let transformedScriptCode = printer.printFile(transformedSourceFile);
+        result.dispose();
+        if (ext === ".vue" && vueScriptRange) {
+            const originalScriptContent = originalCode.slice(vueScriptRange.start, vueScriptRange.end);
+            if (originalScriptContent.startsWith("\n") && !transformedScriptCode.startsWith("\n")) {
+                transformedScriptCode = `\n${transformedScriptCode}`;
+            }
+            if (originalScriptContent.endsWith("\n") && !transformedScriptCode.endsWith("\n")) {
+                transformedScriptCode = `${transformedScriptCode}\n`;
+            }
+            const updatedCode = originalCode.slice(0, vueScriptRange.start) +
+                transformedScriptCode +
+                originalCode.slice(vueScriptRange.end);
+            return updatedCode;
+        }
+        return transformedScriptCode;
+    });
+}
+function loadConfig(options) {
+    var _a;
+    const fileConfig = loadConfigFile(options.configPath);
+    const merged = mergeDeep(DEFAULT_CONFIG, fileConfig, (_a = options.config) !== null && _a !== void 0 ? _a : {}, options.disableAI ? { ai: { enabled: false } } : {});
+    merged.ai.provider = normalizeProvider(merged.ai.provider);
+    applyProviderDefaults(merged.ai);
+    const envApiKey = resolveApiKeyFromEnv(merged.ai.provider);
+    if (!merged.ai.apiKey && envApiKey) {
+        merged.ai.apiKey = envApiKey;
+    }
+    if (merged.ai.enabled && !merged.ai.apiKey) {
+        merged.ai.enabled = false;
+    }
+    return merged;
+}
+function loadConfigFile(configPath) {
+    const targetPath = configPath || path.resolve(process.cwd(), "jsdoc-builder.config.json");
+    if (!fs.existsSync(targetPath)) {
+        return {};
+    }
+    try {
+        const raw = fs.readFileSync(targetPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!isObject(parsed)) {
+            return {};
+        }
+        return parsed;
+    }
+    catch (_a) {
+        return {};
+    }
+}
+function extractVueScript(sourceCode) {
+    var _a;
+    const scriptRegex = /<script\b[^>]*>([\s\S]*?)<\/script\s*>/i;
+    const match = scriptRegex.exec(sourceCode);
+    if (!match) {
+        return undefined;
+    }
+    const full = match[0];
+    const content = (_a = match[1]) !== null && _a !== void 0 ? _a : "";
+    const contentOffset = full.indexOf(content);
+    const fullStart = match.index;
+    const contentStart = fullStart + contentOffset;
+    const contentEnd = contentStart + content.length;
+    const openTag = full.slice(0, contentOffset);
+    return {
+        openTag,
+        content,
+        contentStart,
+        contentEnd,
+    };
+}
+function resolveScriptKind(ext) {
+    if (ext === ".js" || ext === ".mjs" || ext === ".cjs") {
+        return ts.ScriptKind.JS;
+    }
+    if (ext === ".jsx") {
+        return ts.ScriptKind.JSX;
+    }
+    if (ext === ".tsx") {
+        return ts.ScriptKind.TSX;
+    }
+    return ts.ScriptKind.TS;
+}
+function resolveScriptKindFromVue(openTag) {
+    const langMatch = openTag.match(/lang\s*=\s*["']?([a-zA-Z0-9-]+)/i);
+    const lang = ((langMatch === null || langMatch === void 0 ? void 0 : langMatch[1]) || "js").toLowerCase();
+    if (lang.includes("tsx")) {
+        return ts.ScriptKind.TSX;
+    }
+    if (lang.includes("jsx")) {
+        return ts.ScriptKind.JSX;
+    }
+    if (lang.includes("ts")) {
+        return ts.ScriptKind.TS;
+    }
+    return ts.ScriptKind.JS;
+}
+function collectTargets(sourceFile, sourceText, checker) {
+    const targets = [];
+    const walk = (node) => {
         if (ts.isFunctionDeclaration(node) && node.name) {
-            const jsDoc = createJSDoc(node.name.text, node.parameters, node.type);
-            ts.addSyntheticLeadingComment(node, ts.SyntaxKind.MultiLineCommentTrivia, jsDoc.comment, true);
-            return node;
+            const commentNode = node;
+            if (!hasJSDoc(commentNode, sourceText)) {
+                targets.push(createTarget(commentNode, node.name.text, node.parameters, inferReturnTypeText(node, checker), node.getText(sourceFile)));
+            }
         }
-        // Check for arrow functions assigned to a constant
         if (ts.isVariableDeclaration(node) &&
             node.initializer &&
-            ts.isArrowFunction(node.initializer)) {
-            const jsDoc = createJSDoc(node.name.getText(), node.initializer.parameters, node.initializer.type);
-            // Add JSDoc to the entire variable statement for clarity
-            const parent = node.parent;
-            if (ts.isVariableDeclarationList(parent) &&
-                parent.declarations.length === 1) {
-                ts.addSyntheticLeadingComment(parent.parent, ts.SyntaxKind.MultiLineCommentTrivia, jsDoc.comment, true);
-            }
-            return node;
-        }
-        return ts.visitEachChild(node, (child) => visit(child, context), context); // Pass context to visit
-    }
-    // Create the transformer
-    const transformer = (context) => {
-        return (sourceFile) => {
-            return ts.visitNode(sourceFile, (node) => visit(node, context)); // Pass context to visit
-        };
+            (ts.isArrowFunction(node.initializer) || ts.isFunctionExpression(node.initializer))) {
+            const functionNode = node.initializer;
+            const commentNode = resolveVariableCommentNode(node);
+            if (!hasJSDoc(commentNode, sourceText)) {
+                targets.push(createTarget(commentNode, getFunctionNameFromVariable(node), functionNode.parameters, inferReturnTypeText(functionNode, checker), functionNode.getText(sourceFile)));
+            }
+        }
+        ts.forEachChild(node, walk);
     };
-    // Apply the transformer
-    const result = ts.transform(sourceFile, [transformer]);
-    const transformedSourceFile = result.transformed[0];
-    const updatedCode = printer.printFile(transformedSourceFile);
-    fs.writeFileSync(filePath, updatedCode, "utf-8");
+    walk(sourceFile);
+    return targets;
 }
-/**
- * Creates a JSDoc comment.
- * @param functionName - The name of the function.
- * @param parameters - The parameters of the function.
- * @param returnType - The return type of the function.
- * @returns A JSDoc comment as a string.
- */
-function createJSDoc(functionName, parameters, returnType) {
-    const paramTags = parameters.map((param) => ({
-        tagName: "param",
-        name: param.name.getText(),
-        type: param.type ? param.type.getText() : "any",
+function resolveVariableCommentNode(node) {
+    const declarationList = node.parent;
+    if (ts.isVariableDeclarationList(declarationList) &&
+        declarationList.declarations.length === 1 &&
+        ts.isVariableStatement(declarationList.parent)) {
+        return declarationList.parent;
+    }
+    return node;
+}
+function createTarget(commentNode, functionName, parameters, returnTypeText, sourceSnippet) {
+    return {
+        key: makeNodeKey(commentNode),
+        functionName,
+        parameters,
+        returnTypeText,
+        sourceSnippet,
+    };
+}
+function buildCommentMap(targets, config, checker) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const entries = [];
+        for (const target of targets) {
+            const params = target.parameters.map((param, index) => ({
+                name: getParameterName(param, index),
+                type: inferParameterType(param, checker),
+            }));
+            const description = yield createDescription({
+                functionName: target.functionName,
+                returnType: target.returnTypeText,
+                parameters: params,
+                sourceSnippet: target.sourceSnippet,
+            }, config);
+            const comment = createJSDocComment(target.functionName, params, target.returnTypeText, description, config);
+            entries.push([target.key, comment]);
+        }
+        return new Map(entries);
+    });
+}
+function createDescription(context, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!config.ai.enabled || !config.ai.apiKey) {
+            return `${context.functionName} function`;
+        }
+        const aiDescription = yield requestDescriptionFromAI(context, config.ai);
+        if (!aiDescription) {
+            return `${context.functionName} function`;
+        }
+        return aiDescription;
+    });
+}
+function createJSDocComment(functionName, parameters, returnType, description, config) {
+    const lines = [];
+    lines.push(formatTemplate(config.template.descriptionLine, {
+        functionName,
+        description,
+        returnType,
+        paramsCount: String(parameters.length),
     }));
-    const returnTag = {
-        tagName: "returns",
-        type: returnType ? returnType.getText() : "void",
+    for (const param of parameters) {
+        lines.push(formatTemplate(config.template.paramLine, {
+            functionName,
+            description,
+            type: param.type,
+            name: param.name,
+            returnType,
+        }));
+    }
+    if (config.includeReturnsWhenVoid || returnType !== "void") {
+        lines.push(formatTemplate(config.template.returnsLine, {
+            functionName,
+            description,
+            type: returnType,
+            returnType,
+        }));
+    }
+    const withPrefix = lines.map((line) => ` * ${line}`);
+    return `*\n${withPrefix.join("\n")}\n `;
+}
+function requestDescriptionFromAI(context, aiConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!aiConfig.apiKey) {
+            return undefined;
+        }
+        const prompt = formatTemplate(aiConfig.promptTemplate, {
+            functionName: context.functionName,
+            returnType: context.returnType,
+            parameters: context.parameters.map((p) => `${p.name}:${p.type}`).join(", "),
+            sourceSnippet: context.sourceSnippet.replace(/\s+/g, " ").trim().slice(0, 300),
+        });
+        if (aiConfig.provider === "gemini") {
+            return requestDescriptionFromGemini(prompt, aiConfig);
+        }
+        return requestDescriptionFromOpenAI(prompt, aiConfig);
+    });
+}
+function requestDescriptionFromOpenAI(prompt, aiConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        const payload = {
+            model: aiConfig.model,
+            messages: [
+                {
+                    role: "system",
+                    content: "You write concise JSDoc descriptions. Return a single sentence with no markdown.",
+                },
+                { role: "user", content: prompt },
+            ],
+            temperature: 0.2,
+        };
+        try {
+            const response = yield postJson(aiConfig.baseUrl, payload, aiConfig.timeoutMs, {
+                Authorization: `Bearer ${aiConfig.apiKey}`,
+            });
+            const content = (_c = (_b = (_a = response === null || response === void 0 ? void 0 : response.choices) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.message) === null || _c === void 0 ? void 0 : _c.content;
+            if (typeof content !== "string") {
+                return undefined;
+            }
+            return content.replace(/[\r\n]+/g, " ").trim();
+        }
+        catch (_d) {
+            return undefined;
+        }
+    });
+}
+function requestDescriptionFromGemini(prompt, aiConfig) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b, _c;
+        if (!aiConfig.apiKey) {
+            return undefined;
+        }
+        const endpoint = buildGeminiEndpoint(aiConfig.baseUrl, aiConfig.model, aiConfig.apiKey);
+        const payload = {
+            systemInstruction: {
+                parts: [
+                    {
+                        text: "You write concise JSDoc descriptions. Return a single sentence with no markdown.",
+                    },
+                ],
+            },
+            contents: [
+                {
+                    role: "user",
+                    parts: [{ text: prompt }],
+                },
+            ],
+            generationConfig: {
+                temperature: 0.2,
+            },
+        };
+        try {
+            const response = yield postJson(endpoint, payload, aiConfig.timeoutMs);
+            const parts = (_c = (_b = (_a = response === null || response === void 0 ? void 0 : response.candidates) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.content) === null || _c === void 0 ? void 0 : _c.parts;
+            if (!Array.isArray(parts)) {
+                return undefined;
+            }
+            const content = parts
+                .map((part) => (typeof (part === null || part === void 0 ? void 0 : part.text) === "string" ? part.text : ""))
+                .join(" ")
+                .trim();
+            if (!content) {
+                return undefined;
+            }
+            return content.replace(/[\r\n]+/g, " ").trim();
+        }
+        catch (_d) {
+            return undefined;
+        }
+    });
+}
+function postJson(endpoint, payload, timeoutMs, headers = {}) {
+    const url = new url_1.URL(endpoint);
+    return new Promise((resolve, reject) => {
+        const req = https.request({
+            protocol: url.protocol,
+            hostname: url.hostname,
+            path: `${url.pathname}${url.search}`,
+            method: "POST",
+            port: url.port || undefined,
+            headers: Object.assign({ "Content-Type": "application/json" }, headers),
+        }, (res) => {
+            let body = "";
+            res.on("data", (chunk) => {
+                body += chunk;
+            });
+            res.on("end", () => {
+                if (!res.statusCode || res.statusCode >= 400) {
+                    reject(new Error("AI request failed"));
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch (_a) {
+                    reject(new Error("Invalid AI response"));
+                }
+            });
+        });
+        req.setTimeout(timeoutMs, () => {
+            req.destroy(new Error("AI request timeout"));
+        });
+        req.on("error", reject);
+        req.write(JSON.stringify(payload));
+        req.end();
+    });
+}
+function hasJSDoc(node, sourceText) {
+    var _a;
+    if (ts.getJSDocCommentsAndTags(node).length > 0) {
+        return true;
+    }
+    const ranges = (_a = ts.getLeadingCommentRanges(sourceText, node.getFullStart())) !== null && _a !== void 0 ? _a : [];
+    return ranges.some((range) => sourceText.slice(range.pos, range.end).startsWith("/**"));
+}
+function inferReturnTypeText(node, checker) {
+    if (checker) {
+        const signature = checker.getSignatureFromDeclaration(node);
+        if (signature) {
+            const returnType = checker.getReturnTypeOfSignature(signature);
+            const typeText = checker.typeToString(returnType);
+            if (typeText && typeText !== "{}") {
+                return typeText;
+            }
+        }
+    }
+    const parameterTypes = getParameterTypeMap(node.parameters, checker);
+    if (node.type) {
+        return node.type.getText();
+    }
+    if (!node.body) {
+        return "void";
+    }
+    if (ts.isArrowFunction(node) && !ts.isBlock(node.body)) {
+        return finalizeReturnType(inferExpressionType(node.body, parameterTypes), node);
+    }
+    const returnTypes = new Set();
+    const walk = (current) => {
+        if (current !== node && isFunctionLike(current)) {
+            return;
+        }
+        if (ts.isReturnStatement(current)) {
+            if (!current.expression) {
+                returnTypes.add("void");
+            }
+            else {
+                returnTypes.add(inferExpressionType(current.expression, parameterTypes));
+            }
+        }
+        ts.forEachChild(current, walk);
+    };
+    walk(node.body);
+    if (returnTypes.size === 0) {
+        return "void";
+    }
+    const types = Array.from(returnTypes).filter((type) => type !== "void");
+    if (types.length === 0) {
+        return finalizeReturnType("void", node);
+    }
+    return finalizeReturnType(types.join(" | "), node);
+}
+function inferExpressionType(expression, parameterTypes) {
+    if (ts.isParenthesizedExpression(expression)) {
+        return inferExpressionType(expression.expression, parameterTypes);
+    }
+    if (ts.isNumericLiteral(expression)) {
+        return "number";
+    }
+    if (ts.isStringLiteral(expression) ||
+        ts.isNoSubstitutionTemplateLiteral(expression) ||
+        ts.isTemplateExpression(expression)) {
+        return "string";
+    }
+    if (expression.kind === ts.SyntaxKind.TrueKeyword || expression.kind === ts.SyntaxKind.FalseKeyword) {
+        return "boolean";
+    }
+    if (ts.isArrayLiteralExpression(expression)) {
+        return "Array<any>";
+    }
+    if (ts.isObjectLiteralExpression(expression)) {
+        return "object";
+    }
+    if (expression.kind === ts.SyntaxKind.NullKeyword) {
+        return "null";
+    }
+    if (ts.isArrowFunction(expression) || ts.isFunctionExpression(expression)) {
+        return "Function";
+    }
+    if (ts.isIdentifier(expression)) {
+        return parameterTypes.get(expression.text) || "any";
+    }
+    if (ts.isAsExpression(expression)) {
+        return expression.type.getText();
+    }
+    if (ts.isTypeAssertionExpression(expression)) {
+        return expression.type.getText();
+    }
+    if (ts.isPrefixUnaryExpression(expression)) {
+        if (expression.operator === ts.SyntaxKind.ExclamationToken) {
+            return "boolean";
+        }
+        if (expression.operator === ts.SyntaxKind.PlusToken ||
+            expression.operator === ts.SyntaxKind.MinusToken) {
+            return "number";
+        }
+    }
+    if (ts.isBinaryExpression(expression)) {
+        const left = inferExpressionType(expression.left, parameterTypes);
+        const right = inferExpressionType(expression.right, parameterTypes);
+        const operator = expression.operatorToken.kind;
+        if (operator === ts.SyntaxKind.PlusToken) {
+            if (left === "string" || right === "string") {
+                return "string";
+            }
+            if (left === "number" && right === "number") {
+                return "number";
+            }
+            return "any";
+        }
+        if (operator === ts.SyntaxKind.MinusToken ||
+            operator === ts.SyntaxKind.AsteriskToken ||
+            operator === ts.SyntaxKind.SlashToken ||
+            operator === ts.SyntaxKind.PercentToken ||
+            operator === ts.SyntaxKind.AsteriskAsteriskToken) {
+            return "number";
+        }
+        if (operator === ts.SyntaxKind.GreaterThanToken ||
+            operator === ts.SyntaxKind.GreaterThanEqualsToken ||
+            operator === ts.SyntaxKind.LessThanToken ||
+            operator === ts.SyntaxKind.LessThanEqualsToken ||
+            operator === ts.SyntaxKind.EqualsEqualsToken ||
+            operator === ts.SyntaxKind.EqualsEqualsEqualsToken ||
+            operator === ts.SyntaxKind.ExclamationEqualsToken ||
+            operator === ts.SyntaxKind.ExclamationEqualsEqualsToken ||
+            operator === ts.SyntaxKind.InstanceOfKeyword ||
+            operator === ts.SyntaxKind.InKeyword) {
+            return "boolean";
+        }
+        if (operator === ts.SyntaxKind.AmpersandAmpersandToken ||
+            operator === ts.SyntaxKind.BarBarToken ||
+            operator === ts.SyntaxKind.QuestionQuestionToken) {
+            return left === right ? left : `${left} | ${right}`;
+        }
+        if (operator === ts.SyntaxKind.EqualsToken ||
+            operator === ts.SyntaxKind.PlusEqualsToken ||
+            operator === ts.SyntaxKind.MinusEqualsToken ||
+            operator === ts.SyntaxKind.SlashEqualsToken ||
+            operator === ts.SyntaxKind.AsteriskEqualsToken ||
+            operator === ts.SyntaxKind.PercentEqualsToken) {
+            return right;
+        }
+    }
+    if (ts.isAwaitExpression(expression)) {
+        return "Promise<any>";
+    }
+    if (ts.isConditionalExpression(expression)) {
+        const whenTrue = inferExpressionType(expression.whenTrue, parameterTypes);
+        const whenFalse = inferExpressionType(expression.whenFalse, parameterTypes);
+        return whenTrue === whenFalse ? whenTrue : `${whenTrue} | ${whenFalse}`;
+    }
+    return "any";
+}
+function inferParameterType(param, checker) {
+    if (checker) {
+        const type = checker.getTypeAtLocation(param);
+        const typeText = checker.typeToString(type);
+        if (typeText && typeText !== "{}") {
+            return typeText;
+        }
+    }
+    if (param.type) {
+        return param.type.getText();
+    }
+    if (param.initializer) {
+        return inferExpressionType(param.initializer, new Map());
+    }
+    if (param.dotDotDotToken) {
+        return "Array<any>";
+    }
+    return "any";
+}
+function getFunctionNameFromVariable(node) {
+    if (ts.isIdentifier(node.name)) {
+        return node.name.text;
+    }
+    return "anonymousFunction";
+}
+function getParameterName(param, index) {
+    if (ts.isIdentifier(param.name)) {
+        return param.name.text;
+    }
+    return `param${index + 1}`;
+}
+function makeNodeKey(node) {
+    return `${node.kind}:${node.getStart()}:${node.getEnd()}`;
+}
+function formatTemplate(template, values) {
+    let output = template;
+    for (const [key, value] of Object.entries(values)) {
+        output = output.replace(new RegExp(`{{\\s*${escapeRegExp(key)}\\s*}}`, "g"), value);
+        output = output.replace(new RegExp(`\\$\\{\\s*${escapeRegExp(key)}\\s*\\}`, "g"), value);
+    }
+    return output;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\\]\\]/g, "\\$&");
+}
+function mergeDeep(...sources) {
+    const result = {
+        template: Object.assign({}, DEFAULT_CONFIG.template),
+        ai: Object.assign({}, DEFAULT_CONFIG.ai),
+        includeReturnsWhenVoid: DEFAULT_CONFIG.includeReturnsWhenVoid,
+    };
+    for (const source of sources) {
+        if (!source || !isObject(source)) {
+            continue;
+        }
+        if ("template" in source && isObject(source.template)) {
+            result.template = Object.assign(Object.assign({}, result.template), source.template);
+        }
+        if ("ai" in source && isObject(source.ai)) {
+            result.ai = Object.assign(Object.assign({}, result.ai), source.ai);
+        }
+        if (typeof source.includeReturnsWhenVoid === "boolean") {
+            result.includeReturnsWhenVoid = source.includeReturnsWhenVoid;
+        }
+    }
+    return result;
+}
+function getParameterTypeMap(parameters, checker) {
+    const map = new Map();
+    parameters.forEach((param) => {
+        if (ts.isIdentifier(param.name)) {
+            map.set(param.name.text, inferParameterType(param, checker));
+        }
+    });
+    return map;
+}
+function finalizeReturnType(inferredType, node) {
+    var _a;
+    const isAsync = !!((_a = node.modifiers) === null || _a === void 0 ? void 0 : _a.some((modifier) => modifier.kind === ts.SyntaxKind.AsyncKeyword));
+    if (!isAsync) {
+        return inferredType;
+    }
+    if (inferredType.startsWith("Promise<")) {
+        return inferredType;
+    }
+    return `Promise<${inferredType}>`;
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFunctionLike(node) {
+    return (ts.isFunctionDeclaration(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isArrowFunction(node) ||
+        ts.isMethodDeclaration(node) ||
+        ts.isGetAccessorDeclaration(node) ||
+        ts.isSetAccessorDeclaration(node) ||
+        ts.isConstructorDeclaration(node));
+}
+function normalizeProvider(provider) {
+    return provider === "gemini" ? "gemini" : "openai";
+}
+function resolveApiKeyFromEnv(provider) {
+    if (provider === "gemini") {
+        return process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+    }
+    return process.env.OPENAI_API_KEY;
+}
+function applyProviderDefaults(ai) {
+    if (ai.provider === "gemini") {
+        if (!ai.model || ai.model === OPENAI_AI_DEFAULTS.model) {
+            ai.model = GEMINI_AI_DEFAULTS.model;
+        }
+        if (!ai.baseUrl || ai.baseUrl === OPENAI_AI_DEFAULTS.baseUrl) {
+            ai.baseUrl = GEMINI_AI_DEFAULTS.baseUrl;
+        }
+    }
+    else {
+        if (!ai.model || ai.model === GEMINI_AI_DEFAULTS.model) {
+            ai.model = OPENAI_AI_DEFAULTS.model;
+        }
+        if (!ai.baseUrl || ai.baseUrl === GEMINI_AI_DEFAULTS.baseUrl) {
+            ai.baseUrl = OPENAI_AI_DEFAULTS.baseUrl;
+        }
+    }
+    if (!ai.promptTemplate) {
+        ai.promptTemplate = DEFAULT_PROMPT_TEMPLATE;
+    }
+    if (!ai.timeoutMs || ai.timeoutMs <= 0) {
+        ai.timeoutMs =
+            ai.provider === "gemini"
+                ? GEMINI_AI_DEFAULTS.timeoutMs
+                : OPENAI_AI_DEFAULTS.timeoutMs;
+    }
+}
+function buildGeminiEndpoint(baseUrl, model, apiKey) {
+    const cleanBaseUrl = baseUrl.replace(/\/+$/, "");
+    const encodedModel = encodeURIComponent(model);
+    const encodedApiKey = encodeURIComponent(apiKey);
+    return `${cleanBaseUrl}/models/${encodedModel}:generateContent?key=${encodedApiKey}`;
+}
+function createTypeChecker(filePath, sourceCode, scriptKind, sourceFile) {
+    const virtualPath = resolveVirtualPath(filePath, scriptKind);
+    const options = {
+        target: ts.ScriptTarget.ESNext,
+        allowJs: true,
+        checkJs: false,
+        jsx: ts.JsxEmit.Preserve,
+        skipLibCheck: true,
+    };
+    const defaultHost = ts.createCompilerHost(options, true);
+    const normalizedVirtualPath = path.resolve(virtualPath);
+    const host = Object.assign(Object.assign({}, defaultHost), { getSourceFile: (targetFileName, languageVersion, onError, shouldCreateNewSourceFile) => {
+            if (path.resolve(targetFileName) === normalizedVirtualPath) {
+                return sourceFile;
+            }
+            return defaultHost.getSourceFile(targetFileName, languageVersion, onError, shouldCreateNewSourceFile);
+        }, readFile: (targetFileName) => {
+            if (path.resolve(targetFileName) === normalizedVirtualPath) {
+                return sourceCode;
+            }
+            return defaultHost.readFile(targetFileName);
+        }, fileExists: (targetFileName) => {
+            if (path.resolve(targetFileName) === normalizedVirtualPath) {
+                return true;
+            }
+            return defaultHost.fileExists(targetFileName);
+        } });
+    try {
+        const program = ts.createProgram([normalizedVirtualPath], options, host);
+        return program.getTypeChecker();
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+function resolveVirtualPath(filePath, scriptKind) {
+    const ext = path.extname(filePath);
+    if (ext && ext !== ".vue") {
+        return filePath;
+    }
+    const suffixByKind = {
+        [ts.ScriptKind.TS]: ".ts",
+        [ts.ScriptKind.TSX]: ".tsx",
+        [ts.ScriptKind.JS]: ".js",
+        [ts.ScriptKind.JSX]: ".jsx",
     };
-    const commentText = [
-        `* @description Press Your { Function ${functionName} } Description`,
-        ...paramTags.map((tag) => `* @param {${tag.type}} ${tag.name}`),
-        `* @returns {${returnTag.type}}`,
-    ].join("\n");
-    return { comment: `*\n${commentText}\n` };
+    const suffix = suffixByKind[scriptKind] || ".js";
+    return `${filePath}${suffix}`;
 }