@aiready/consistency 0.2.0

package/.turbo/turbo-build.log

@@ -0,0 +1,24 @@
+
+
+> @aiready/consistency@0.2.0 build /Users/pengcao/projects/aiready/packages/consistency
+> tsup src/index.ts src/cli.ts --format cjs,esm --dts
+
+CLI Building entry: src/cli.ts, src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2020
+CJS Build start
+ESM Build start
+CJS dist/cli.js   22.47 KB
+CJS dist/index.js 14.13 KB
+CJS ⚡️ Build success in 47ms
+ESM dist/index.mjs          220.00 B
+ESM dist/cli.mjs            8.08 KB
+ESM dist/chunk-CF4LU7KE.mjs 12.90 KB
+ESM ⚡️ Build success in 48ms
+DTS Build start
+DTS ⚡️ Build success in 588ms
+DTS dist/cli.d.ts    20.00 B
+DTS dist/index.d.ts  2.60 KB
+DTS dist/cli.d.mts   20.00 B
+DTS dist/index.d.mts 2.60 KB

package/CONTRIBUTING.md

@@ -0,0 +1,153 @@
+# Contributing to @aiready/consistency
+
+Thank you for your interest in contributing to AIReady Consistency Checker! We welcome bug reports, feature requests, and code contributions.
+
+## 🐛 Reporting Issues
+
+Found a bug or have a feature request? [Open an issue](https://github.com/caopengau/aiready-consistency/issues) with:
+- Clear description of the problem or feature
+- Sample code that demonstrates the issue
+- Expected vs actual behavior
+- Your environment (Node version, OS)
+
+## 🔧 Development Setup
+
+```bash
+# Clone your fork
+git clone https://github.com/YOUR_USERNAME/aiready-consistency
+cd aiready-consistency
+
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Run tests
+pnpm test
+
+# Test CLI locally
+./dist/cli.js ../test-project
+```
+
+## 📝 Making Changes
+
+1. **Fork the repository** and create a new branch:
+   ```bash
+   git checkout -b fix/naming-detection
+   # or
+   git checkout -b feat/new-pattern-check
+   ```
+
+2. **Make your changes** following our code style:
+   - Use TypeScript strict mode
+   - Add tests for new detectors
+   - Update README with new features
+   - Keep analyzers modular and focused
+
+3. **Test your changes**:
+   ```bash
+   pnpm build
+   pnpm test
+   
+   # Test on real projects
+   ./dist/cli.js path/to/test-project
+   ```
+
+4. **Commit and push**:
+   ```bash
+   git add .
+   git commit -m "feat: add camelCase detection for Python"
+   git push origin your-branch
+   ```
+
+5. **Open a Pull Request** with:
+   - Description of changes
+   - Test results
+   - Screenshots (if applicable)
+
+## 🧪 Testing Guidelines
+
+- Add tests for new naming patterns
+- Test on multiple file types (TS, JS, Python, etc.)
+- Verify false positive rate is acceptable
+- Check performance with large codebases
+
+## 🏗️ Architecture
+
+### Directory Structure
+
+```
+src/
+├── analyzers/        # Individual analyzers
+│   ├── naming.ts     # Naming quality & conventions
+│   ├── patterns.ts   # Code pattern consistency
+│   └── architecture.ts # (future) Architecture checks
+├── analyzer.ts       # Main orchestrator
+├── types.ts          # Type definitions
+├── cli.ts            # CLI interface
+└── index.ts          # Public API exports
+```
+
+### Adding a New Analyzer
+
+1. Create `src/analyzers/your-analyzer.ts`:
+   ```typescript
+   import type { YourIssueType } from '../types';
+   
+   export async function analyzeYourThing(files: string[]): Promise<YourIssueType[]> {
+     // Your detection logic
+     return issues;
+   }
+   ```
+
+2. Update `src/types.ts` with new issue types
+
+3. Integrate in `src/analyzer.ts`
+
+4. Add CLI options in `src/cli.ts`
+
+5. Export from `src/index.ts`
+
+6. Add tests in `src/__tests__/`
+
+## 📊 Pattern Detection Guidelines
+
+When adding new consistency checks:
+
+1. **Focus on AI Impact**: Does this inconsistency confuse AI models?
+2. **Minimize False Positives**: Acceptable patterns should not be flagged
+3. **Provide Context**: Include file, line, and clear suggestions
+4. **Categorize Properly**: Is it naming, pattern, or architecture?
+5. **Consider Performance**: Avoid expensive operations on every line
+
+## 🎯 Code Style
+
+- Follow existing patterns in the codebase
+- Use descriptive variable names (we're checking naming, after all!)
+- Add comments for complex logic
+- Keep functions focused and small
+- Prefer composition over inheritance
+
+## 🔄 Monorepo Development
+
+This package is part of the AIReady monorepo. If contributing to the monorepo:
+
+1. Work in `packages/consistency/`
+2. Use `pnpm` for package management
+3. Follow hub-and-spoke patterns (only import from `@aiready/core`)
+4. Test integration with `@aiready/cli`
+
+## 📚 Resources
+
+- [AIReady Main Repo](https://github.com/caopengau/aiready)
+- [AIReady Documentation](.github/copilot-instructions.md)
+- [TypeScript Best Practices](https://github.com/labs42io/clean-code-typescript)
+
+## 🤝 Code of Conduct
+
+Be respectful, constructive, and inclusive. We're all learning and improving together.
+
+## 📄 License
+
+By contributing, you agree that your contributions will be licensed under the MIT License.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AIReady Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,170 @@
+# @aiready/consistency
+
+> **Detect consistency issues in naming, patterns, and architecture that confuse AI models**
+
+Helps teams maintain consistent coding practices across their codebase, making it easier for AI tools to understand and work with your code.
+
+## 🚀 Quick Start
+
+**Recommended: Use the unified CLI** (includes consistency checking + more tools):
+
+```bash
+npm install -g @aiready/cli
+aiready consistency ./src
+```
+
+**Or use this package directly:**
+
+```bash
+npm install -g @aiready/consistency
+aiready-consistency ./src
+```
+
+## 🎯 What It Does
+
+Inconsistent code patterns confuse AI models and reduce their effectiveness. This tool analyzes:
+
+### 🏷️ Naming Quality & Conventions
+- Single-letter variables (except loop counters)
+- Unclear abbreviations
+- Mixed naming conventions (camelCase vs snake_case)
+- Boolean naming (should use is/has/can prefixes)
+- Function naming (should start with action verbs)
+
+### 🔄 Pattern Consistency
+- Error handling strategies (try-catch vs returns)
+- Async patterns (async/await vs promises vs callbacks)
+- Import styles (ES modules vs CommonJS)
+- API design patterns
+
+### 🏗️ Architectural Consistency *(coming soon)*
+- File organization patterns
+- Module structure
+- Export/import patterns
+
+## 📊 Example Output
+
+```
+📊 Summary
+
+Files Analyzed: 47
+Total Issues: 23
+  Naming: 15
+  Patterns: 8
+  Architecture: 0
+
+🏷️  Naming Issues
+
+MINOR src/utils/helpers.ts:12
+  poor-naming: x
+  → Use descriptive variable name instead of single letter 'x'
+
+MINOR src/components/User.ts:45
+  convention-mix: user_name
+  → Use camelCase 'userName' instead of snake_case in TypeScript/JavaScript
+
+🔄 Pattern Issues
+
+MAJOR multiple files
+  Inconsistent error handling strategies across codebase
+  → Standardize error handling strategy (prefer try-catch with typed errors)
+
+💡 Recommendations
+
+1. Standardize naming conventions: Found 7 snake_case variables in TypeScript
+2. Improve variable naming: Found 8 single-letter or unclear variable names
+3. Use async/await consistently instead of mixing with promise chains
+```
+
+## ⚙️ Usage
+
+```bash
+# Full analysis
+aiready-consistency ./src
+
+# Skip naming checks
+aiready-consistency ./src --no-naming
+
+# Skip pattern checks
+aiready-consistency ./src --no-patterns
+
+# Show only major issues
+aiready-consistency ./src --min-severity major
+
+# Export to JSON
+aiready-consistency ./src --output json > report.json
+
+# Export to Markdown
+aiready-consistency ./src --output markdown --output-file report.md
+```
+
+## 🎛️ Options
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--naming` | Enable naming analysis | `true` |
+| `--no-naming` | Skip naming analysis | - |
+| `--patterns` | Enable pattern analysis | `true` |
+| `--no-patterns` | Skip pattern analysis | - |
+| `--min-severity` | Minimum severity: info\|minor\|major\|critical | `info` |
+| `--include` | File patterns to include | All files |
+| `--exclude` | File patterns to exclude | - |
+| `--output` | Output format: console\|json\|markdown | `console` |
+| `--output-file` | Output file path | - |
+
+## 📝 Configuration File
+
+Create `aiready.json` in your project root:
+
+```json
+{
+  "consistency": {
+    "checkNaming": true,
+    "checkPatterns": true,
+    "minSeverity": "minor",
+    "exclude": ["**/dist/**", "**/node_modules/**"]
+  }
+}
+```
+
+## 🔧 Programmatic API
+
+```typescript
+import { analyzeConsistency } from '@aiready/consistency';
+
+const report = await analyzeConsistency({
+  rootDir: './src',
+  checkNaming: true,
+  checkPatterns: true,
+  minSeverity: 'minor'
+});
+
+console.log(`Found ${report.summary.totalIssues} issues`);
+```
+
+## 🤝 Why This Matters for AI
+
+AI models work best with consistent codebases because:
+
+1. **Pattern Recognition**: Consistent patterns help AI understand your coding style
+2. **Context Efficiency**: Less variation = more useful code fits in context window
+3. **Accurate Suggestions**: AI can predict conventions and follow them
+4. **Reduced Errors**: AI makes fewer mistakes with clear, consistent patterns
+
+## 📦 Integration with AIReady
+
+This tool is part of the [AIReady](https://github.com/caopengau/aiready) ecosystem:
+
+- **@aiready/cli** - Unified interface for all analysis tools
+- **@aiready/pattern-detect** - Semantic duplicate detection
+- **@aiready/context-analyzer** - Context window cost analysis
+- **@aiready/consistency** - Consistency analysis (this tool)
+
+## 📖 Documentation
+
+- [Contributing Guide](./CONTRIBUTING.md)
+- [AIReady Main Repo](https://github.com/caopengau/aiready)
+
+## 📄 License
+
+MIT © AIReady Team