Update license to AGPL and prepare latest changes for launch

Author: matteius

CLA.md

@@ -0,0 +1,38 @@
+Smart Code Diff — Contributor License Agreement (CLA)
+
+Summary (Not a Substitute for the Terms)
+- You grant the project maintainers broad rights to use, modify, distribute, sublicense, and relicense your contributions, including under proprietary/commercial terms.
+- You confirm you have the necessary rights to contribute and that your contribution is your original work (or you have permission to submit it).
+- You grant a patent license for patents necessarily infringed by your contribution.
+
+1. Definitions
+- “Contribution”: any code, documentation, or other material you submit to the project.
+- “You”: the individual or legal entity submitting the Contribution.
+- “Project”: Smart Code Diff and its maintainers.
+
+2. Copyright License to the Project
+- You grant the Project a perpetual, worldwide, irrevocable, non-exclusive, transferable, sublicensable license to use, reproduce, prepare derivative works of, publicly display/perform, and distribute the Contribution and derivative works.
+- The Project may relicense the Contribution, in whole or in part, under any terms the Project chooses, including proprietary/commercial licenses.
+
+3. Patent License
+- You grant the Project a perpetual, worldwide, irrevocable, non-exclusive, transferable, sublicensable patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Contribution, where such license is only to the extent of patents necessarily infringed by the Contribution alone or in combination with the Project.
+
+4. Representations
+- You represent that each Contribution is your original work or that you have sufficient rights to grant the above licenses.
+- You represent that the Contribution is provided without encumbrances that would prevent its licensing as described herein.
+
+5. No Warranty; Disclaimer
+- Contributions are provided “as is”, without warranties or conditions of any kind.
+
+6. Acceptance
+- You will be asked to agree to this CLA via CLA Assistant on GitHub. Do not submit Contributions unless you agree to these terms.
+
+7. Entity Contributors
+- If you contribute on behalf of your employer or another entity, you represent you have authority to bind that entity. The entity is the “You” for purposes of this CLA.
+
+8. Miscellaneous
+- This is the entire agreement regarding the Contribution, superseding prior communications on this topic.
+- If any provision is unenforceable, the remainder remains in effect.
+
+For questions, contact: matt@opensensor.io
+

COMMERCIAL_LICENSE.md

@@ -0,0 +1,33 @@
+Smart Code Diff — Commercial License Summary
+
+This document summarizes the intent of the commercial license offered for Smart Code Diff. It is not the legal agreement. Final terms will be provided upon request and execution by both parties.
+
+Scope
+- Permits proprietary use, integration, and distribution of Smart Code Diff without AGPL obligations.
+- Suitable for SaaS and embedded use where source disclosure is undesirable.
+
+Grant
+- Non-exclusive, worldwide license to use, modify, and distribute the software in proprietary products and services.
+- Redistribution of modified or unmodified versions permitted under proprietary terms.
+- Includes the right to keep source code private (no copyleft obligations).
+
+Restrictions
+- No removal of copyright notices or license attributions.
+- No use of trademarks, logos, or names of the Smart Code Diff Team without permission.
+- No license to patents other than those necessarily infringed by the unmodified software; patent terms provided in the executed agreement.
+
+Support & Updates
+- Optional support, updates, and security maintenance tiers are available.
+
+Pricing
+- Commercial licenses are available on a per-company basis. Typical range: $500–$5000/year depending on use, seats, and support.
+
+Contact
+- Email: matt@opensensor.io to receive the full commercial license terms and a quote.
+
+Relation to AGPL
+- This commercial license is an alternative to AGPL-3.0-only. If you obtain a commercial license, its terms supersede AGPL obligations for your covered use.
+
+Disclaimer
+- Provided “as is” without warranties unless otherwise specified in the executed agreement.
+

CONTRIBUTING.md

