@openinc/parse-server-opendash 3.19.1 → 3.20.0

package/dist/features/documentation/core/Organizer.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentationOrganizer = void 0;
+const TreeNormalizer_1 = require("../services/TreeNormalizer");
+const StructureBuilder_1 = require("../services/StructureBuilder");
+const ConfigApplier_1 = require("../services/ConfigApplier");
+const MetadataEnricher_1 = require("../services/MetadataEnricher");
+const ContentLoader_1 = require("../services/ContentLoader");
+const FeatureFilter_1 = require("../services/FeatureFilter");
+/**
+ * Documentation Structure Organizer
+ */
+class DocumentationOrganizer {
+    /**
+     * Organize GitHub tree data into a hierarchical structure
+     */
+    static async organizeRepositoryStructure(treeData, fileFilter, rootPath, githubClient, owner, repo, branch, defaultFolderConfig) {
+        // 1. Normalize tree into flat file list
+        const { files: normalizedFiles } = TreeNormalizer_1.TreeNormalizer.normalize(treeData, rootPath, fileFilter);
+        // 2. Build folder structure & identify config.json files
+        const { root: builtRoot, configFiles } = StructureBuilder_1.StructureBuilder.build(normalizedFiles, rootPath, defaultFolderConfig);
+        // 3. Apply configs
+        await ConfigApplier_1.ConfigApplier.apply(builtRoot, configFiles, githubClient, owner, repo, branch, rootPath);
+        // 4. Apply feature filtering
+        console.log(`[DocumentationOrganizer] Applying feature-based filtering...`);
+        const preFilterFileCount = normalizedFiles.length;
+        const filteredRoot = FeatureFilter_1.FeatureFilter.filterByFeature(builtRoot);
+        const filteredFiles = FeatureFilter_1.FeatureFilter.filterFileList(normalizedFiles, filteredRoot);
+        const postFilterFileCount = filteredFiles.length;
+        if (preFilterFileCount !== postFilterFileCount) {
+            console.log(`[DocumentationOrganizer] Feature filtering applied: ${preFilterFileCount - postFilterFileCount} files filtered out`);
+        }
+        else {
+            console.log(`[DocumentationOrganizer] Feature filtering applied: no files filtered`);
+        }
+        // 5. Enrich commit metadata
+        if (githubClient && owner && repo) {
+            await MetadataEnricher_1.MetadataEnricher.enrichCommits(filteredFiles, githubClient, owner, repo, branch, rootPath);
+            // 6. Load content
+            await ContentLoader_1.ContentLoader.populate(filteredFiles, githubClient, owner, repo, branch, rootPath);
+        }
+        // Build extension map
+        const filesByExtension = new Map();
+        for (const f of filteredFiles) {
+            if (!filesByExtension.has(f.extension))
+                filesByExtension.set(f.extension, []);
+            filesByExtension.get(f.extension).push(f);
+        }
+        return { root: filteredRoot, allFiles: filteredFiles, filesByExtension };
+    }
+}
+exports.DocumentationOrganizer = DocumentationOrganizer;

package/dist/features/documentation/core/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Importer";
+export * from "./Cleanup";
+export * from "./Converter";
+export * from "./Organizer";

package/dist/features/documentation/core/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Importer"), exports);
+__exportStar(require("./Cleanup"), exports);
+__exportStar(require("./Converter"), exports);
+__exportStar(require("./Organizer"), exports);

package/dist/features/documentation/functions/importDocs.d.ts

@@ -0,0 +1,2 @@
+import "dotenv/config";
+export declare function importDocs(): Promise<void>;

