@foss.global/codefeed 1.8.0 → 1.10.0

package/dist_ts/classes.gitmanagerpublicclient.js

@@ -0,0 +1,648 @@
+import * as plugins from './plugins.js';
+export class GitManagerPublicReadClient {
+    constructor(optionsArg) {
+        if (!optionsArg.allowAllRepositories && !optionsArg.isRepositoryPublic) {
+            throw new Error('GitManagerPublicReadClient requires allowAllRepositories or an authoritative isRepositoryPublic predicate');
+        }
+        this.gitManager = optionsArg.gitManager;
+        this.publicBaseUrl = this.normalizeBaseUrl(optionsArg.publicBaseUrl ?? 'https://foss.global', ['http:', 'https:']);
+        this.smartHttpBaseUrl = this.normalizeBaseUrl(optionsArg.smartHttpBaseUrl ?? this.publicBaseUrl, ['http:', 'https:']);
+        this.sshBaseUrl = this.normalizeBaseUrl(optionsArg.sshBaseUrl ?? 'ssh://git@code.foss.global:29419', ['ssh:']);
+        this.allowAllRepositories = optionsArg.allowAllRepositories ?? false;
+        this.isRepositoryPublic = optionsArg.isRepositoryPublic;
+        this.organizationMetadata = optionsArg.organizationMetadata;
+        this.repositoryMetadata = optionsArg.repositoryMetadata;
+        this.newsProvider = optionsArg.newsProvider;
+        this.maxCommits = this.validateLimit(optionsArg.maxCommits ?? 40, 'maxCommits', 1, 1000);
+        this.maxReleases = this.validateLimit(optionsArg.maxReleases ?? 50, 'maxReleases', 1, 1000);
+        this.maxLanguageFiles = this.validateLimit(optionsArg.maxLanguageFiles ?? 1000, 'maxLanguageFiles', 1, 10_000);
+        this.maxConcurrency = this.validateLimit(optionsArg.maxConcurrency ?? 8, 'maxConcurrency', 1, 32);
+    }
+    async getOverview(queryArg = '') {
+        const query = queryArg.trim().toLowerCase();
+        if (query.length > 160) {
+            throw new Error('Query exceeds maximum length of 160');
+        }
+        const repositoryInfos = await this.listVisibleRepositories();
+        const filteredInfos = query
+            ? repositoryInfos.filter((repository) => `${repository.org}/${repository.repo}`.toLowerCase().includes(query))
+            : repositoryInfos;
+        const repos = await this.mapWithConcurrency(filteredInfos.slice(0, query ? 100 : 36), (repository) => this.mapRepository(repository));
+        const orgs = await this.mapOrganizations(repositoryInfos);
+        const commitFeed = await this.getCommitFeed(filteredInfos.slice(0, 12), 3);
+        const activity = commitFeed.slice(0, 24).map((commit) => this.mapActivity(commit));
+        const news = query ? [] : ((await this.newsProvider?.(6)) ?? []);
+        return {
+            orgs: query
+                ? orgs.filter((org) => org.name.toLowerCase().includes(query))
+                : orgs,
+            repos,
+            activity,
+            commitFeed,
+            news,
+            stats: this.getStats(orgs, repos),
+        };
+    }
+    async getOrg(orgArg) {
+        const org = this.validateSlug(orgArg, 'organization', 120);
+        const repositoryInfos = (await this.listVisibleRepositories()).filter((repository) => repository.org === org);
+        if (repositoryInfos.length === 0) {
+            return {
+                org: null,
+                repos: [],
+                members: [],
+                activity: [],
+                commitFeed: [],
+                stats: {
+                    orgCount: 0,
+                    repoCount: 0,
+                    releaseCount: 0,
+                    openIssueCount: 0,
+                },
+            };
+        }
+        const repos = await this.mapWithConcurrency(repositoryInfos, (repository) => this.mapRepository(repository));
+        const [mappedOrg] = await this.mapOrganizations(repositoryInfos, [org]);
+        const commitFeed = await this.getCommitFeed(repositoryInfos.slice(0, 12), 3);
+        const activity = commitFeed.slice(0, 24).map((commit) => this.mapActivity(commit));
+        return {
+            org: mappedOrg ?? null,
+            repos,
+            members: [],
+            activity,
+            commitFeed,
+            stats: this.getStats(mappedOrg ? [mappedOrg] : [], repos),
+        };
+    }
+    async getRepo(orgArg, repoArg, pathArg = '', _issueNumberArg = 0) {
+        const repository = await this.findVisibleRepository(orgArg, repoArg);
+        if (!repository) {
+            return {
+                repo: null,
+                contents: [],
+                readme: '',
+                releases: [],
+                activity: [],
+                issues: [],
+                selectedIssue: null,
+                selectedIssueComments: [],
+                commits: [],
+                languages: {},
+            };
+        }
+        const path = this.validatePath(pathArg);
+        const [tree, readme, tags, commitSummaries, languages] = await Promise.all([
+            this.withFallback(() => this.gitManager.listTree({
+                org: repository.org,
+                repo: repository.repo,
+                ref: repository.defaultBranch,
+                path: path || undefined,
+            }), []),
+            path ? Promise.resolve('') : this.readReadme(repository),
+            this.withFallback(() => this.gitManager.listTags({
+                org: repository.org,
+                repo: repository.repo,
+                limit: this.maxReleases,
+            }), []),
+            this.withFallback(() => this.gitManager.listCommits({
+                org: repository.org,
+                repo: repository.repo,
+                ref: repository.defaultBranch,
+                limit: Math.min(this.maxCommits, 12),
+            }), []),
+            this.scanLanguages(repository),
+        ]);
+        const commits = commitSummaries.map((commit) => this.mapCommit(commit));
+        const latestCommit = commits[0];
+        const releases = tags.map((tag) => this.mapRelease(repository, tag));
+        const repo = await this.mapRepository(repository);
+        repo.releaseCount = releases.length;
+        repo.language = this.getPrimaryLanguage(languages);
+        return {
+            repo,
+            contents: tree
+                .filter((entry) => entry.entryType !== 'other')
+                .map((entry) => this.mapContent(repository, entry, latestCommit)),
+            readme,
+            releases,
+            activity: commits.map((commit) => this.mapActivity(commit)),
+            issues: [],
+            selectedIssue: null,
+            selectedIssueComments: [],
+            commits,
+            languages,
+        };
+    }
+    async getFile(orgArg, repoArg, pathArg) {
+        const repository = await this.findVisibleRepository(orgArg, repoArg);
+        if (!repository) {
+            return { repo: null, file: null, activity: [], commits: [] };
+        }
+        const path = this.validatePath(pathArg, false);
+        const [file, commitSummaries, repo] = await Promise.all([
+            this.withFallback(() => this.gitManager.readFile({
+                org: repository.org,
+                repo: repository.repo,
+                ref: repository.defaultBranch,
+                path,
+            }), null),
+            this.withFallback(() => this.gitManager.listCommits({
+                org: repository.org,
+                repo: repository.repo,
+                ref: repository.defaultBranch,
+                limit: Math.min(this.maxCommits, 8),
+            }), []),
+            this.mapRepository(repository),
+        ]);
+        const commits = commitSummaries.map((commit) => this.mapCommit(commit));
+        return {
+            repo,
+            file: file
+                ? {
+                    path: file.path,
+                    name: file.path.split('/').pop() ?? file.path,
+                    size: file.size,
+                    htmlUrl: this.repoPathUrl(repository, `src/${repository.defaultBranch}/${file.path}`),
+                    downloadUrl: '',
+                    content: file.isBinary
+                        ? ''
+                        : Buffer.from(file.contentBase64, 'base64').toString('utf8'),
+                    isBinary: file.isBinary,
+                    truncated: false,
+                }
+                : null,
+            activity: commits.map((commit) => this.mapActivity(commit)),
+            commits,
+        };
+    }
+    async getCommits(orgArg, repoArg, shaArg = '') {
+        const repository = await this.findVisibleRepository(orgArg, repoArg);
+        if (!repository) {
+            return { repo: null, commits: [], selectedCommit: null };
+        }
+        const sha = shaArg.trim();
+        if (sha && !/^[0-9a-fA-F]{40,64}$/.test(sha)) {
+            throw new Error('Invalid commit SHA');
+        }
+        const [repo, commitSummaries, selectedCommit] = await Promise.all([
+            this.mapRepository(repository),
+            this.withFallback(() => this.gitManager.listCommits({
+                org: repository.org,
+                repo: repository.repo,
+                ref: repository.defaultBranch,
+                limit: this.maxCommits,
+            }), []),
+            sha
+                ? this.withFallback(() => this.getCommitDetail(repository, sha), null)
+                : Promise.resolve(null),
+        ]);
+        return {
+            repo,
+            commits: commitSummaries.map((commit) => this.mapCommit(commit)),
+            selectedCommit,
+        };
+    }
+    async listVisibleRepositories() {
+        const repositories = await this.gitManager.listRepositories();
+        if (this.allowAllRepositories) {
+            return repositories;
+        }
+        const visibility = await this.mapWithConcurrency(repositories, async (repository) => ({
+            repository,
+            visible: await this.isRepositoryPublic(repository),
+        }));
+        return visibility
+            .filter((entry) => entry.visible)
+            .map((entry) => entry.repository);
+    }
+    async findVisibleRepository(orgArg, repoArg) {
+        const org = this.validateSlug(orgArg, 'organization', 120);
+        const repo = this.validateSlug(repoArg, 'repository', 160);
+        return (await this.listVisibleRepositories()).find((repository) => repository.org === org && repository.repo === repo);
+    }
+    async mapOrganizations(repositoriesArg, explicitOrgsArg) {
+        const orgNames = explicitOrgsArg
+            ?? [...new Set(repositoriesArg.map((repository) => repository.org))];
+        const orgs = await this.mapWithConcurrency(orgNames, async (name) => {
+            const repositories = repositoriesArg.filter((repository) => repository.org === name);
+            const metadata = await this.organizationMetadata?.(name);
+            const base = {
+                name,
+                fullName: name,
+                description: '',
+                website: '',
+                location: '',
+                avatarUrl: '',
+                htmlUrl: `${this.publicBaseUrl}/${name}`,
+                repoCount: repositories.length,
+                starsCount: 0,
+                memberCount: 0,
+                languages: {},
+            };
+            return {
+                ...base,
+                ...metadata,
+                name,
+                repoCount: repositories.length,
+            };
+        });
+        return orgs.sort((orgA, orgB) => orgA.name.localeCompare(orgB.name));
+    }
+    async mapRepository(repositoryArg) {
+        const [latestCommit] = await this.withFallback(() => this.gitManager.listCommits({
+            org: repositoryArg.org,
+            repo: repositoryArg.repo,
+            ref: repositoryArg.defaultBranch,
+            limit: 1,
+        }), []);
+        const metadata = await this.repositoryMetadata?.(repositoryArg);
+        const slug = `${repositoryArg.org}/${repositoryArg.repo}`;
+        const base = {
+            id: this.stableId(slug),
+            org: repositoryArg.org,
+            name: repositoryArg.repo,
+            slug,
+            orgAvatarUrl: '',
+            description: '',
+            language: '',
+            htmlUrl: `${this.publicBaseUrl}/${slug}`,
+            cloneUrl: `${this.smartHttpBaseUrl}/${slug}.git`,
+            sshUrl: `${this.sshBaseUrl}/${slug}.git`,
+            starsCount: 0,
+            forksCount: 0,
+            watchersCount: 0,
+            openIssuesCount: 0,
+            openPrCount: 0,
+            releaseCount: 0,
+            size: 0,
+            defaultBranch: repositoryArg.defaultBranch,
+            updatedAt: latestCommit?.createdAt ?? '',
+            createdAt: latestCommit?.createdAt ?? '',
+            archived: false,
+            topics: [],
+        };
+        return {
+            ...base,
+            ...metadata,
+            id: this.stableId(slug),
+            org: repositoryArg.org,
+            name: repositoryArg.repo,
+            slug,
+            defaultBranch: repositoryArg.defaultBranch,
+        };
+    }
+    async getCommitFeed(repositoriesArg, perRepositoryLimitArg) {
+        const groups = await this.mapWithConcurrency(repositoriesArg, async (repository) => {
+            const commits = await this.withFallback(() => this.gitManager.listCommits({
+                org: repository.org,
+                repo: repository.repo,
+                ref: repository.defaultBranch,
+                limit: Math.min(this.maxCommits, perRepositoryLimitArg),
+            }), []);
+            return commits.map((commit) => this.mapCommit(commit));
+        });
+        return groups
+            .flat()
+            .sort((commitA, commitB) => commitB.createdAt.localeCompare(commitA.createdAt))
+            .slice(0, this.maxCommits);
+    }
+    mapCommit(commitArg) {
+        return {
+            sha: commitArg.sha,
+            shortSha: commitArg.shortSha,
+            message: commitArg.subject,
+            title: commitArg.subject,
+            body: '',
+            htmlUrl: this.repoPathUrl({ org: commitArg.org, repo: commitArg.repo }, `commit/${commitArg.sha}`),
+            createdAt: commitArg.createdAt,
+            authorName: commitArg.authorName,
+            authorLogin: '',
+            authorAvatarUrl: '',
+            repoSlug: `${commitArg.org}/${commitArg.repo}`,
+            files: [],
+            additions: 0,
+            deletions: 0,
+            verified: false,
+            kind: this.getActivityKind(commitArg.subject),
+        };
+    }
+    async getCommitDetail(repositoryArg, shaArg) {
+        const [commit, diff] = await Promise.all([
+            this.gitManager.getCommit({
+                org: repositoryArg.org,
+                repo: repositoryArg.repo,
+                ref: shaArg,
+            }),
+            this.gitManager.getDiff({
+                org: repositoryArg.org,
+                repo: repositoryArg.repo,
+                headRef: shaArg,
+            }),
+        ]);
+        return {
+            sha: commit.sha,
+            shortSha: commit.shortSha,
+            message: commit.message,
+            title: commit.subject,
+            body: commit.body,
+            htmlUrl: this.repoPathUrl(repositoryArg, `commit/${commit.sha}`),
+            createdAt: commit.createdAt,
+            authorName: commit.author.name,
+            authorLogin: '',
+            authorAvatarUrl: '',
+            verified: false,
+            parents: commit.parents.map((parent) => parent.sha),
+            additions: diff.additions,
+            deletions: diff.deletions,
+            files: diff.files.map((file) => ({
+                path: file.newPath || file.oldPath,
+                previousPath: file.oldPath,
+                status: this.mapDiffStatus(file.status),
+                language: this.languageForPath(file.newPath || file.oldPath),
+                additions: file.additions,
+                deletions: file.deletions,
+                isBinary: file.isBinary,
+                hunks: file.hunks.map((hunk) => ({
+                    header: hunk.header,
+                    lines: hunk.lines.map((line) => ({
+                        kind: line.kind,
+                        content: line.content,
+                        oldNumber: line.oldNumber,
+                        newNumber: line.newNumber,
+                    })),
+                })),
+            })),
+            diffTruncated: diff.truncated,
+        };
+    }
+    mapContent(repositoryArg, entryArg, latestCommitArg) {
+        const type = entryArg.entryType === 'other' ? 'file' : entryArg.entryType;
+        return {
+            name: entryArg.name,
+            path: entryArg.path,
+            type,
+            size: entryArg.size ?? 0,
+            htmlUrl: this.repoPathUrl(repositoryArg, `src/${repositoryArg.defaultBranch}/${entryArg.path}`),
+            downloadUrl: '',
+            lastCommitSha: latestCommitArg?.sha ?? '',
+            lastAuthorDate: latestCommitArg?.createdAt ?? '',
+            lastCommitMessage: latestCommitArg?.title ?? '',
+        };
+    }
+    mapRelease(repositoryArg, tagArg) {
+        return {
+            tagName: tagArg.name,
+            name: tagArg.subject || tagArg.name,
+            body: tagArg.message,
+            htmlUrl: this.repoPathUrl(repositoryArg, `releases/tag/${tagArg.name}`),
+            publishedAt: tagArg.taggedAt,
+            prerelease: /(?:^|[-.])(alpha|beta|rc)(?:[-.]|$)/i.test(tagArg.name),
+            draft: false,
+            author: {
+                login: '',
+                fullName: tagArg.taggerName,
+                description: '',
+                website: '',
+                location: '',
+                avatarUrl: '',
+                htmlUrl: '',
+                createdAt: '',
+            },
+            assets: [],
+        };
+    }
+    mapActivity(commitArg) {
+        return {
+            id: commitArg.sha,
+            org: commitArg.repoSlug.split('/')[0] ?? '',
+            repo: commitArg.repoSlug.split('/')[1] ?? '',
+            repoSlug: commitArg.repoSlug,
+            tagName: '',
+            version: '',
+            kind: commitArg.kind,
+            title: commitArg.title,
+            body: commitArg.body,
+            createdAt: commitArg.createdAt,
+        };
+    }
+    async readReadme(repositoryArg) {
+        for (const path of ['README.md', 'readme.md', 'Readme.md']) {
+            try {
+                const file = await this.gitManager.readFile({
+                    org: repositoryArg.org,
+                    repo: repositoryArg.repo,
+                    ref: repositoryArg.defaultBranch,
+                    path,
+                });
+                if (!file.isBinary) {
+                    return Buffer.from(file.contentBase64, 'base64').toString('utf8');
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return '';
+    }
+    async scanLanguages(repositoryArg) {
+        const languages = {};
+        const pendingPaths = [''];
+        let fileCount = 0;
+        let scannedEntryCount = 0;
+        while (pendingPaths.length > 0 && scannedEntryCount < this.maxLanguageFiles) {
+            const path = pendingPaths.shift();
+            const entries = await this.withFallback(() => this.gitManager.listTree({
+                org: repositoryArg.org,
+                repo: repositoryArg.repo,
+                ref: repositoryArg.defaultBranch,
+                path: path || undefined,
+            }), []);
+            for (const entry of entries) {
+                if (scannedEntryCount >= this.maxLanguageFiles) {
+                    break;
+                }
+                scannedEntryCount += 1;
+                if (entry.entryType === 'dir') {
+                    if (entry.path.split('/').length <= 20) {
+                        pendingPaths.push(entry.path);
+                    }
+                    continue;
+                }
+                if (entry.entryType !== 'file' || fileCount >= this.maxLanguageFiles) {
+                    continue;
+                }
+                fileCount += 1;
+                const language = this.languageForPath(entry.path);
+                languages[language] = (languages[language] ?? 0) + (entry.size ?? 0);
+            }
+        }
+        return languages;
+    }
+    getStats(orgsArg, reposArg) {
+        return {
+            orgCount: orgsArg.length,
+            repoCount: reposArg.length,
+            releaseCount: reposArg.reduce((sum, repo) => sum + repo.releaseCount, 0),
+            openIssueCount: reposArg.reduce((sum, repo) => sum + repo.openIssuesCount, 0),
+        };
+    }
+    getPrimaryLanguage(languagesArg) {
+        return Object.entries(languagesArg)
+            .sort((entryA, entryB) => entryB[1] - entryA[1] || entryA[0].localeCompare(entryB[0]))[0]?.[0] ?? '';
+    }
+    languageForPath(pathArg) {
+        const extension = pathArg.toLowerCase().split('.').pop() ?? '';
+        const languages = {
+            ts: 'TypeScript',
+            tsx: 'TypeScript',
+            js: 'JavaScript',
+            jsx: 'JavaScript',
+            mjs: 'JavaScript',
+            cjs: 'JavaScript',
+            rs: 'Rust',
+            go: 'Go',
+            py: 'Python',
+            java: 'Java',
+            kt: 'Kotlin',
+            rb: 'Ruby',
+            php: 'PHP',
+            c: 'C',
+            h: 'C',
+            cc: 'C++',
+            cpp: 'C++',
+            hpp: 'C++',
+            cs: 'C#',
+            swift: 'Swift',
+            sh: 'Shell',
+            bash: 'Shell',
+            zsh: 'Shell',
+            html: 'HTML',
+            css: 'CSS',
+            scss: 'SCSS',
+            vue: 'Vue',
+            svelte: 'Svelte',
+        };
+        return languages[extension] ?? 'Other';
+    }
+    getActivityKind(messageArg) {
+        const prefix = messageArg.trim().toLowerCase().match(/^([a-z]+)(?:\([^)]*\))?[!:]/)?.[1];
+        switch (prefix) {
+            case 'feat':
+            case 'fix':
+            case 'perf':
+            case 'docs':
+            case 'test':
+            case 'refactor':
+            case 'build':
+            case 'ci':
+            case 'chore':
+                return prefix;
+            case 'release':
+            case 'rel':
+                return 'rel';
+            default:
+                return 'code';
+        }
+    }
+    mapDiffStatus(statusArg) {
+        switch (statusArg) {
+            case 'added':
+            case 'deleted':
+            case 'renamed':
+                return statusArg;
+            default:
+                return 'modified';
+        }
+    }
+    repoPathUrl(repositoryArg, suffixArg) {
+        const encodedSuffix = suffixArg
+            .split('/')
+            .map((segment) => encodeURIComponent(segment))
+            .join('/');
+        return `${this.publicBaseUrl}/${repositoryArg.org}/${repositoryArg.repo}/${encodedSuffix}`;
+    }
+    stableId(valueArg) {
+        let hash = 2166136261;
+        for (const char of valueArg) {
+            hash ^= char.charCodeAt(0);
+            hash = Math.imul(hash, 16777619);
+        }
+        return hash >>> 0;
+    }
+    normalizeBaseUrl(valueArg, allowedProtocolsArg) {
+        const value = valueArg.trim().replace(/\/+$/, '');
+        if (!value
+            || value.length > 2048
+            || /[\u0000-\u0020\u007f]/.test(value)) {
+            throw new Error('Invalid base URL');
+        }
+        let parsed;
+        try {
+            parsed = new URL(value);
+        }
+        catch {
+            throw new Error('Invalid base URL');
+        }
+        if (!allowedProtocolsArg.includes(parsed.protocol)
+            || parsed.password
+            || parsed.search
+            || parsed.hash) {
+            throw new Error('Invalid base URL');
+        }
+        return value;
+    }
+    validateSlug(valueArg, labelArg, maxLengthArg) {
+        const value = valueArg.trim();
+        if (!value
+            || value.length > maxLengthArg
+            || value === '.'
+            || value === '..'
+            || !/^[A-Za-z0-9._-]+$/.test(value)) {
+            throw new Error(`Invalid ${labelArg}`);
+        }
+        return value;
+    }
+    validatePath(valueArg, allowEmptyArg = true) {
+        const path = valueArg.trim().replace(/^\/+|\/+$/g, '');
+        if (!path) {
+            if (allowEmptyArg) {
+                return '';
+            }
+            throw new Error('Path is required');
+        }
+        if (path.length > 500
+            || path.includes('\\')
+            || path.split('/').some((segment) => !segment || segment === '.' || segment === '..')) {
+            throw new Error('Invalid path');
+        }
+        return path;
+    }
+    validateLimit(valueArg, labelArg, minimumArg, maximumArg) {
+        if (!Number.isSafeInteger(valueArg) || valueArg < minimumArg || valueArg > maximumArg) {
+            throw new Error(`${labelArg} must be an integer between ${minimumArg} and ${maximumArg}`);
+        }
+        return valueArg;
+    }
+    async withFallback(operationArg, fallbackArg) {
+        try {
+            return await operationArg();
+        }
+        catch {
+            return fallbackArg;
+        }
+    }
+    async mapWithConcurrency(itemsArg, mapperArg) {
+        const results = new Array(itemsArg.length);
+        let nextIndex = 0;
+        const workers = Array.from({ length: Math.min(this.maxConcurrency, itemsArg.length) }, async () => {
+            while (nextIndex < itemsArg.length) {
+                const index = nextIndex;
+                nextIndex += 1;
+                results[index] = await mapperArg(itemsArg[index]);
+            }
+        });
+        await Promise.all(workers);
+        return results;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.gitmanagerpublicclient.js","sourceRoot":"","sources":["../ts/classes.gitmanagerpublicclient.ts"],"names":[],"mappings":"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"}