@parseme/cli 0.0.5 → 0.1.0

package/README.md

@@ -1,16 +1,43 @@
 # PARSEME
 
-AI Project Context Generator - Automated context generation for AI coding assistants.
+**Local code analysis and context generation to improve token efficiency of AI Coding agents
+Cross-project access via Cloud MCP**
 
 PARSEME analyzes your TypeScript/JavaScript projects and generates a PARSEME.md file—a README.md for AI agents. This file provides comprehensive context documentation that helps AI assistants understand your codebase structure, architecture, and patterns. By providing persistent, reusable context, PARSEME prevents AI agents from repeatedly analyzing your codebase from scratch—saving valuable tokens and improving efficiency for every interaction.
 
+## Table of Contents
+
+- [Development Status](#development-status)
+- [Features](#features)
+  - [What PARSEME Detects](#what-parseme-detects)
+  - [Language Support](#language-support)
+  - [Supported Projects](#supported-projects)
+- [Installation](#installation)
+- [Quick Start](#quick-start)
+- [Automation Options](#automation-options)
+  - [Option 1: Manual Execution](#option-1-manual-execution)
+  - [Option 2: Automatic Local Generation](#option-2-automatic-local-generation)
+  - [Option 3: Automatic Local and Remote Generation (Advanced Git Hooks)](#option-3-automatic-local-and-remote-generation-advanced-git-hooks)
+  - [Option 4: GitHub Actions for Remote Generation paired with Local Generation](#option-4-github-actions-for-remote-generation-paired-with-local-generation)
+- [Configuration](#configuration)
+  - [Configuration File Formats & Priority](#configuration-file-formats--priority)
+  - [Configuration Priority](#configuration-priority)
+  - [Configuration Options](#configuration-options)
+  - [CLI Options](#cli-options)
+  - [Interactive Configuration](#interactive-configuration)
+- [CLI Commands](#cli-commands)
+- [Programmatic API](#programmatic-api)
+- [Output Format](#output-format)
+- [AI Agent Integration](#ai-agent-integration)
+- [Requirements](#requirements)
+- [License](#license)
+
 ## Development Status
 
-**This project is currently in active development and pre-alpha phase.**
+**This project is currently in active development.**
 
 The core functionality is working, but expect:
 
-- Breaking changes in configuration format
 - API modifications as the interface gets refined
 - Additional features being added regularly
 - Possible bugs and edge cases
@@ -88,6 +115,8 @@ PARSEME aims to automatically analyse any JavaScript or TypeScript project like:
 - **Desktop apps** - Main processes, renderers, IPC handlers
 - **Testing utilities** - Test functions, mocks, utilities, custom matchers
 
+**Note:** PARSEME provides specialized analysis for **Express.js**, **NestJS**, and **Fastify**, including route detection, middleware identification, and decorator analysis. All other frameworks benefit from universal AST-based analysis.
+
 ## Installation
 
 ```bash
@@ -114,21 +143,10 @@ npm install --save-dev parseme
    - How to add parseme script to package.json
    - How to integrate with git hooks
    - README section to help AI agents find context
+   - AI agent configuration files to reference PARSEME.md
 
-2. **Add to your package.json scripts** (optional, for easier execution):
-
-   ```json
-   {
-     "scripts": {
-       "parseme": "parseme generate"
-     }
-   }
-   ```
-
-3. **Generate context**:
+2. **Generate context**:
    ```bash
-   npm run parseme
-   # or
    npx parseme generate
    # or use the alias
    npx parseme g
@@ -137,7 +155,317 @@ npm install --save-dev parseme
 This creates:
 
 - `PARSEME.md` - Main overview with links to context files
-- `parseme-context/` - Structured data files (AST, dependencies, routes, git info)
+- `parseme-context/` - Structured data files (file list, AST structure, routes, git diff)
+
+## Automation Options
+
+PARSEME can be integrated into your workflow in several ways, from manual execution to fully automated generation. Choose the approach that best fits your needs:
+
+### Option 1: Manual Execution
+
+Run parseme manually whenever you need updated context.
+
+**Setup:**
+
+Add to your `package.json` scripts (optional, for convenience):
+
+```json
+{
+  "scripts": {
+    "parseme": "parseme generate"
+  }
+}
+```
+
+**Usage:**
+
+```bash
+npm run parseme
+# or directly
+npx parseme generate
+```
+
+**Best for:** Small projects, occasional updates, or when you prefer full control over when context is generated.
+
+---
+
+### Option 2: Automatic Local Generation
+
+Automatically generate parseme files locally after every commit. Files are committed to the repository.
+
+**Setup with Husky:**
+
+```bash
+# Install Husky (if not already installed)
+npm install --save-dev husky
+npx husky init
+
+# Create post-commit hook
+cat > .husky/post-commit << 'EOF'
+#!/bin/sh
+
+# Generate PARSEME files locally after commit
+npx parseme generate
+EOF
+
+# Make hook executable
+chmod +x .husky/post-commit
+```
+
+**Setup with manual git hooks:**
+
+```bash
+cat > .git/hooks/post-commit << 'EOF'
+#!/bin/sh
+
+npx parseme generate
+EOF
+
+chmod +x .git/hooks/post-commit
+```
+
+**How it works:**
+
+- After each commit, parseme automatically generates context files with full git info
+- Files are ready to be staged and committed with your next commit
+- Simple setup with minimal configuration
+
+**Best for:** Solo developers or small teams wanting automatic local updates with committed parseme files.
+
+**Note:** If using a custom `contextDir`, ensure the path is consistent across your team's configuration.
+
+---
+
+### Option 3: Automatic Local and Remote Generation (Advanced Git Hooks)
+
+Automatically update parseme files locally and remotely with git hooks. Keeps the remote version clean (without git-specific info) while maintaining full context locally. Uses multiple git hooks to manage local vs remote state.
+
+**Setup with Husky:**
+
+```bash
+# Install Husky (if not already installed)
+npm install --save-dev husky
+npx husky init
+
+# Create post-commit hook
+cat > .husky/post-commit << 'EOF'
+#!/bin/sh
+
+npx parseme generate
+EOF
+
+# Create pre-push hook
+cat > .husky/pre-push << 'EOF'
+#!/bin/sh
+
+# Regenerate without git info for clean remote state
+npx parseme generate --no-git-info
+
+# Stage parseme files
+git add parseme-context/ PARSEME.md
+
+# Amend the commit with updated parseme files
+git commit --amend --no-edit --no-verify
+EOF
+
+# Create post-push hook
+cat > .husky/post-push << 'EOF'
+#!/bin/sh
+
+# Regenerate with git info for local development
+npx parseme generate
+EOF
+
+# Make hooks executable
+chmod +x .husky/post-commit .husky/pre-push .husky/post-push
+```
+
+**Setup with manual git hooks:**
+
+```bash
+# Post-commit: Generate context with git info after each commit
+cat > .git/hooks/post-commit << 'EOF'
+#!/bin/sh
+
+npx parseme generate
+EOF
+
+# Pre-push: Regenerate without git info and amend before pushing
+cat > .git/hooks/pre-push << 'EOF'
+#!/bin/sh
+
+# Regenerate without git info for clean remote state
+npx parseme generate --no-git-info
+
+# Stage parseme files
+git add parseme-context/ PARSEME.md
+
+# Amend the commit with updated parseme files
+git commit --amend --no-edit --no-verify
+EOF
+
+# Post-push: Restore git info locally after push completes
+cat > .git/hooks/post-push << 'EOF'
+#!/bin/sh
+
+# Regenerate with git info for local development
+npx parseme generate
+EOF
+
+# Make hooks executable
+chmod +x .git/hooks/post-commit .git/hooks/pre-push .git/hooks/post-push
+```
+
+**How it works:**
+
+1. **post-commit**: Generates context files with full git info locally
+2. **pre-push**: Regenerates without git info and amends the commit before pushing
+3. **post-push**: Restores full git info locally after push completes
+
+The `--no-verify` flag in pre-push prevents an infinite loop by skipping hook execution on the amend.
+
+**Best for:** Teams that want detailed local context for development while keeping clean, portable context in the repository.
+
+**Note:** If using a custom `contextDir`, update the `git add` path in the pre-push hook (e.g., `git add docs/context/ PARSEME.md`).
+
+---
+
+### Option 4: GitHub Actions for Remote Generation paired with Local Generation
+
+Use GitHub Actions to automatically manage remote parseme files while keeping them updated locally with git hooks. This is the recommended approach for teams using GitHub.
+
+**Setup:**
+
+**1. Add parseme files to `.gitignore`:**
+
+```gitignore
+# Parseme documentation (generated locally and by CI)
+parseme-context/
+PARSEME.md
+```
+
+**2. Create `.github/workflows/parseme-update.yml`:**
+
+```yaml
+name: Update PARSEME Documentation
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  update-parseme:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    env:
+      GITHUB_TOKEN: ${{ secrets.GH_SERVICE_ACCOUNT_TOKEN }}
+
+    steps:
+      - name: Check if pusher is service account
+        id: check_pusher
+        run: |
+          if [ "${{ github.event.pusher.name }}" = "${{ secrets.GH_SERVICE_ACCOUNT_USERNAME }}" ]; then
+            echo "is_bot=true" >> $GITHUB_OUTPUT
+          else
+            echo "is_bot=false" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Checkout code
+        if: steps.check_pusher.outputs.is_bot == 'false'
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GH_SERVICE_ACCOUNT_TOKEN }}
+
+      - name: Setup Node.js
+        if: steps.check_pusher.outputs.is_bot == 'false'
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: 'npm'
+
+      - name: Configure Git
+        if: steps.check_pusher.outputs.is_bot == 'false'
+        run: |
+          git config user.name "${{ secrets.GH_SERVICE_ACCOUNT_USERNAME }}"
+          git config user.email "${{ secrets.GH_SERVICE_ACCOUNT_USERNAME }}@users.noreply.github.com"
+
+      - name: Install dependencies
+        if: steps.check_pusher.outputs.is_bot == 'false'
+        run: npm ci
+
+      - name: Generate ParseMe documentation
+        if: steps.check_pusher.outputs.is_bot == 'false'
+        run: npx parseme generate --no-git-info
+
+      - name: Force add parseme files (ignored in .gitignore)
+        if: steps.check_pusher.outputs.is_bot == 'false'
+        run: git add -f parseme-context/ PARSEME.md
+
+      - name: Check for changes
+        if: steps.check_pusher.outputs.is_bot == 'false'
+        id: check_changes
+        run: |
+          if git diff --cached --quiet; then
+            echo "changes=false" >> $GITHUB_OUTPUT
+          else
+            echo "changes=true" >> $GITHUB_OUTPUT
+          fi
+
+      - name: Commit and amend
+        if: steps.check_pusher.outputs.is_bot == 'false' && steps.check_changes.outputs.changes == 'true'
+        run: |
+          git commit --amend --no-edit --no-verify
+          git push --force-with-lease
+```
+
+**3. Configure GitHub secrets:**
+
+- `GH_SERVICE_ACCOUNT_TOKEN`: A GitHub personal access token with repo write permissions
+- `GH_SERVICE_ACCOUNT_USERNAME`: The username of your service account (to prevent infinite loops)
+
+**4. Setup local git hooks with Husky:**
+
+```bash
+# Install Husky (if not already installed)
+npm install --save-dev husky
+npx husky init
+
+# Create post-commit hook
+cat > .husky/post-commit << 'EOF'
+#!/bin/sh
+
+# Generate PARSEME files locally after commit
+npx parseme generate
+EOF
+
+# Create post-merge hook
+cat > .husky/post-merge << 'EOF'
+#!/bin/sh
+
+# Untrack parseme files after merge/pull to keep them gitignored locally
+git rm --cached -r parseme-context/ PARSEME.md 2>/dev/null || true
+EOF
+
+# Make hooks executable
+chmod +x .husky/post-commit .husky/post-merge
+```
+
+**How it works:**
+
+1. **Local development**: Parseme files are generated locally after each commit with full git info
+2. **Ignored by git**: Files are listed in `.gitignore` so they're not committed manually
+3. **Remote updates**: GitHub Actions automatically generates and commits parseme files (without git info) when pushing to main
+4. **After pull/merge**: The post-merge hook ensures parseme files stay untracked locally, preventing conflicts
+
+**Best for:** Teams using GitHub that want automated CI-managed remote updates with local context for development.
+
+**Notes:**
+
+- The workflow only runs on the `main` branch (adjust as needed for your branching strategy)
+- If using a custom `contextDir`, update both the `.gitignore` entry, the workflow's `git add -f` path, and the post-merge hook's `git rm --cached -r` path accordingly
 
 ## Configuration
 
@@ -173,7 +501,8 @@ const config = {
   maxDepth: 10,
 
   // Git integration
-  includeGitInfo: true,
+  includeGitInfo: true, // Include git repository information in context
+  useGitForFiles: true, // Use git to discover files (respects .gitignore)
 
   // Size limits
   limits: {
@@ -272,7 +601,8 @@ Configuration values are resolved in the following order (highest to lowest prio
 
 #### Git Integration
 
-- `includeGitInfo` - Include git repository information (default: `true`)
+- `includeGitInfo` - Include git repository information in context files (default: `true`)
+- `useGitForFiles` - Use git to discover files, respecting .gitignore (default: `true`)
 
 #### Content Sections
 
@@ -296,54 +626,6 @@ Toggle which sections to include in the output (all default to `true`):
 
 - `limits.maxFilesPerContext` - Maximum number of files to analyze (default: `5000`)
 
-## Output Format
-
-PARSEME always generates the following output files:
-
-- `PARSEME.md` - Main overview with links to context files (Markdown)
-- Context directory (default: `parseme-context/`) with structured data files:
-  - `files.md` - Complete list of analyzed files (Markdown)
-  - `structure.json` - AST analysis with exports, imports, functions, and classes (JSON)
-  - `api-endpoints.json` - API routes with methods, paths, and handlers (JSON, only if routes detected)
-  - `dependencies.json` - Production dependencies with versions (JSON)
-  - `framework.json` - Framework details if detected (JSON, optional)
-  - `gitDiff.md` - Git diff statistics from generation time (Markdown, if git enabled)
-
-The context directory location can be customized via the `contextDir` configuration option.
-
-## CLI Commands
-
-```bash
-# Generate context (auto-detects config file)
-npx parseme generate
-npx parseme g  # alias
-
-# Initialize configuration (JSON by default)
-npx parseme init
-npx parseme i  # alias
-
-# Initialize with TypeScript format
-npx parseme init --format ts
-
-# Initialize with JavaScript format
-npx parseme init --format js
-
-# Use custom config file
-npx parseme generate --config custom.config.js
-
-# If added to package.json scripts, use npm run
-npm run parseme
-
-# Auto-generate context with git hooks (when configured)
-# Runs automatically after each commit
-
-# Override config with CLI flags
-npx parseme generate --output custom.md --context-dir docs/context --root ./src --no-git
-
-# Specify file types and exclude patterns
-npx parseme generate --file-types ts js --exclude "**/*.test.ts"
-```
-
 ### CLI Options
 
 #### Generate Command (`parseme generate` or `parseme g`)
@@ -354,7 +636,8 @@ npx parseme generate --file-types ts js --exclude "**/*.test.ts"
 - `--context-dir <path>` - Context directory path (default: parseme-context)
 - `--file-types <types...>` - File types to analyze (e.g., ts tsx js jsx)
 - `--exclude <patterns...>` - Additional exclude patterns (glob, in git repositories on top of git-tracked files)
-- `--no-git` - Disable git information
+- `--no-git-info` - Disable git info generation (keeps git for file discovery)
+- `--no-git-files` - Disable git for file discovery (uses filesystem crawling instead)
 - `--max-depth <number>` - Maximum directory depth
 
 #### Init Command (`parseme init` or `parseme i`)
@@ -374,28 +657,49 @@ After initialization, setup tips are displayed:
 - Package.json script suggestion
 - Git hook integration suggestion
 - README.md section suggestion for AI agents
+- AI agent configuration files to reference PARSEME.md
 
-## Framework Support
+## CLI Commands
 
-PARSEME automatically detects and provides specialized analysis for:
+```bash
+# Generate context (auto-detects config file)
+npx parseme generate
+npx parseme g  # alias
 
-### Express.js
+# Initialize configuration (JSON by default)
+npx parseme init
+npx parseme i  # alias
 
-- Route detection (`app.get`, `router.post`, etc.)
-- Middleware identification
-- Request handler mapping
+# Initialize with TypeScript format
+npx parseme init --format ts
 
-### NestJS
+# Initialize with JavaScript format
+npx parseme init --format js
 
-- Controller and decorator analysis
-- Module structure detection w
-- Dependency injection mapping
+# Use custom config file
+npx parseme generate --config custom.config.js
+
+# If added to package.json scripts, use npm run
+npm run parseme
+
+# Auto-generate context with git hooks (when configured)
+# Runs automatically after each commit
+
+# Override config with CLI flags
+npx parseme generate --output custom.md --context-dir docs/context --root ./src
 
-### Fastify
+# Disable git info generation (keeps git for file discovery)
+npx parseme generate --no-git-info
 
-- Route registration detection
-- Plugin identification
-- Hook analysis
+# Disable git for file discovery (keeps git info generation)
+npx parseme generate --no-git-files
+
+# Disable both git info and git file discovery
+npx parseme generate --no-git-info --no-git-files
+
+# Specify file types and exclude patterns
+npx parseme generate --file-types ts js --exclude "**/*.test.ts"
+```
 
 ## Programmatic API
 
@@ -411,36 +715,54 @@ const context = await generator.generate();
 await generator.generateToFile('./output/PARSEME.md');
 ```
 
-## Git Hook Integration
+## Output Format
 
-Keep your AI context automatically updated by adding parseme as a post-commit hook:
+PARSEME generates the following output files:
 
-### Manual Setup
+- `PARSEME.md` - Main overview with links to context files and project summary (Markdown)
+- Context directory (default: `parseme-context/`) with structured data files:
+  - `files.md` - Complete list of all project files (Markdown)
+  - `structure.json` - AST analysis with exports, imports, functions, classes, and route references (JSON)
+  - `routes.json` - API routes with methods, paths, and handlers (JSON, only if routes detected)
+  - `gitDiff.md` - Git diff statistics from generation time (Markdown, only if git is enabled and changes exist)
 
-```bash
-# Create and make executable
-echo '#!/bin/sh\npx parseme generate' > .git/hooks/post-commit
-chmod +x .git/hooks/post-commit
+The context directory location can be customized via the `contextDir` configuration option.
+
+## AI Agent Integration
+
+To help AI coding assistants efficiently understand your codebase structure and context, add instructions to your agent configuration files:
+
+### Claude Code (`.claude/README.md` or `.claude/instructions.md`)
+
+```markdown
+Read PARSEME.md and parseme-context/ to understand the codebase structure and context.
 ```
 
-### Using Husky
+### GitHub Copilot (`.github/copilot-instructions.md`)
 
-```json
-// package.json
-{
-  "husky": {
-    "hooks": {
-      "post-commit": "npx parseme generate"
-    }
-  }
-}
+```markdown
+Read PARSEME.md and parseme-context/ to understand the codebase structure and context.
+```
+
+### Cursor (`.cursorrules`)
+
+```
+Read PARSEME.md and parseme-context/ to understand the codebase structure and context.
+```
+
+### ChatGPT / Custom GPT
+
+Add to project instructions or system prompt:
+
+```
+Read PARSEME.md and parseme-context/ to understand the codebase structure and context.
 ```
 
-This automatically regenerates your AI context files after every commit, ensuring they're always up-to-date!
+This ensures AI assistants use your pre-generated context for efficient codebase understanding.
 
 ## Requirements
 
-- Node.js ≥20.19.5
+- Node.js ≥20.19.5 <21 || ≥22.21.1
 - npm ≥10.8.2
 
 ## License

package/dist/cli/cli.js

@@ -20,7 +20,8 @@ program
     .option('--context-dir <path>', 'Context directory path (default: parseme-context)')
     .option('--file-types <types...>', 'File types to analyze (e.g., ts tsx js jsx)')
     .option('--exclude <patterns...>', 'Exclude patterns (glob)')
-    .option('--no-git', 'Disable git integration (info and file discovery)')
+    .option('--no-git-files', 'Disable git for file discovery')
+    .option('--no-git-info', 'Disable git info generation')
     .option('--max-depth <number>', 'Maximum directory depth', parseInt)
     .action(async (options) => {
     try {
@@ -31,7 +32,8 @@ program
             ...(options.contextDir && { contextDir: options.contextDir }),
             ...(options.fileTypes && { analyzeFileTypes: options.fileTypes }),
             ...(options.exclude && { excludePatterns: options.exclude }),
-            ...(options.git === false && { includeGitInfo: false, useGitForFiles: false }),
+            ...(options.gitFiles === false && { useGitForFiles: false }),
+            ...(options.gitInfo === false && { includeGitInfo: false }),
             ...(options.maxDepth && { maxDepth: options.maxDepth }),
         };
         const configFromFile = await ParsemeConfig.fromFile(options.config, {
@@ -116,15 +118,21 @@ program
         if (options.format === 'ts') {
             console.log('For TypeScript configs, ensure tsx or ts-node is available to load .ts files');
         }
-        console.log('Tip: Add "parseme": "parseme" to your package.json scripts for easier manual execution or hook integration');
-        console.log('Tip: Add parseme as a git hook to keep context auto-updated! See README for setup instructions.');
+        console.log('Tip: Add "parseme": "parseme generate" to your package.json scripts for easier manual execution or hook integration');
+        console.log('Tip: Add parseme as git hooks to keep context auto-updated! See README for recommended hook setup (post-commit, pre-push, post-push).');
         console.log('');
         console.log('Tip: Add this section to your README.md to help AI agents find the context:');
         console.log('');
         console.log('## Instructions For AI Agents');
         console.log('This project includes AI-optimized documentation for efficient context providing:');
         console.log('- `PARSEME.md` - Project overview with links to detailed context files');
-        console.log('- `parseme-context/` - Structured data files (AST analysis, dependencies, routes, git info)');
+        console.log('- `parseme-context/` - Structured data files (file list, AST structure, routes, git diff)');
+        console.log('');
+        console.log('Tip: Add references to PARSEME.md in your AI agent config files for efficient context gathering:');
+        console.log('  - Claude Code: .claude/README.md or .claude/instructions.md');
+        console.log('  - GitHub Copilot: .github/copilot-instructions.md');
+        console.log('  - Cursor: .cursorrules');
+        console.log('  - Example instruction: "Read PARSEME.md and parseme-context/ to understand the codebase structure and context."');
         console.log('');
     }
     catch (error) {

package/dist/core/context-builder.js

@@ -156,7 +156,7 @@ A comprehensive list of all discovered API routes is available at [${linkPath}/r
         return content;
     }
     buildFilesList(allFiles) {
-        let content = `# Project Files\n`;
+        let content = `# Project Files\n\n`;
         allFiles.forEach((file) => {
             content += `- ${file}\n`;
         });

package/dist/core/generator.js

@@ -1,4 +1,4 @@
-import { mkdir, writeFile } from 'fs/promises';
+import { mkdir, writeFile, rm } from 'fs/promises';
 import { join } from 'path';
 import { ASTAnalyzer } from './analyzers/ast-analyzer.js';
 import { FrameworkDetector } from './analyzers/framework-detector.js';
@@ -72,13 +72,19 @@ export class ParsemeGenerator {
         const parsemeDir = finalContextDir.startsWith('/')
             ? finalContextDir // Absolute path
             : join(baseDir, finalContextDir); // Relative path
+        // Clear the directory if it exists, then recreate it
+        await rm(parsemeDir, { recursive: true, force: true });
         await mkdir(parsemeDir, { recursive: true });
-        await writeFile(finalOutputPath, context.parseme);
+        const parsemeContent = context.parseme.endsWith('\n')
+            ? context.parseme
+            : context.parseme + '\n';
+        await writeFile(finalOutputPath, parsemeContent);
         if (context.context) {
             for (const [filename, content] of Object.entries(context.context)) {
                 // Use .md extension for markdown files, .json for others
                 const extension = filename === 'gitDiff' || filename === 'files' ? '.md' : '.json';
-                await writeFile(join(parsemeDir, `${filename}${extension}`), content);
+                const fileContent = content.endsWith('\n') ? content : content + '\n';
+                await writeFile(join(parsemeDir, `${filename}${extension}`), fileContent);
             }
         }
     }

package/package.json

@@ -1,10 +1,15 @@
 {
   "name": "@parseme/cli",
-  "version": "0.0.5",
+  "version": "0.1.0",
   "description": "Adds a PARSEME.md file—a README.md for AI agents—to your project, providing context and structure for automated tools.",
   "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "bin": {
     "parseme": "dist/cli/cli.js"
   },
@@ -15,7 +20,7 @@
   ],
   "engines": {
     "npm": ">=10.8.2",
-    "node": ">=20.19.5"
+    "node": ">=20.19.5 <21 || >=22.21.1"
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
@@ -24,13 +29,11 @@
     "format:check": "prettier . --ignore-unknown --check",
     "lint": "eslint --config ./eslint.config.js --fix",
     "lint:check": "eslint --config ./eslint.config.js --no-fix --max-warnings 0",
-    "test": "node --test --experimental-test-coverage 'tests/**/*.test.ts'",
-    "pretest:unit": "npm run build",
+    "test": "node --test 'tests/**/*.test.ts'",
+    "pretest": "npm run build",
     "test:unit": "node --test 'tests/unit/**/*.test.ts'",
-    "pretest:integration": "npm run build",
     "test:integration": "node --test 'tests/integration/**/*.test.ts'",
     "test:watch": "node --test --watch 'tests/**/*.test.ts'",
-    "pretest:coverage": "npm run build",
     "test:coverage": "node --test --experimental-test-coverage 'tests/unit/**/*.test.ts' 'tests/integration/**/*.test.ts'",
     "test:setup:e2e": "npm run -C ../e2e setup",
     "test:e2e": "npm run -C ../e2e test",
@@ -55,7 +58,7 @@
   "bugs": {
     "url": "https://github.com/citrus551/parseme-modules/issues"
   },
-  "homepage": "https://github.com/citrus551/parseme-modules#readme",
+  "homepage": "https://parseme.ai",
   "dependencies": {
     "@babel/core": "^7.28.4",
     "@babel/parser": "^7.28.4",