codefeed/readme.md

```markdown
# @foss.global/codefeed

A module for creating feeds for code development.

## Install

To install the `@foss.global/codefeed` package, you can run the following npm command in your project directory:

```bash
npm install @foss.global/codefeed
```

Ensure that you have a compatible version of Node.js installed and that your project is set up to support ECMAScript modules. The `@foss.global/codefeed` module uses ESM syntax.

## Usage

The `@foss.global/codefeed` package is designed to help developers generate feeds for code developments, specifically targeting Gitea repositories. It fetches and processes commit data, changelogs, and repository activities for further analysis or visualization. Here, we'll delve into how you can utilize the different features of the `CodeFeed` class.

### Setting Up CodeFeed

To get started, import the `CodeFeed` class from the module:

```typescript
import { CodeFeed } from '@foss.global/codefeed';
```

Then, create an instance of `CodeFeed`. You'll need the base URL of your Gitea instance and optionally an API token if your repositories require authentication.

```typescript
// default: fetch commits since 7 days ago, no caching or npm checks, include all commits
const codeFeed = new CodeFeed(
  'https://your-gitea-instance-url.com',
  'your-api-token'
);
// with options: cache commits in-memory for 30 days, disable npm lookups, return only tagged commits
const thirtyDays = 30 * 24 * 60 * 60 * 1000;
const codeFeedStateful = new CodeFeed(
  'https://your-gitea-instance-url.com',
  'your-api-token',
  undefined, // defaults to 7 days ago
  {
    enableCache: true,
    cacheWindowMs: thirtyDays,
    enableNpmCheck: false,
    taggedOnly: true,
  }
);
```

The constructor can also accept a `lastRunTimestamp` which indicates the last time a sync was performed. If not provided, it defaults to one week (7 days) prior to the current time.

### Fetching Commits

One of the core functionalities of CodeFeed is fetching commits from a Gitea instance. By calling `fetchAllCommitsFromInstance`, you can retrieve commits across multiple repositories:

```typescript
(async () => {
  try {
    const commits = await codeFeed.fetchAllCommitsFromInstance();
    console.log(commits);
  } catch (error) {
    console.error('An error occurred while fetching commits:', error);
  }
})();
```

This method scans all organizations and repositories, fetches all commits since the constructor’s `lastRunTimestamp` (default: one week ago), and enriches them with metadata like:
- Git tags (to detect releases)
- npm publication status (when enabled)
- parsed changelog entries (when available)

When `taggedOnly` is enabled, only commits marked as release tags are returned. When `enableCache` is enabled, previously fetched commits are kept in memory (up to `cacheWindowMs`), and only new commits are fetched on subsequent calls.

Each commit object in the resulting array conforms to the `ICommitResult` interface, containing details such as:
- `baseUrl`
- `org`
- `repo`
- `timestamp`
- `hash`
- `commitMessage`
- `tagged` (boolean)
- `publishedOnNpm` (boolean)
- `prettyAgoTime` (human-readable relative time)
- `changelog` (text from the `changelog.md` associated with a commit)

### Understanding the Data Fetch Process

#### Fetching Organizations

The `fetchAllOrganizations` method collects all organizations within the Gitea instance:

```typescript
const organizations = await codeFeed.fetchAllOrganizations();
console.log('Organizations:', organizations);
```

This method interacts with the Gitea API to pull organization names, aiding further requests that require organization context.

#### Fetching Repositories

Repositories under these organizations can be retrieved using `fetchAllRepositories`:

```typescript
const repositories = await codeFeed.fetchAllRepositories();
console.log('Repositories:', repositories);
```

Here, filtering by organization can help narrow down the scope further when dealing with large instances.

#### Fetching Tags and Commits

To handle repository-specific details, use:

- `fetchTags(owner: string, repo: string)`: Appropriately handles paginated tag data within a repository.
  
- `fetchRecentCommitsForRepo(owner: string, repo: string)`: Gathers commit data specific to the past 24 hours for a given repository.

```typescript
const tags = await codeFeed.fetchTags('orgName', 'repoName');
const recentCommits = await codeFeed.fetchRecentCommitsForRepo('orgName', 'repoName');

console.log('Tags:', tags);
console.log('Recent Commits:', recentCommits);
```

### Changelog Integration

Loading changelog content from a repository is integrated into the flow with `loadChangelogFromRepo`. This can be accessed when processing specific commits:

```typescript
await codeFeed.loadChangelogFromRepo('org', 'repo');
const changelog = codeFeed.getChangelogForVersion('1.0.0');
console.log('Changelog for version 1.0.0:', changelog);
```

### Conclusion

The `@foss.global/codefeed` module provides robust capabilities for extracting and managing feed data related to code developments in Gitea environments. Through systematic setup and leveraging API-driven methods, it becomes a valuable tool for developers aiming to keep track of software progress and changes efficiently. The integration hooks like changelog and npm verification further enrich its utility, offering consolidated insights into each commit's journey from codebase to published package.

Explore integrating these capabilities into your development workflows to enhance tracking, deployment pipelines, or analytics systems within your projects. Remember to always handle API tokens securely and adhere to best practices when managing access to repository resources. Stay updated on any changes or enhancements to this module for further feature exposures or bug fixes. Happy coding!
```
undefined