@@ -0,0 +1,30 @@
+Contributing to Smart Code Diff
+
+Thank you for your interest in contributing!
+
+Code of Conduct
+- Be respectful and constructive. Treat others as you wish to be treated.
+
+How to Contribute
+1) Fork the repo and create a feature branch.
+2) Write clear, tested code. Run `cargo fmt`, `cargo clippy`, and project tests.
+3) Submit a Pull Request with a clear description and rationale.
+
+Contributor License Agreement (CLA)
+- We use a CLA to preserve dual-licensing rights. All contributors must agree to the CLA before contributions can be merged.
+- We recommend enabling GitHub CLA Assistant for this repository. When you open a PR, you’ll be prompted to sign.
+- The CLA text is in CLA.md. By contributing, you agree to those terms.
+
+Licensing Model
+- Core project: AGPL-3.0-only
+- Companies needing closed-source usage may obtain a commercial license; see COMMERCIAL_LICENSE.md.
+
+Developer Setup
+- Rust 1.75+, Node.js 18+
+- Build: `cargo build`
+- Test: `cargo test`
+- Frontend: `cd nextjs-frontend && npm install && npm run dev`
+
+Questions?
+- Open a GitHub Discussion or Issue, or email: matt@opensensor.io
+

Cargo.toml

@@ -13,8 +13,8 @@ resolver = "2"
 version = "0.1.0"
 edition = "2021"
 authors = ["Smart Code Diff Team"]
-license = "MIT"
-repository = "https://github.com/your-org/smart-code-diff"
+license = "AGPL-3.0-only"
+repository = "https://github.com/opensensor/smartdiff"
 description = "A next-generation code diffing tool that performs structural and semantic comparison"
 
 [workspace.dependencies]

FRONTEND_IMPROVEMENTS.md