package/dist/features/documentation/functions/importDocs.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importDocs = importDocs;
+require("dotenv/config");
+const core_1 = require("../core");
+const config_1 = require("../config");
+const Converter_1 = require("../core/Converter");
+const types_1 = require("../../../types");
+const GITHUB_TOKEN = process.env.OI_DOCUMENTATION_GITHUB_ACCESS_TOKEN;
+async function importDocs() {
+    try {
+        if (!GITHUB_TOKEN) {
+            throw new Error("Missing GitHub token - Please set OI_DOCUMENTATION_GITHUB_ACCESS_TOKEN environment variable");
+        }
+        const importer = new core_1.DocumentationImporter(GITHUB_TOKEN);
+        // Use the configuration helper to create import options
+        const config = (0, config_1.createImportConfig)({
+            token: GITHUB_TOKEN,
+        });
+        const userId = process.env.OI_DOCUMENTATION_USER_ID;
+        const user = userId
+            ? await new Parse.Query(Parse.User)
+                .equalTo("objectId", userId)
+                .include("tenant")
+                .first({ useMasterKey: true })
+            : undefined;
+        const tenantId = process.env.OI_DOCUMENTATION_TENANT_ID;
+        const tenant = tenantId
+            ? new types_1.Tenant({ objectId: tenantId })
+            : user?.get("tenant");
+        const result = await importer.importFromRepository(config, user, tenant);
+        if (result.metadata.skipped)
+            return;
+        if (result.structure)
+            await new Converter_1.DocumentationConverter(result).convert(user, tenant);
+    }
+    catch (err) {
+        console.error("Error importing documentation:", err);
+    }
+}

package/dist/features/documentation/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./core";
+export * from "./services";
+export * from "./types";
+export * from "./config";
+export { DocumentationImporter } from "./core/Importer";
+export { GitHubClient } from "./services/GitHubClient";
+export { DocumentationOrganizer } from "./core/Organizer";
+export { createImportConfig, DEFAULT_IMPORT_CONFIG, IMPORT_PRESETS, } from "./config/defaults";

package/dist/features/documentation/index.js

