arcvision 0.2.12 → 0.2.15

package/test_repos/allowed-clean-architecture/adapters/http/HttpServer.js

@@ -0,0 +1,78 @@
+// Express HTTP Server - Clean architecture adapter
+
+const express = require('express');
+const UserController = require('./controllers/UserController');
+
+class HttpServer {
+  constructor() {
+    this.app = express();
+    this.userController = new UserController();
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+
+  setupMiddleware() {
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+    
+    // Logging middleware
+    this.app.use((req, res, next) => {
+      console.log(`${new Date().toISOString()} - ${req.method} ${req.path}`);
+      next();
+    });
+  }
+
+  setupRoutes() {
+    // Health check endpoint
+    this.app.get('/health', (req, res) => {
+      res.json({ status: 'ok', timestamp: new Date().toISOString() });
+    });
+
+    // User routes
+    this.app.post('/api/users', (req, res) => 
+      this.userController.createUser(req, res));
+    
+    this.app.get('/api/users/:id', (req, res) => 
+      this.userController.getUser(req, res));
+    
+    this.app.put('/api/users/:id', (req, res) => 
+      this.userController.updateUser(req, res));
+    
+    this.app.delete('/api/users/:id', (req, res) => 
+      this.userController.deleteUser(req, res));
+
+    // Catch-all for undefined routes
+    this.app.use('*', (req, res) => {
+      res.status(404).json({ error: 'Route not found' });
+    });
+
+    // Error handling middleware
+    this.app.use((error, req, res, next) => {
+      console.error('Unhandled error:', error);
+      res.status(500).json({ error: 'Internal server error' });
+    });
+  }
+
+  async start(port = 3002) {
+    return new Promise((resolve) => {
+      this.server = this.app.listen(port, () => {
+        console.log(`Clean Architecture Server running on port ${port}`);
+        console.log('✅ Clean architecture boundaries maintained');
+        resolve(this.server);
+      });
+    });
+  }
+
+  async stop() {
+    if (this.server) {
+      return new Promise((resolve) => {
+        this.server.close(() => {
+          console.log('Server stopped');
+          resolve();
+        });
+      });
+    }
+  }
+}
+
+module.exports = HttpServer;

package/test_repos/allowed-clean-architecture/application/dtos/CreateUserRequest.js

@@ -0,0 +1,37 @@
+// CreateUserRequest DTO - Data Transfer Object for user creation
+
+class CreateUserRequest {
+  constructor(name, email) {
+    this.name = name;
+    this.email = email;
+  }
+
+  static fromJson(json) {
+    return new CreateUserRequest(json.name, json.email);
+  }
+
+  validate() {
+    const errors = [];
+    
+    if (!this.name || this.name.trim().length === 0) {
+      errors.push('Name is required');
+    }
+    
+    if (!this.email || this.email.trim().length === 0) {
+      errors.push('Email is required');
+    } else if (!this.isValidEmail(this.email)) {
+      errors.push('Invalid email format');
+    }
+    
+    return {
+      isValid: errors.length === 0,
+      errors
+    };
+  }
+
+  isValidEmail(email) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+  }
+}
+
+module.exports = CreateUserRequest;

package/test_repos/allowed-clean-architecture/application/services/UserService.js

@@ -0,0 +1,61 @@
+// User Application Service - Orchestrates business logic
+
+const User = require('../../domain/models/User');
+const UserRepository = require('../../domain/interfaces/UserRepository');
+
+class UserService {
+  constructor(userRepository) {
+    if (!(userRepository instanceof UserRepository)) {
+      throw new Error('UserRepository interface must be implemented');
+    }
+    this.userRepository = userRepository;
+  }
+
+  async createUser(userData) {
+    // Business logic validation
+    const { name, email } = userData;
+    
+    if (!name || !email) {
+      throw new Error('Name and email are required');
+    }
+
+    // Create domain entity
+    const user = User.create(name, email);
+    
+    if (!user.isValid()) {
+      throw new Error('Invalid user data');
+    }
+
+    // Save through repository abstraction
+    return await this.userRepository.save(user);
+  }
+
+  async getUserById(id) {
+    return await this.userRepository.findById(id);
+  }
+
+  async updateUser(id, updateData) {
+    const existingUser = await this.userRepository.findById(id);
+    
+    if (!existingUser) {
+      throw new Error('User not found');
+    }
+
+    // Apply updates based on business rules
+    if (updateData.name) {
+      existingUser.updateName(updateData.name);
+    }
+    
+    if (updateData.email) {
+      existingUser.updateEmail(updateData.email);
+    }
+
+    return await this.userRepository.update(existingUser);
+  }
+
+  async deleteUser(id) {
+    return await this.userRepository.delete(id);
+  }
+}
+
+module.exports = UserService;

package/test_repos/allowed-clean-architecture/arcvision_context/README.md

@@ -0,0 +1,93 @@
+# ArcVision System Context Artifact
+
+
+## What This Is [arcvision.context.json](./arcvision.context.json)
+
+This file is the **canonical structural context** of this codebase.
+It represents how the system actually works — not how it is described.
+
+It is generated directly from source code by ArcVision.
+
+## What This Replaces
+
+This artifact replaces:
+- Manual repository scanning
+- Tribal knowledge held by senior engineers
+- Re-explaining the system to new developers
+- Re-prompting LLMs with partial or incorrect context
+- Guessing blast radius of changes
+
+## When You Must Use This
+
+Use this artifact when:
+- Onboarding a new developer
+- Prompting an AI assistant about this codebase
+- Making architectural changes
+- Investigating unexpected behavior
+- Assessing risk before modifying core modules
+
+## What This Artifact Contains
+
+- Canonical module and dependency graph
+- Execution and data flow relationships
+- Structural roles (service, store, boundary, etc.)
+- Invariants inferred from the system
+- Impact metrics (blast radius, coupling)
+- Authority core identification
+- Hidden coupling detection
+- Architectural archetype classification
+- Analysis completeness metrics
+
+## Determinism & Trust
+
+- Generated from commit: ae164d81a70b781ce2aa48702aa493acc245b50c
+- Generation timestamp: 2026-01-22T06:51:47.253Z
+- Tool version: 0.2.14
+- Deterministic: same input → same output
+- Explicit assumptions listed inside the artifact
+
+If this artifact conflicts with human memory, **trust the artifact**.
+
+## Structural Context Hubs
+
+The following files have the highest blast radius and represent critical structural hubs in the system:
+
+- **domain/interfaces/UserRepository.js**
+  - Blast Radius: 2 files (20% of codebase)
+  - Risk: Changes here may silently propagate across the system.
+
+- **domain/models/User.js**
+  - Blast Radius: 2 files (20% of codebase)
+  - Risk: Acts as a coordination layer between components.
+
+- **adapters/http/HttpServer.js**
+  - Blast Radius: 1 files (10% of codebase)
+  - Risk: Modifications can cause widespread inconsistencies.
+
+
+
+## How to Use With AI
+
+When prompting AI tools, include this file as system context.
+Do not ask the AI to infer architecture without it.
+
+## When to Regenerate
+
+Regenerate this artifact when:
+- Core modules change
+- New services are added
+- Dependency structure shifts
+
+Run:
+
+```
+arcvision scan --upload
+```
+
+## Source of Truth
+
+This artifact is the **source of truth** for system structure.
+All explanations, decisions, and AI reasoning should reference it.
+
+Some execution script invocations are dynamically assembled at runtime and may not be statically traceable; such scripts are included 
+as execution boundaries without guaranteed call-site resolution