@@ -0,0 +1,201 @@
+# Frontend Diff Comparison Improvements
+
+## Summary
+
+Fixed the Next.js frontend to properly leverage the Rust backend's advanced AST-based function matching algorithm, and created a new function-centric view that sorts functions by change magnitude instead of grouping by file.
+
+## Problems Identified
+
+1. **Not leveraging the Rust backend properly**: The frontend was calling `/api/comparison/analyze` which used a simplified regex-based function extraction instead of the advanced AST parser
+2. **MCP layer was unnecessary**: The MCP endpoints were just wrappers that added complexity without benefit for the web UI
+3. **File-centric organization**: Functions were grouped by file, making it hard to see the most changed functions across the entire codebase
+4. **Confusing change detection**: Functions that were moved AND modified appeared in multiple categories
+
+## Solutions Implemented
+
+### 1. Enhanced Rust Backend (`crates/web-ui/src/handlers.rs`)
+
+**Changed**: `analyze_function_changes()` function
+
+**Before**: Used regex patterns to extract functions
+```rust
+// Simple function extraction using regex patterns
+let functions = extract_functions_simple(&file.content, language_str, &file.relative_path);
+```
+
+**After**: Uses proper AST parsing with Hungarian algorithm matching
+```rust
+// Parse files using TreeSitter AST parser
+let parser = TreeSitterParser::new(language);
+let parse_result = parser.parse(&file.content, Some(&file.path));
+source_functions_ast.extend(parse_result.functions);
+
+// Use advanced FunctionMatcher with Hungarian algorithm
+let function_matcher = FunctionMatcher::new(similarity_threshold);
+let match_result = function_matcher.match_functions(&source_functions_ast, &target_functions_ast);
+```
+
+**Benefits**:
+- Accurate function extraction across all languages
+- Optimal matching using Hungarian algorithm
+- Proper similarity scoring based on AST structure
+- Correct change type detection (moved, renamed, modified)
+
+### 2. Improved Change Type Detection (`crates/diff-engine/src/changes.rs`)
+
+**Updated**: `determine_primary_change_type()` function
+
+**Key improvement**: Clear priority order for change types:
+1. Cross-file move (whether modified or not - similarity score indicates modification level)
+2. Rename (only if high similarity)
+3. Move within file (only if high similarity)
+4. Modification (default)
+
+**Result**: A function that is moved AND modified is correctly categorized as "moved" with a low similarity score, rather than appearing in both "moved" and "modified" categories.
+
+### 3. Better Change Summaries (`crates/mcp-server/src/comparison/manager.rs`)
+
+**Enhanced**: Diff summaries now clearly indicate combined changes:
+- "Function moved from X to Y and modified (75% similar)"
+- "Function renamed from 'foo' to 'bar' and modified (80% similar)"
+- "Function moved from X to Y (unchanged)"
+
+### 4. New Function-Centric View Component
+
+**Created**: `nextjs-frontend/src/components/diff/FunctionCentricDiffView.tsx`
+
+**Features**:
+- **Sorted by change magnitude**: Most changed functions appear first (regardless of file)
+- **File path as indicator**: Shows source/target file paths as small labels per function
+- **Visual change metrics**: Color-coded change magnitude and similarity percentages
+- **Flexible filtering**: Filter by change type (modified, added, deleted, moved, renamed)
+- **Multiple sort options**: By magnitude, similarity, or name
+- **Search**: Find functions by name or file path
+
+**UI Layout**:
+```
+┌─────────────────────────────────────────────────────┐
+│ [Search] [Filter: Modified ▼] [Sort: Magnitude ▼]  │
+├─────────────────────────────────────────────────────┤
+│ ┌─────────────────────────────────────────────────┐ │
+│ │ functionName()                    [modified]    │ │
+│ │ 📄 src/old.rs → src/new.rs                      │ │
+│ │ Source: L10-50  Target: L15-55                  │ │
+│ │                                   85% changed   │ │
+│ │                                   15% similar   │ │
+│ └─────────────────────────────────────────────────┘ │
+│ ┌─────────────────────────────────────────────────┐ │
+│ │ anotherFunction()                 [moved]       │ │
+│ │ 📄 src/utils.rs → src/helpers.rs                │ │
+│ │ Source: L100-120  Target: L200-220              │ │
+│ │                                   5% changed    │ │
+│ │                                   95% similar   │ │
+│ └─────────────────────────────────────────────────┘ │
+└─────────────────────────────────────────────────────┘
+```
+
+### 5. Enhanced Comparison Component
+
+**Created**: `nextjs-frontend/src/components/diff/EnhancedDiffComparison.tsx`
+
+**Features**:
+- Toggle between function-centric and file-centric views
+- Summary statistics (total, added, deleted, modified, renamed, moved)
+- Direct integration with Rust backend (no MCP middleman)
+- Better error handling and loading states
+
+**New page**: `/enhanced-diff` - Try it out!
+
+### 6. Updated ComparisonService
+
+**Removed**: MCP-specific methods (`analyzeDirectoriesWithMCP`, `getChangedFunctionsFromMCP`)
+
+**Enhanced**: `analyzeDirectories()` now:
+- Calls Rust backend's improved `/api/comparison/analyze` endpoint
+- Calculates `changeMagnitude` for each function (0.0 = no change, 1.0 = complete change)
+- Properly transforms AST-based results to frontend format
+
+## Architecture Clarification
+
+### Why NOT use MCP endpoints?
+
+**MCP (Model Context Protocol)** is designed for AI agents to interact with code, not for web UIs:
+- MCP returns text-based responses that need parsing
+- Adds unnecessary complexity (Next.js API → MCP Server → Rust Backend)
+- Web UI can call Rust backend directly with structured JSON
+
+**Better architecture**:
+```
+Next.js Frontend → Rust Backend (with AST matching)
+                    ↓
+                    Advanced diff-engine
+                    - TreeSitter AST parsing
+                    - Hungarian algorithm matching
+                    - Tree edit distance
+                    - Similarity scoring
+```
+
+**MCP is still useful for**:
+- AI agents analyzing code changes
+- Claude/GPT integrations
+- Command-line tools
+- Automated code review workflows
+
+## Files Changed
+
+### Rust Backend
+- `crates/web-ui/src/handlers.rs` - Use AST-based function matching
+- `crates/diff-engine/src/changes.rs` - Improved change type detection
+- `crates/mcp-server/src/comparison/manager.rs` - Better diff summaries
+
+### Next.js Frontend
+- `nextjs-frontend/src/services/comparisonService.ts` - Removed MCP methods, enhanced analyzeDirectories
+- `nextjs-frontend/src/components/diff/FunctionCentricDiffView.tsx` - NEW: Function-centric view
+- `nextjs-frontend/src/components/diff/EnhancedDiffComparison.tsx` - NEW: Enhanced comparison UI
+- `nextjs-frontend/src/app/enhanced-diff/page.tsx` - NEW: Page for enhanced diff
+
+### Files to Remove (Optional)
+- `nextjs-frontend/src/app/api/mcp/compare-locations/route.ts` - Not needed for web UI
+- `nextjs-frontend/src/app/api/mcp/list-changed-functions/route.ts` - Not needed for web UI
+
+## Testing
+
+1. **Start the Rust backend**:
+   ```bash
+   cd crates/web-ui
+   cargo run --release
+   ```
+
+2. **Start the Next.js frontend**:
+   ```bash
+   cd nextjs-frontend
+   npm run dev
+   ```
+
+3. **Navigate to**: http://localhost:3000/enhanced-diff
+
+4. **Test with two directories**:
+   - Select source and target directories
+   - Click "Start Comparison"
+   - Toggle between function-centric and file-centric views
+   - Try filtering by change type
+   - Sort by different criteria
+
+## Key Improvements
+
+✅ **Accurate function detection** - AST parsing instead of regex  
+✅ **Optimal matching** - Hungarian algorithm finds best matches  
+✅ **Clear categorization** - Functions appear in one category with detailed info  
+✅ **Change magnitude sorting** - See most changed functions first  
+✅ **File-agnostic view** - Functions sorted by impact, not file organization  
+✅ **Simpler architecture** - Direct Rust backend calls, no MCP middleman  
+✅ **Better UX** - Visual indicators, search, filtering, multiple views  
+
+## Next Steps (Optional)
+
+1. **Add detailed diff view**: Click a function to see line-by-line AST diff
+2. **Persist comparisons**: Save comparison results for later review
+3. **Export reports**: Generate markdown/HTML reports of changes
+4. **Batch comparisons**: Compare multiple directory pairs
+5. **Integration tests**: Add tests for the new matching algorithm
+

