RDF Utils Development Agent

Expert AI agent for developing and maintaining the rdf-utils TypeScript library, a resource management package built with the Bun runtime.

What This Agent Does

This agent provides specialized guidance for working with the rdf-utils repository, including:

Instructions

Development Commands

When working with this repository, use these standard commands:

**Building the project:**

**Testing:**

Architecture Guidelines

Understanding the project structure:

1. **Entry Point**: `src/index.ts` contains main module exports

2. **Source Structure**: Flat directory structure in `src/`

3. **Test Organization**:

- Unit tests: `test/*.test.ts`

- Integration tests: `test/integration/` (requires external services)

4. **Build Output**: `dist/` directory with declarations and source maps

5. **Target Environment**: Node.js with ES2022 features, ESNext modules

Code Style Requirements

Follow these conventions when writing code:

1. **TypeScript Configuration**:

- Strict mode enabled

- ES2022 target

- ESNext module format

2. **Import Conventions**:

- Relative imports within src: `./filename`

- Absolute imports for external packages

3. **Naming Conventions**:

- camelCase for functions and variables

- PascalCase for types and interfaces

4. **Documentation**:

- Add JSDoc comments for all exported functions

- Include @param and @returns tags

5. **Error Handling**:

- Use standard TypeScript error patterns

6. **Testing**:

- Use Bun's built-in test runner

- Write descriptive test names

- Aim for comprehensive test coverage

Git Workflow

**Branch Management:**

**Worktree Synchronization:**

When asked to "sync worktrees", follow this efficient process to minimize tool calls (target: ~5 tool calls instead of ~40):

**Step 1: Pre-flight Validation**

Before starting rebase, validate:

**Step 2: Conflict Analysis (1 tool call)**

```bash

git status --porcelain | grep "^UU\|^AA\|^DD"

```

**Step 3: Smart Conflict Resolution Patterns**

Apply these standard patterns immediately:

**Step 4: Batch Operations (1-2 tool calls)**

**Step 5: Parallel Validation (1 tool call)**

```bash

bun run build & bun test

```

**Step 6: Atomic Resolution (1 tool call)**

Rebase Process

When performing the rebase against main:

1. Commit outstanding changes on current branch

2. Perform efficient manual rebase against `main` branch only

3. Do not touch any other branches

4. Apply batched conflict resolution strategies

5. There is no remote repository to push to

Best Practices

1. **Minimize Tool Calls**: Use batch operations and intelligent pattern matching

2. **Test Before Commit**: Always validate build and tests before finalizing sync

3. **Document Changes**: Write clear commit messages during worktree sync

4. **Follow Conventions**: Strictly adhere to the established code style

5. **Comprehensive Testing**: Ensure test coverage for all new functionality

Example Workflows

**Adding a new feature:**

1. Write implementation in `src/`

2. Add corresponding tests in `test/`

3. Export new functionality from `src/index.ts`

4. Run `bun test` to validate

5. Run `bun run build` to ensure compilation succeeds

**Fixing a bug:**

1. Write failing test that reproduces the bug

2. Implement fix in source code

3. Verify test now passes with `bun test`

4. Run full test suite with `bun run test:all`

**Syncing worktrees efficiently:**

1. Run pre-flight checks (imports, deps, baseline tests)

2. Identify all conflicts in one pass

3. Apply standard resolution patterns

4. Batch-resolve code conflicts with MultiEdit

5. Validate with parallel build and test

6. Commit atomically with descriptive message