@@ -0,0 +1,34 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMPORT_PRESETS = exports.DEFAULT_IMPORT_CONFIG = exports.createImportConfig = exports.DocumentationOrganizer = exports.GitHubClient = exports.DocumentationImporter = void 0;
+// Core exports
+__exportStar(require("./core"), exports);
+__exportStar(require("./services"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./config"), exports);
+// Main classes for easy access
+var Importer_1 = require("./core/Importer");
+Object.defineProperty(exports, "DocumentationImporter", { enumerable: true, get: function () { return Importer_1.DocumentationImporter; } });
+var GitHubClient_1 = require("./services/GitHubClient");
+Object.defineProperty(exports, "GitHubClient", { enumerable: true, get: function () { return GitHubClient_1.GitHubClient; } });
+var Organizer_1 = require("./core/Organizer");
+Object.defineProperty(exports, "DocumentationOrganizer", { enumerable: true, get: function () { return Organizer_1.DocumentationOrganizer; } });
+// Configuration helpers
+var defaults_1 = require("./config/defaults");
+Object.defineProperty(exports, "createImportConfig", { enumerable: true, get: function () { return defaults_1.createImportConfig; } });
+Object.defineProperty(exports, "DEFAULT_IMPORT_CONFIG", { enumerable: true, get: function () { return defaults_1.DEFAULT_IMPORT_CONFIG; } });
+Object.defineProperty(exports, "IMPORT_PRESETS", { enumerable: true, get: function () { return defaults_1.IMPORT_PRESETS; } });

package/dist/features/documentation/services/ConfigApplier.d.ts

@@ -0,0 +1,11 @@
+import { DocumentationFolder, DocumentationFile } from "../types";
+import { GitHubClient } from "./GitHubClient";
+export declare class ConfigApplier {
+    static apply(root: DocumentationFolder, configFiles: DocumentationFile[], githubClient?: GitHubClient, owner?: string, repo?: string, branch?: string, rootPath?: string): Promise<void>;
+    /** Compare raw vs sanitized folder config and log warnings for dropped / invalid entries */
+    private static diffAndWarnFolderConfig;
+    private static diffAndWarnFileConfig;
+    private static fetchConfigFromGitHub;
+    private static applyFileConfigs;
+    private static findFolderByPath;
+}

package/dist/features/documentation/services/ConfigApplier.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigApplier = void 0;
+const config_1 = require("../config");
+class ConfigApplier {
+    static async apply(root, configFiles, githubClient, owner, repo, branch, rootPath) {
+        if (!configFiles.length)
+            return;
+        for (const cfgFile of configFiles) {
+            let folderPath = "";
+            if (cfgFile.path.endsWith("/config.json"))
+                folderPath = cfgFile.path.slice(0, -"/config.json".length);
+            const folder = folderPath
+                ? this.findFolderByPath(root, folderPath)
+                : root;
+            if (!folder)
+                continue;
+            try {
+                if (githubClient && owner && repo) {
+                    const customRaw = await this.fetchConfigFromGitHub(cfgFile, githubClient, owner, repo, branch, rootPath);
+                    const custom = (0, config_1.sanitizeFolderConfig)(customRaw);
+                    this.diffAndWarnFolderConfig(customRaw, custom, cfgFile.path);
+                    folder.config = { ...folder.config, ...custom };
+                    if (folder.config.files)
+                        this.applyFileConfigs(folder);
+                }
+            }
+            catch (e) {
+                console.warn(`Failed to apply config ${cfgFile.path}`, e);
+            }
+        }
+    }
+    /** Compare raw vs sanitized folder config and log warnings for dropped / invalid entries */
+    static diffAndWarnFolderConfig(raw, sanitized, sourcePath) {
+        if (!raw || typeof raw !== "object")
+            return;
+        const allowedSet = new Set(config_1.FOLDER_CONFIG_ALLOWED_KEYS);
+        for (const key of Object.keys(raw)) {
+            if (!allowedSet.has(key)) {
+                console.warn(`[ConfigApplier] Unknown folder config key '${key}' in ${sourcePath}. Allowed: ${config_1.FOLDER_CONFIG_ALLOWED_KEYS.join(", ")}`);
+            }
+        }
+        // File config diffs
+        if (raw.files && typeof raw.files === "object") {
+            for (const [fileBase, rawFile] of Object.entries(raw.files)) {
+                const sanitizedFile = sanitized.files?.[fileBase];
+                this.diffAndWarnFileConfig(rawFile, sanitizedFile || {}, sourcePath, fileBase);
+            }
+        }
+    }
+    static diffAndWarnFileConfig(raw, sanitized, sourcePath, fileBase) {
+        if (!raw || typeof raw !== "object")
+            return;
+        const allowedSet = new Set(config_1.FILE_CONFIG_ALLOWED_KEYS);
+        for (const key of Object.keys(raw)) {
+            if (!allowedSet.has(key)) {
+                console.warn(`[ConfigApplier] Unknown file config key '${key}' for '${fileBase}' in ${sourcePath}. Allowed: ${config_1.FILE_CONFIG_ALLOWED_KEYS.join(", ")}`);
+            }
+        }
+        // Basic type checks for known keys
+        if ("order" in raw && raw.order != null && typeof raw.order !== "number") {
+            console.warn(`[ConfigApplier] Invalid type for 'order' (expected number) in file '${fileBase}' (${sourcePath})`);
+        }
+        if ("icon" in raw && raw.icon != null && typeof raw.icon !== "string") {
+            console.warn(`[ConfigApplier] Invalid type for 'icon' (expected string) in file '${fileBase}' (${sourcePath})`);
+        }
+        if ("title" in raw && raw.title != null && typeof raw.title !== "string") {
+            console.warn(`[ConfigApplier] Invalid type for 'title' (expected string) in file '${fileBase}' (${sourcePath})`);
+        }
+        if ("locations" in raw &&
+            raw.locations != null &&
+            (!Array.isArray(raw.locations) ||
+                raw.locations.some((v) => typeof v !== "string"))) {
+            console.warn(`[ConfigApplier] Invalid type for 'locations' (expected string[]) in file '${fileBase}' (${sourcePath})`);
+        }
+    }
+    static async fetchConfigFromGitHub(cfgFile, githubClient, owner, repo, branch, rootPath) {
+        const normalizedRoot = rootPath?.replace(/^\/+/g, "").replace(/\/+$/g, "");
+        const fullPath = normalizedRoot
+            ? `${normalizedRoot}/${cfgFile.path}`
+            : cfgFile.path;
+        const fileContent = await githubClient.getFileContent(owner, repo, fullPath, branch);
+        const json = Buffer.from(fileContent.content, "base64").toString("utf-8");
+        return JSON.parse(json);
+    }
+    static applyFileConfigs(folder) {
+        if (!folder.config.files)
+            return;
+        for (const file of folder.files) {
+            const cfg = folder.config.files[file.name];
+            if (cfg) {
+                file.config = { ...config_1.DEFAULT_FILE_CONFIG, ...cfg };
+            }
+        }
+    }
+    static findFolderByPath(root, path) {
+        if (!path)
+            return root;
+        const parts = path.split("/").filter(Boolean);
+        let current = root;
+        for (const segment of parts) {
+            const next = current.subfolders.get(segment);
+            if (!next)
+                return null;
+            current = next;
+        }
+        return current;
+    }
+}
+exports.ConfigApplier = ConfigApplier;

package/dist/features/documentation/services/ContentLoader.d.ts

@@ -0,0 +1,6 @@
+import { DocumentationFile } from "../types";
+import { GitHubClient } from "./GitHubClient";
+export declare class ContentLoader {
+    private static readonly TEXT_EXTENSIONS;
+    static populate(files: DocumentationFile[], githubClient: GitHubClient, owner: string, repo: string, branch?: string, rootPath?: string): Promise<void>;
+}

package/dist/features/documentation/services/ContentLoader.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentLoader = void 0;
+class ContentLoader {
+    static async populate(files, githubClient, owner, repo, branch, rootPath) {
+        const candidates = files.filter((f) => this.TEXT_EXTENSIONS.has(f.extension));
+        if (!candidates.length)
+            return;
+        const normalizedRoot = rootPath?.replace(/^\/+/g, "").replace(/\/+$/g, "");
+        let fetched = 0;
+        for (const file of candidates) {
+            try {
+                const fullPath = normalizedRoot
+                    ? `${normalizedRoot}/${file.path}`
+                    : file.path;
+                const ghContent = await githubClient.getFileContent(owner, repo, fullPath, branch);
+                if (ghContent?.content) {
+                    file.content = Buffer.from(ghContent.content, "base64").toString("utf-8");
+                    fetched++;
+                }
+            }
+            catch (e) {
+                console.warn(`Failed to fetch content for ${file.path}:`, e);
+            }
+        }
+    }
+}
+exports.ContentLoader = ContentLoader;
+ContentLoader.TEXT_EXTENSIONS = new Set([
+    "md",
+    "markdown",
+    "txt",
+    "json",
+    "yml",
+    "yaml",
+    "html",
+    "css",
+    "ts",
+    "js",
+]);

package/dist/features/documentation/services/FeatureFilter.d.ts

@@ -0,0 +1,34 @@
+import { DocumentationFolder, DocumentationFile } from "../types";
+/**
+ * Feature-based filtering service for documentation
+ */
+export declare class FeatureFilter {
+    /**
+     * Filter folders and files based on their feature configuration
+     */
+    static filterByFeature(root: DocumentationFolder): DocumentationFolder;
+    /**
+     * Recursively filter a folder and its contents based on feature enablement
+     */
+    private static filterFolder;
+    /**
+     * Check if a folder has any content (files or non-empty subfolders)
+     */
+    private static hasContent;
+    /**
+     * Filter the flat file list to match the filtered folder structure
+     */
+    static filterFileList(files: DocumentationFile[], filteredRoot: DocumentationFolder): DocumentationFile[];
+    /**
+     * Recursively collect all allowed file paths from the filtered folder structure
+     */
+    private static collectAllowedPaths;
+    /**
+     * Count total files recursively in a folder structure
+     */
+    private static countTotalFiles;
+    /**
+     * Count total folders recursively in a folder structure
+     */
+    private static countTotalFolders;
+}

package/dist/features/documentation/services/FeatureFilter.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeatureFilter = void 0;
+const isFeatureEnabled_1 = require("../../config/helper/isFeatureEnabled");
+/**
+ * Feature-based filtering service for documentation
+ */
+class FeatureFilter {
+    /**
+     * Filter folders and files based on their feature configuration
+     */
+    static filterByFeature(root) {
+        console.log(`[FeatureFilter] Starting feature-based filtering for root folder: ${root.name}`);
+        const originalFileCount = this.countTotalFiles(root);
+        const originalFolderCount = this.countTotalFolders(root);
+        const filtered = this.filterFolder(root);
+        const filteredFileCount = this.countTotalFiles(filtered);
+        const filteredFolderCount = this.countTotalFolders(filtered);
+        console.log(`[FeatureFilter] Filtering complete:`, {
+            originalFiles: originalFileCount,
+            filteredFiles: filteredFileCount,
+            excludedFiles: originalFileCount - filteredFileCount,
+            originalFolders: originalFolderCount,
+            filteredFolders: filteredFolderCount,
+            excludedFolders: originalFolderCount - filteredFolderCount,
+        });
+        return filtered;
+    }
+    /**
+     * Recursively filter a folder and its contents based on feature enablement
+     */
+    static filterFolder(folder) {
+        const folderPath = folder.path || folder.name;
+        // Check if this folder should be excluded based on feature
+        if (folder.config.feature && !(0, isFeatureEnabled_1.isFeatureEnabled)(folder.config.feature)) {
+            console.log(`[FeatureFilter] Excluding folder '${folderPath}' (feature '${folder.config.feature}' is disabled)`);
+            // Return an empty folder structure to effectively exclude this folder
+            return {
+                ...folder,
+                files: [],
+                subfolders: new Map(),
+            };
+        }
+        const originalFileCount = folder.files.length;
+        const originalSubfolderCount = folder.subfolders.size;
+        // Filter files in this folder
+        const filteredFiles = folder.files.filter((file) => {
+            // If file has no feature config, include it
+            if (!file.config?.feature)
+                return true;
+            // If file has feature config, check if it's enabled
+            const isEnabled = (0, isFeatureEnabled_1.isFeatureEnabled)(file.config.feature);
+            if (!isEnabled) {
+                console.log(`[FeatureFilter] Excluding file '${file.path}' (feature '${file.config.feature}' is disabled)`);
+            }
+            return isEnabled;
+        });
+        // Recursively filter subfolders
+        const filteredSubfolders = new Map();
+        for (const [name, subfolder] of folder.subfolders) {
+            const filteredSubfolder = this.filterFolder(subfolder);
+            // Only include subfolders that have content after filtering
+            // or don't have a feature restriction
+            if (this.hasContent(filteredSubfolder) || !subfolder.config.feature) {
+                filteredSubfolders.set(name, filteredSubfolder);
+            }
+            else {
+                console.log(`[FeatureFilter] Removing empty subfolder '${subfolder.path || subfolder.name}' after filtering`);
+            }
+        }
+        const excludedFiles = originalFileCount - filteredFiles.length;
+        const excludedSubfolders = originalSubfolderCount - filteredSubfolders.size;
+        if (excludedFiles > 0 || excludedSubfolders > 0) {
+            console.log(`[FeatureFilter] Filtered folder '${folderPath}':`, {
+                excludedFiles,
+                excludedSubfolders,
+                remainingFiles: filteredFiles.length,
+                remainingSubfolders: filteredSubfolders.size,
+            });
+        }
+        return {
+            ...folder,
+            files: filteredFiles,
+            subfolders: filteredSubfolders,
+        };
+    }
+    /**
+     * Check if a folder has any content (files or non-empty subfolders)
+     */
+    static hasContent(folder) {
+        // Has files
+        if (folder.files.length > 0)
+            return true;
+        // Has non-empty subfolders
+        for (const subfolder of folder.subfolders.values()) {
+            if (this.hasContent(subfolder))
+                return true;
+        }
+        return false;
+    }
+    /**
+     * Filter the flat file list to match the filtered folder structure
+     */
+    static filterFileList(files, filteredRoot) {
+        console.log(`[FeatureFilter] Filtering file list: ${files.length} total files`);
+        const allowedPaths = new Set();
+        this.collectAllowedPaths(filteredRoot, "", allowedPaths);
+        console.log(`[FeatureFilter] Collected ${allowedPaths.size} allowed file paths`);
+        const filteredFiles = files.filter((file) => allowedPaths.has(file.path));
+        const excludedCount = files.length - filteredFiles.length;
+        if (excludedCount > 0) {
+            console.log(`[FeatureFilter] File list filtering complete: ${excludedCount} files excluded, ${filteredFiles.length} files remaining`);
+        }
+        else {
+            console.log(`[FeatureFilter] File list filtering complete: no files excluded`);
+        }
+        return filteredFiles;
+    }
+    /**
+     * Recursively collect all allowed file paths from the filtered folder structure
+     */
+    static collectAllowedPaths(folder, currentPath, allowedPaths) {
+        // Add all files in this folder
+        for (const file of folder.files) {
+            allowedPaths.add(file.path);
+        }
+        // Recursively process subfolders
+        for (const [name, subfolder] of folder.subfolders) {
+            const subfolderPath = currentPath ? `${currentPath}/${name}` : name;
+            this.collectAllowedPaths(subfolder, subfolderPath, allowedPaths);
+        }
+    }
+    /**
+     * Count total files recursively in a folder structure
+     */
+    static countTotalFiles(folder) {
+        let count = folder.files.length;
+        for (const subfolder of folder.subfolders.values()) {
+            count += this.countTotalFiles(subfolder);
+        }
+        return count;
+    }
+    /**
+     * Count total folders recursively in a folder structure
+     */
+    static countTotalFolders(folder) {
+        let count = folder.subfolders.size;
+        for (const subfolder of folder.subfolders.values()) {
+            count += this.countTotalFolders(subfolder);
+        }
+        return count;
+    }
+}
+exports.FeatureFilter = FeatureFilter;

package/dist/features/documentation/services/GitHubClient.d.ts

@@ -0,0 +1,43 @@
+import { GitHubTreeResponse, GitHubBranch, GitHubRepository } from "../types";
+/**
+ * GitHub API Client for fetching repository data
+ */
+export declare class GitHubClient {
+    private readonly baseUrl;
+    private readonly headers;
+    constructor(token: string);
+    /**
+     * Validate the GitHub token
+     */
+    validateToken(): Promise<{
+        login: string;
+    }>;
+    /**
+     * Get repository information
+     */
+    getRepository(owner: string, repo: string): Promise<GitHubRepository>;
+    /**
+     * Get all branches for a repository
+     */
+    getBranches(owner: string, repo: string): Promise<GitHubBranch[]>;
+    /**
+     * Get a specific branch
+     */
+    getBranch(owner: string, repo: string, branch: string): Promise<GitHubBranch>;
+    /**
+     * Get repository tree (file structure)
+     */
+    getTree(owner: string, repo: string, sha: string, recursive?: boolean): Promise<GitHubTreeResponse>;
+    /**
+     * Get file content
+     */
+    getFileContent(owner: string, repo: string, path: string, ref?: string): Promise<any>;
+    /**
+     * Get the last commit information for a specific file
+     */
+    getFileLastCommit(owner: string, repo: string, path: string, ref?: string): Promise<any>;
+    /**
+     * Get commit information for multiple files in batch
+     */
+    getMultipleFileCommits(owner: string, repo: string, paths: string[], ref?: string): Promise<Map<string, any>>;
+}