npm - @ngocsangairvds/vsaf - Versions diffs - 3.2.13 → 3.2.15 - Mend

@ngocsangairvds/vsaf 3.2.13 → 3.2.15

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1441) hide show

package/tools/vds-scripts/lsp_orchestrator/docs/how-to-guides/automate-with-json.md DELETED Viewed

@@ -1,159 +0,0 @@
-# How to Automate with JSON Output
-Use the LSP orchestrator in scripts and automation with structured JSON output.
----
-## Enable JSON Output
-Add the `--json-only` flag to any command:
-```bash
-vds-lsp --json-only type-check src/
-```
-## Write to File
-```bash
-vds-lsp --json-only --output results.json type-check src/
-```
-Or use shell redirection:
-```bash
-vds-lsp --json-only type-check src/ > results.json
-```
-## Parse JSON Output
-### Python
-```python
-import json
-import subprocess
-result = subprocess.run(
-    ["vds-lsp", "--json-only", "type-check", "src/"],
-    capture_output=True,
-    text=True
-)
-data = json.loads(result.stdout)
-if data.get("error"):
-    print(f"Error: {data['message']}")
-else:
-    print(f"Errors: {data['result']['summary']['errorCount']}")
-    print(f"Warnings: {data['result']['summary']['warningCount']}")
-```
-### Bash with jq
-```bash
-result=$(vds-lsp --json-only type-check src/)
-error_count=$(echo "$result" | jq -r '.result.summary.errorCount')
-if [ "$error_count" -gt 0 ]; then
-    echo "Found $error_count type errors"
-    exit 1
-fi
-```
-### JavaScript (Node.js)
-```javascript
-import { execFileSync } from 'child_process';
-const result = execFileSync('vds-lsp', ['--json-only', 'type-check', 'src/'], {
-  encoding: 'utf-8'
-});
-const data = JSON.parse(result);
-if (data.error) {
-  console.error(`Error: ${data.message}`);
-  process.exit(1);
-}
-console.log(`Errors: ${data.result.summary.errorCount}`);
-```
-## Common JSON Patterns
-### Check for Errors
-```bash
-result=$(vds-lsp --json-only type-check src/)
-has_errors=$(echo "$result" | jq '.result.summary.errorCount > 0')
-if [ "$has_errors" = "true" ]; then
-    echo "Type errors found!"
-fi
-```
-### Extract Diagnostics
-```bash
-result=$(vds-lsp --json-only diagnostics src/)
-echo "$result" | jq '.result.diagnostics[] | select(.severity == "error")'
-```
-### Get Symbol Locations
-```bash
-result=$(vds-lsp --json-only symbol "DaemonManager")
-echo "$result" | jq -r '.result.symbols[] | "\(.location.file):\(.location.line)"'
-```
-### Count Results
-```bash
-result=$(vds-lsp --json-only refs --file "src/app.py:10:5" my_func)
-count=$(echo "$result" | jq '.result.locations | length')
-echo "Found $count references"
-```
-## JSON Response Format
-### Success Response
-```json
-{
-  "result": { <command-specific-data> },
-  "error": null,
-  "message": "OK",
-  "meta": {
-    "timestamp": "2026-02-08T07:40:29.665266+00:00",
-    "tool": {
-      "name": "vds-lsp-orchestrator",
-      "version": "0.1.0"
-    },
-    "python": "3.14.3",
-    "cwd": "/path/to/workspace"
-  }
-}
-```
-### Error Response
-```json
-{
-  "error": true,
-  "message": "Failed to get diagnostics",
-  "details": {
-    "error": "LSP server timeout",
-    "timeout": 60
-  },
-  "meta": {
-    "timestamp": "2026-02-08T07:40:29.665266+00:00",
-    "tool": { "name": "vds-lsp-orchestrator", "version": "0.1.0" },
-    "python": "3.14.3"
-  }
-}
-```
-## See Also
-- [How to Use Daemon Mode](use-daemon-mode.md)
-- [Command Reference: Global Options](../reference/commands.md#global-options)
-- [For LLMs and Agents](../FOR_LLMS.md)

package/tools/vds-scripts/lsp_orchestrator/docs/how-to-guides/docker-mode.md DELETED Viewed

@@ -1,256 +0,0 @@
-# Docker Mode
-**Phase 11 Feature**: Run LSP server in an isolated Docker container for reproducible environments.
-## Overview
-Docker mode provides an isolated, reproducible environment for LSP operations. This is useful for:
-- CI/CD pipelines
-- Ensuring consistent behavior across different machines
-- Avoiding dependency conflicts
-- Running without installing Python/LSP servers on the host
-## Quick Start
-### Using Docker Flag
-Enable Docker mode for any command:
-```bash
-vds-lsp --docker type-check src/
-vds-lsp --docker diagnostics src/
-vds-lsp --docker hover src/app.py:10:5
-```
-### Building the Docker Image
-```bash
-cd WHO-project/vds-scripts/lsp_orchestrator
-docker build -t vds-lsp-orchestrator:latest .
-```
-## Docker Compose (Recommended)
-Using `docker-compose` provides better workflow management:
-```bash
-# Start the LSP server container
-cd WHO-project/vds-scripts/lsp_orchestrator
-docker-compose up -d vds-lsp
-# Run commands through the container
-docker-compose run --rm vds-lsp-cmd type-check /workspace/src/
-docker-compose run --rm vds-lsp-cmd diagnostics /workspace/src/
-docker-compose run --rm vds-lsp-cmd batch-format /workspace/src/ --apply
-# Stop the container
-docker-compose down
-```
-## Configuration
-### Environment Variables
-Set via environment:
-```bash
-export VDS_LSP_DOCKER_MODE=true
-export VDS_LSP_DOCKER_IMAGE=vds-lsp-orchestrator:latest
-```
-### Configuration File
-**`.vds-lsp/config.json`**:
-```json
-{
-  "docker_mode": true,
-  "docker_image": "vds-lsp-orchestrator:latest"
-}
-```
-**`pyproject.toml`**:
-```toml
-[tool.vds-lsp]
-docker-mode = true
-docker-image = "vds-lsp-orchestrator:latest"
-```
-### CLI Flag
-Enable per-command:
-```bash
-vds-lsp --docker type-check src/
-```
-## Volume Mounts
-Your workspace must be accessible from the container. The default setup uses:
-```yaml
-volumes:
-  - ./:/workspace:cached
-```
-This mounts your current directory to `/workspace` in the container.
-## Examples
-### Type Checking
-```bash
-# Via docker-compose
-docker-compose run --rm vds-lsp-cmd type-check /workspace/src/
-# Via docker flag
-vds-lsp --docker type-check src/
-```
-### Batch Formatting
-```bash
-# Via docker-compose
-docker-compose run --rm vds-lsp-cmd batch-format /workspace/src/ --apply --yes
-# Via docker flag
-vds-lsp --docker batch-format src/ --apply --yes
-```
-### Diagnostics with JSON Output
-```bash
-# Via docker-compose
-docker-compose run --rm vds-lsp-cmd --json-only diagnostics /workspace/src/
-# Via docker flag
-vds-lsp --docker --json-only diagnostics src/
-```
-## CI/CD Integration
-### GitHub Actions Example
-```yaml
-name: LSP Type Check
-on: [push, pull_request]
-jobs:
-  type-check:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Build Docker image
-        run: |
-          cd WHO-project/vds-scripts/lsp_orchestrator
-          docker build -t vds-lsp-orchestrator .
-      - name: Run type check
-        run: |
-          cd WHO-project/vds-scripts/lsp_orchestrator
-          docker-compose run --rm vds-lsp-cmd type-check /workspace/src/
-```
-### GitLab CI Example
-```yaml
-type-check:
-  image: docker:24
-  services:
-    - docker:24-dind
-  script:
-    - cd WHO-project/vds-scripts/lsp_orchestrator
-    - docker build -t vds-lsp-orchestrator .
-    - docker-compose run --rm vds-lsp-cmd type-check /workspace/src/
-```
-## Limitations
-### File Access
-The container must have access to your files:
-- Use volume mounts to share directories
-- Workspace paths must be accessible from the container
-- Relative paths are resolved inside the container
-### Performance
-Docker mode has slight overhead compared to native mode:
-- Container startup time (~100-200ms)
-- Filesystem access through volume mounts
-- Network communication between host and container
-### Daemon Mode
-Daemon mode is not available in Docker mode. Each command starts a fresh container.
-## Troubleshooting
-### Permission Issues
-If you encounter permission errors, ensure the container has proper access:
-```yaml
-volumes:
-  - ./:/workspace:cached  # Add :rw for read-write if needed
-```
-### Image Not Found
-Build the image first:
-```bash
-cd WHO-project/vds-scripts/lsp_orchestrator
-docker build -t vds-lsp-orchestrator:latest .
-```
-### Volume Mount Issues
-Ensure your workspace directory is mounted correctly:
-```bash
-# Test volume mount
-docker run --rm -v $(pwd):/workspace vds-lsp-orchestrator ls /workspace
-```
-## Advanced Configuration
-### Custom Dockerfile
-Create a custom Dockerfile for your environment:
-```dockerfile
-FROM python:3.14-slim
-# Install system dependencies
-RUN apt-get update && apt-get install -y git
-# Install Python dependencies
-COPY pyproject.toml uv.lock ./
-RUN pip install uv && uv sync --frozen
-# Set working directory
-WORKDIR /workspace
-# Default command
-CMD ["vds-lsp", "health"]
-```
-### Resource Limits
-Configure resource limits in `docker-compose.yml`:
-```yaml
-services:
-  vds-lsp:
-    deploy:
-      resources:
-        limits:
-          cpus: '2'
-          memory: 2G
-```
-## See Also
-- [Configuration Reference](../reference/configuration.md#platform-settings)
-- [WSL2 Optimization](wsl2-optimization.md) - For Windows users
-- [Parallel Processing](parallel-processing.md) - Performance improvements

package/tools/vds-scripts/lsp_orchestrator/docs/how-to-guides/navigate-code.md DELETED Viewed

@@ -1,116 +0,0 @@
-# How to Navigate Code
-Find symbols, go to definitions, and trace call relationships.
----
-## Find a Symbol
-Search for a class, function, or variable:
-```bash
-vds-lsp symbol "DaemonManager"
-```
-### Fuzzy Search
-```bash
-vds-lsp symbol "http" --match fuzzy
-```
-### Exact Match
-```bash
-vds-lsp symbol "DaemonManager" --match exact
-```
-### Regex Search
-```bash
-vds-lsp symbol "test_.*" --match regex
-```
-### Limit Results
-```bash
-vds-lsp symbol "Manager" --limit 10
-```
----
-## Go to Definition
-Find where a symbol is defined:
-```bash
-vds-lsp goto --file "src/app.py:10:5" my_function
-```
-**Important**: Always use `--file` with the location format `path:line:col`
----
-## Find References
-Find all places where a symbol is used:
-```bash
-vds-lsp refs --file "src/app.py:10:5" my_function
-```
-With more context lines:
-```bash
-vds-lsp refs --file "src/app.py:10:5" my_function --context 5
-```
----
-## Trace Call Hierarchy
-### Find Callers (what calls this function)
-```bash
-vds-lsp callers "process_request"
-```
-With depth and paths:
-```bash
-vds-lsp callers "process_request" --max-depth 2 --show-path
-```
-### Find Callees (what this function calls)
-```bash
-vds-lsp callees "process_request" --max-depth 2
-```
-### Export Call Graph
-```bash
-vds-lsp callers "process_request" --format mermaid --output callgraph.mmd
-```
----
-## Get Document Symbols
-List all symbols in a file:
-```bash
-vds-lsp doc-symbols src/app.py
-```
-JSON output:
-```bash
-vds-lsp --json-only doc-symbols src/app.py
-```
----
-## See Also
-- [How to Use Hover Information](use-hover.md)
-- [Command Reference: Navigation](../reference/commands.md#navigation)

package/tools/vds-scripts/lsp_orchestrator/docs/how-to-guides/parallel-processing.md DELETED Viewed

@@ -1,179 +0,0 @@
-# Parallel Processing for Batch Operations
-**Phase 10 Feature**: Speed up batch operations by processing multiple files concurrently.
-## Overview
-VDS LSP Orchestrator supports parallel processing for batch operations:
-- `batch-format`
-- `batch-organize-imports`
-- `batch-fix-all`
-By default, these operations run in parallel with auto-detected job count based on your CPU cores.
-## Basic Usage
-### Enable Parallel Processing
-Parallel processing is enabled by default:
-```bash
-vds-lsp batch-format . --apply --yes
-vds-lsp batch-organize-imports . --apply --yes
-vds-lsp batch-fix-all . --apply --yes
-```
-### Control Parallelism
-Use `--jobs` to specify the number of parallel jobs:
-```bash
-# Use 8 parallel jobs
-vds-lsp batch-format . --apply --jobs 8
-# Use 4 parallel jobs
-vds-lsp batch-organize-imports . --apply --jobs 4
-```
-### Disable Parallel Processing
-Use `--no-parallel` for sequential processing:
-```bash
-vds-lsp batch-format . --apply --no-parallel
-```
-## Performance Considerations
-### When to Use Parallel Processing
-**Best for:**
-- Large codebases with many files
-- Multi-core systems
-- Independent file operations
-**Avoid when:**
-- Limited system resources
-- Files have dependencies that require sequential processing
-- Debugging issues that may be concurrency-related
-### Job Count Guidelines
-| CPU Cores | Recommended Jobs |
-|-----------|------------------|
-| 2-4 | 2-4 |
-| 4-8 | 4-6 |
-| 8-16 | 6-10 |
-| 16+ | 8-12 |
-**Formula**: `jobs = min(cpu_count - 2, 12)` (auto-detected default)
-### Memory Usage
-Each parallel job uses additional memory. Monitor usage on systems with limited RAM:
-```bash
-# Start with fewer jobs if memory-constrained
-vds-lsp batch-format . --apply --jobs 2
-```
-## Examples
-### Format Entire Project
-```bash
-# Auto-detect optimal job count
-vds-lsp batch-format . --apply --atomic
-# Explicit job count
-vds-lsp batch-format . --apply --atomic --jobs 8
-```
-### Organize Imports with Filters
-```bash
-# Parallel processing with path filters
-vds-lsp batch-organize-imports . \
-  --include "src/**" \
-  --exclude "tests/**" \
-  --apply \
-  --jobs 6
-```
-### Fix All Issues
-```bash
-# Parallel fix-all with progress display
-vds-lsp batch-fix-all . --apply --yes --jobs 4
-```
-## Configuration
-Set defaults via environment variables or config files:
-**Environment Variables**:
-```bash
-export VDS_LSP_PARALLEL_ENABLED=true
-export VDS_LSP_PARALLEL_JOBS=8
-```
-**`.vds-lsp/config.json`**:
-```json
-{
-  "parallel_enabled": true,
-  "parallel_jobs": 8
-}
-```
-**`pyproject.toml`**:
-```toml
-[tool.vds-lsp]
-parallel-enabled = true
-parallel-jobs = 8
-```
-## Monitoring Progress
-When running in terminal mode (not `--json-only`), you'll see progress updates:
-```
-Formatting files: [████████████████████████████] 100/100
-```
-For detailed progress, use `--verbose`:
-```bash
-vds-lsp batch-format . --apply --verbose
-```
-## Troubleshooting
-### Out of Memory Errors
-Reduce the number of parallel jobs:
-```bash
-vds-lsp batch-format . --apply --jobs 2
-```
-### File Access Errors
-Some systems have limits on concurrent file handles. Reduce jobs:
-```bash
-vds-lsp batch-organize-imports . --apply --jobs 4
-```
-### Inconsistent Results
-If you encounter issues, try sequential processing:
-```bash
-vds-lsp batch-fix-all . --apply --no-parallel
-```
-## See Also
-- [Batch Operations Reference](../reference/commands.md#batch-operations)
-- [Configuration Reference](../reference/configuration.md#parallel-processing)
-- [Use Daemon Mode](use-daemon-mode.md) - Further performance improvements