LICENSE

@@ -1,21 +1,19 @@
-MIT License
+Smart Code Diff — Dual License Notice
 
-Copyright (c) 2025 Smart Code Diff Team
+Copyright (c) 2025 OpenSensor Engineering, LLC
 
-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:
+SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Commercial
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+Open Source License (AGPL-3.0-only):
+- This project is available under the GNU Affero General Public License v3.0.
+- Full text: https://www.gnu.org/licenses/agpl-3.0.en.html
+- If you use the software to provide a network service, your complete source code must be made available under the AGPL.
 
-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.
+Commercial License:
+- A commercial, non-AGPL license is available for companies that wish to integrate or use this software without AGPL obligations.
+- Contact: matt@opensensor.io for pricing and terms.
+
+Contributions and Relicensing:
+- By contributing, you agree to the Contributor License Agreement (CLA) in CLA.md, which allows the maintainers to relicense your contributions for commercial use.
+
+This file summarizes licensing. In case of conflict, the full AGPL text (linked above) or your executed commercial agreement controls.

PRD.txt

@@ -380,7 +380,6 @@ interface Change {
 - **Code Editor**: Monaco Editor for syntax highlighting
 
 #### Infrastructure
-- **Container**: Docker with Kubernetes orchestration
 - **CI/CD**: GitHub Actions or GitLab CI
 - **Monitoring**: Prometheus + Grafana
 - **Cloud**: AWS or GCP with auto-scaling

QUICK_START.md

@@ -278,18 +278,6 @@ Create `nextjs-frontend/.env.local`:
 NEXT_PUBLIC_API_URL=http://localhost:8080
 ```
 
-## Docker Alternative
-
-If you prefer Docker:
-
-```bash
-# Build and run with Docker Compose
-docker-compose up
-
-# Or build manually
-docker build -t smart-diff .
-docker run -p 8080:8080 smart-diff
-```
 
 ## Next Steps